dl/tests/queue/QueuePublisherSpec.js

DreamLab Libs

var QueuePath = '../../lib/queue/';

var core = require('core');
var rewire = require('rewire');

var Event = core.event.Event;
var CredentialsProvider = core.credentials.CredentialsProvider;
var RbmqExchange = core.client.rabbitmq.RbmqExchange;
var RbmqOutcomingMessage = core.client.rabbitmq.RbmqOutcomingMessage;
var QueueMessage = require(QueuePath + 'QueueMessage.js').QueueMessage;

describe('QueuePublisher', function () {
    var CredentialsProviderMock;
    var RbmqExchangeMock;
    var dsData = {
        "exchange" : {
            "exchange.noDeclare": true,
            "connection.login": "test-int",
            "qaas.version": 3,
            "connection.password": "test234",
            "exchange.name": "E:offline:exchange_1",
            "connection.vhost": "test-int"
        },
        "hosts": [1, 2]
    };
    var QueuePublisher;
    var instance;
    var message;
    var rewireQueuePublisher;

    beforeEach(function () {
        CredentialsProviderMock = jasmine.createSpy('CredentialsProvider');
        CredentialsProviderMock.addEventListener = jasmine.createSpy('CredentialsProvider.addEventListener').
        andCallFake(function (eventname, callback, ctx) {
            if (eventname == CredentialsProvider.Event.LOAD) {
                callback.call(ctx, {data: dsData});
            }
        });
        CredentialsProviderMock.get = jasmine.createSpy('CredentialsProviderMock.get').andCallFake(function (cb) {
            cb(null, dsData);
        })
        CredentialsProviderMock.getCredentialId = jasmine.createSpy('CredentialsProvider.getCredentailId').andReturn('test');
        CredentialsProviderMock.refresh = jasmine.createSpy('CredentialsProvider.getCredentailId').andReturn('test');
        CredentialsProviderMock.andReturn(CredentialsProviderMock);

        RbmqExchangeMock = jasmine.createSpy('RbmqExchangeMock');
        RbmqExchangeMock.publish = jasmine.createSpy('RbmqExchangeMock.publis').andCallFake(function (msg) {
            msg.setPublished();
            msg.dispatchEvent(new Event(QueueMessage.Event.PUBLISHED, {
                message: msg
            }));
        });
        RbmqExchangeMock.addEventListener = jasmine.createSpy('RbmqExchangeMock.addEventListener').andCallFake(function (){});
        RbmqExchangeMock.open = jasmine.createSpy('RbmqExchangeMock.addEventListener').andCallFake(function (){});
        RbmqExchangeMock.removeAllEventListeners = jasmine.createSpy('RbmqExchangeMock.addEventListener').andCallFake(function (){});
        RbmqExchangeMock.andReturn(RbmqExchangeMock);

        rewireQueuePublisher = rewire(QueuePath + 'QueuePublisher.js');

        rewireQueuePublisher.__set__('RbmqExchange', RbmqExchangeMock);

        QueuePublisher = rewireQueuePublisher.QueuePublisher;
        QueuePublisher.prototype._onCredentialsLoaded = function () {
            this._onConnected();
        };

        message = new QueueMessage();
        message.setBody("od");

    });


    it('require', function () {
        expect(function () {
            var QueuePublisher = require('../../lib/queue/QueueClient.js').QueuePublisher;
        }).not.toThrow();
    });

   describe('publish buffer', function () {
        beforeEach(function () {
            instance = new QueuePublisher(CredentialsProviderMock);
            instance.setPublishBufferSize(10);
            instance.initialize();
            instance._onDisconnected();

        });
        it('should add to buffer message if there is not connection to RabbitMQ', function () {
            instance.publish(message);
            expect(RbmqExchangeMock.publish).not.toHaveBeenCalled();
            expect(message.isPublished()).toBe(false);
            expect(instance._publishBuffer.length).toBe(1);
        });

        it('should publish buffered message when there is connection', function () {
            instance.publish(message);
            instance._onConnected();
            instance._onChannelOpened();
            expect(RbmqExchangeMock.publish).toHaveBeenCalled();
            expect(message.isPublished()).toBe(true);
            expect(instance._publishBuffer.length).toBe(0);
        });


        it('should not ditspath event REJECTED when message was queued', function () {
            var callback = jasmine.createSpy('callback');
            message.addEventListener(QueueMessage.Event.REJECTED, callback);
            instance.publish(message);
            expect(callback).not.toHaveBeenCalled();
            expect(instance._publishBuffer.length).toBe(1);
        });

        it('should dispath event PUBLISH after queued message was published', function () {
            var callback = jasmine.createSpy('callback');
            message.addEventListener(QueueMessage.Event.PUBLISHED, callback);

            runs(function () {
                instance.publish(message);
                instance._onConnected()
                instance._onChannelOpened();
            });

            waitsFor(function () {
                return message.isPublished() == true && callback.callCount > 0;
            });

            runs(function () {
                expect(callback).toHaveBeenCalled();
            });


        });

        it('should dispath event when message buffer limit exceeded', function () {
            instance.setPublishBufferSize(2);
            var queuePublisherCounter = 0;
            var queueMessageCounter = 0;
            instance.addEventListener(QueuePublisher.Event.MESSAGE_BUFFER_EXCEEDED, function () {
                queuePublisherCounter++;
            });
            message.addEventListener(QueueMessage.Event.REJECTED, function (ev) {
                expect(ev.data.error.code).toBe(QueuePublisher.Error.BUFFER_LIMIT_EXCEEDED);
                queueMessageCounter++;;

            });
            runs(function () {
                for ( var i = 0; i < 10; ++i) {
                  instance.publish(message);
                }
            });
            waitsFor(function () {
                return (queuePublisherCounter > 1 &&  queueMessageCounter > 1);
            });
            runs(function() {
                expect(queueMessageCounter).toBe(8);
                expect(queuePublisherCounter).toBe(8);
            });


        });


   });
});