postal.js/spec/SubscriptionDefinition.spec.js

QUnit.specify("postal.js", function(){
	describe("SubscriptionDefinition", function(){
		describe("When initializing SubscriptionDefinition", function() {
			var sDef,
				caughtSubscribeEvent,
				systemSubscription;
			before(function() {
				systemSubscription = postal.subscribe({
					channel: "postal",
					topic: "subscription.created",
					callback: function(data, envelope){
						if( data.event &&
							data.event == "subscription.created" &&
							data.channel == "SubDefTestChannel" &&
							data.topic == "SubDefTestTopic") {
							caughtSubscribeEvent = true;
						}
					}
				});
				sDef = new SubscriptionDefinition("SubDefTestChannel", "SubDefTestTopic", NO_OP);
			});
			after(function(){
				sDef.unsubscribe();
				systemSubscription.unsubscribe();
				caughtSubscribeEvent = false;
			});
			it("should set the channel to SubDefTestChannel", function() {
				assert(sDef.channel).equals("SubDefTestChannel");
			});
			it("should set the topic to SubDefTestTopic", function() {
				assert(sDef.topic).equals("SubDefTestTopic");
			});
			it("should set the callback", function() {
				assert(sDef.callback).equals(NO_OP);
			});
			it("should default the priority", function() {
				assert(sDef.priority).equals(50);
			});
			it("should default the constraints", function() {
				assert(sDef.constraints.length).equals(0);
			});
			it("should default the maxCalls", function() {
				assert(sDef.maxCalls).equals(0);
			});
			it("should default the onHandled callback", function() {
				assert(sDef.onHandled).equals(NO_OP);
			});
			it("should default the context", function() {
				assert(sDef.context).isNull();
			});
			it("should fire the subscription.created message", function() {
				assert(caughtSubscribeEvent).equals(true);
			});
		});

		describe("When setting ignoreDuplicates", function(){
			var sDefa = new SubscriptionDefinition("TestChannel", "TestTopic", NO_OP).ignoreDuplicates();

			it("Should add a DistinctPredicate constraint to the configuration constraints", function() {
				assert(sDefa.constraints.length).equals(1);
			});
		});

		describe("When adding a constraint", function(){
			var sDefb = new SubscriptionDefinition("TestChannel", "TestTopic", NO_OP).withConstraint(function() { });

			it("Should add a constraint", function() {
				assert(sDefb.constraints.length).equals(1);
			});
		});

		describe("When adding multiple constraints", function(){
			var sDefc = new SubscriptionDefinition("TestChannel", "TestTopic", NO_OP).withConstraints([function() { }, function() { }, function() { }]);

			it("Should add a constraint", function() {
				assert(sDefc.constraints.length).equals(3);
			});
		});

		describe("When setting the context", function(){
			var obj = {},
				sDefd = new SubscriptionDefinition("TestChannel", "TestTopic", NO_OP).withContext(obj);

			it("Should set context", function() {
				assert(sDefd.context).equals(obj);
			});
		});

		describe("When setting priority", function(){
			var sDefe = new SubscriptionDefinition("TestChannel", "TestTopic", NO_OP).withPriority(10);

			it("Should set priority", function() {
				assert(sDefe.priority).equals(10);
			});
		});

		describe("When calling subscribe to set the callback", function(){
			var sDefe = new SubscriptionDefinition("TestChannel", "TestTopic", NO_OP),
				fn = function() {};
				sDefe.subscribe(fn);

			it("Should set the callback", function() {
				assert(sDefe.callback).equals(fn);
			});
		});

		describe("When deferring the callback", function(){
			var results = [],
				sDefe = new SubscriptionDefinition("TestChannel", "TestTopic", function(data) {
					results.push(data);
				}).defer();
			sDefe.callback("second");
			results.push("first");

			it("Should defer the callback", function() {
				wait(1, function(){
					assert(results[0]).equals("first");
					assert(results[1]).equals("second");
				});
			});
		});

		describe("When delaying the callback", function(){
			var results = [],
				sDefe = new SubscriptionDefinition("TestChannel", "TestTopic", function(data) {
					results.push(data);
				}).withDelay(200);
			sDefe.callback("second");
			results.push("first");

			it("Should delay the callback", function() {
				wait(300, function(){
					assert(results[0]).equals("first");
					assert(results[1]).equals("second");
				});
			});
		});

		describe("When debouncing the callback", function(){
			var results = [],
				sDefe = new SubscriptionDefinition("TestChannel", "TestTopic", function(data) {
					results.push(data);
				}).withDebounce(800);

			it("should have only invoked debounced callback once", async(function() {
				sDefe.callback(1); // starts the two second clock on debounce
				setTimeout(function() { sDefe.callback(2); },   20); // should not invoke callback
				setTimeout(function() { sDefe.callback(3); },   80); // should not invoke callback
				setTimeout(function() { sDefe.callback(4); },  250); // should not invoke callback
				setTimeout(function() { sDefe.callback(5); },  500); // should not invoke callback
				setTimeout(function() { sDefe.callback(6); }, 1000); // should invoke callback
				setTimeout(function() {
					assert(results[0]).equals(6);
					assert(results.length).equals(1);
					resume();
				}, 2400);
			}));
		});

		describe("When throttling the callback", function(){
			var results = [],
				sDefe = new SubscriptionDefinition("TestChannel", "TestTopic", function(data) {
					results.push(data);
				}).withThrottle(500);

			it("should have only invoked throttled callback twice", async(function() {
				sDefe.callback(1); // starts the two second clock on debounce
				setTimeout(function() { sDefe.callback(800); }, 800); // should invoke callback
				for(var i = 0; i < 20; i++) {
					(function(x) { sDefe.callback(x); })(i);
				}
				setTimeout(function() {
					assert(results[0]).equals(1);
					assert(results[1]).equals(800);
					assert(results.length).equals(2);
					resume();
				}, 1500);
			}));
		});
	});
});