catarse_full 0.0.1

data/spec/javascripts/backer_spec.js

@@ -0,0 +1,74 @@
+describe("Backer", function() {
+  var view;
+  var reward = $('<input type="radio" />');
+
+  beforeEach(function() {
+    view = new App.views.Backer({el: $('<div></div>')});
+  });
+
+  describe('#reward', function(){
+    var reward;
+
+    beforeEach(function() {
+      spyOn(view, "$").andReturn({ length: 1, val: function(){return 1;} });
+      view.rewards = [
+        {id: 1}, 
+        {id: 2}
+      ];
+      reward = view.reward();
+    });
+
+    it("should return reward using id from selector result", function() {
+      expect(reward).toEqual({id: 1});
+    });
+
+    it("should search for selected reward", function() {
+      expect(view.$).wasCalledWith('input[type=radio]:checked');
+    });
+  });
+
+  describe("#clickReward", function() {
+    beforeEach(function() {
+      spyOn(view, "$").andReturn(reward);
+      spyOn(view, "selectReward");
+      spyOn(view, "reward").andReturn({id: 1, minimum_value: 10});
+      spyOn(view.value, "val");
+      view.clickReward({ currentTarget: 'target' });
+    });
+
+    it("should set value to reward minimum value", function() {
+      expect(view.reward).wasCalled();
+      expect(view.value.val).wasCalledWith(10);
+    });
+
+    it("should call selectReward", function() {
+      expect(view.selectReward).wasCalledWith(reward);
+    });
+  });
+
+  describe("#selectReward", function() {
+    var choice = { addClass: function(){} }
+    beforeEach(function() {
+      spyOn(choice, "addClass");
+      spyOn(reward, "prop");
+      spyOn(reward, "parents").andReturn(choice);
+      spyOn(view.choices, "removeClass");
+      view.selectReward(reward);
+    });
+
+    it("should add class selected to choice where reward is in", function() {
+      expect(reward.parents).wasCalledWith('.choice:first');
+      expect(choice.addClass).wasCalledWith('selected');
+    });
+
+    it("should remove selected class from choices", function() {
+      expect(view.choices.removeClass).wasCalledWith('selected');
+    });
+    
+    it("should set prop checked to true", function() {
+      expect(reward.prop).wasCalledWith('checked', true);
+    });
+    
+  });  
+  
+});

data/spec/javascripts/explore_spec.js

@@ -0,0 +1,211 @@
+describe("Explore", function() {
+  var view;
+  var parentView = { $search: { val: function(){} }, router: {route: function(){} } };
+
+  beforeEach(function() {
+    view = new App.views.Explore({ parent: parentView });
+  });
+  
+  describe("#$window", function() {
+    it("should return $(window)", function() {
+      expect(view.$window()).toEqual($(window));
+    });
+  });  
+  
+  describe("#isLoaderDivVisible", function() {
+    describe("when loader is in visible portion of window", function() {
+      beforeEach(function() {
+        var w = {
+          scrollTop: function(){
+            return 1;
+          },
+          height: function(){
+            return 1;
+          }
+        };
+        spyOn(view.$loaderDiv, "is").andReturn(true);
+        spyOn(view.$loaderDiv, "offset").andReturn({top: 1});
+        spyOn(view, "$window").andReturn(w);
+      });
+      it("should return true", function() {
+        expect(view.isLoaderDivVisible()).toEqual(true);
+      });
+    });
+
+    describe("when loader is not in visible portion of window", function() {
+      beforeEach(function() {
+        var w = {
+          scrollTop: function(){
+            return 1;
+          },
+          height: function(){
+            return 0;
+          }
+        };
+        spyOn(view.$loaderDiv, "offset").andReturn({top: 1});
+        spyOn(view, "$window").andReturn(w);
+      });
+      it("should return false", function() {
+        expect(view.isLoaderDivVisible()).toEqual(false);
+      });
+    });
+  });  
+  
+  describe("#setInitialFilter", function() {
+    describe("when parent has search set", function() {
+      it("set filter for search", function() {
+        view.parent = { $search: $('<input type="text" value="foo">') };
+        view.setInitialFilter();
+        expect(view.filter).toEqual({
+          pg_search: 'foo'
+        });
+      });
+    });  
+
+    describe("when parent does not have search set", function() {
+      it("should assign default filters", function() {
+        view.setInitialFilter();
+        expect(view.filter).toEqual({
+          recommended: true,
+          not_expired: true
+        });
+      });
+    });  
+  });  
+  
+  describe("#activate", function() {
+    it("should assing loader", function() {
+      expect(view.$loader).toEqual(jasmine.any(Object));
+    });
+    
+    it("should assing false to EOF results", function() {
+      expect(view.EOF).toEqual(false);
+    });
+
+    it("should assing results", function() {
+      expect(view.$results).toEqual(jasmine.any(Object));
+    });
+    
+    it("should call setInitialFilter", function() {
+      spyOn(view, "setInitialFilter");
+      view.activate();
+      expect(view.setInitialFilter).wasCalled();
+    });
+  });
+
+  describe("#followRoute", function() {
+    var el;
+
+    beforeEach(function() {
+      spyOn(view, "firstPage");
+      spyOn(view, "fetchPage");
+      spyOn(view, "selectLink");
+      view.followRoute('recent', 'recent', []);
+    });
+
+    it("should assign filter to view", function() {
+      expect(view.filter).toEqual({recent: true});
+    });
+
+    it("should call firstPage", function() {
+      expect(view.firstPage).wasCalled();
+    });
+
+    it("should call fetchPage", function() {
+      expect(view.fetchPage).wasCalled();
+    });
+
+    it("should call selectLink", function() {
+      expect(view.selectLink).wasCalled();
+    });
+  });
+
+  describe("#firstPage", function() {
+    beforeEach(function() {
+      view.EOF = true;
+      view.filter.page = 2;
+      spyOn(view, "fetchPage");
+      spyOn(view.$results, "html");
+      view.firstPage();
+    });
+
+    it("should assign false to EOF", function() {
+      expect(view.EOF).toEqual(false);
+    });
+
+    it("should clear results", function() {
+      expect(view.$results.html).wasCalledWith('');
+    });
+
+    it("assign 1 to filter.page", function() {
+      expect(view.filter.page).toEqual(1);
+    });
+  });  
+  
+  describe("#fetchPage", function() {
+    describe("when EOF is true and isLoaderDivVisible is true", function(){
+      beforeEach(function() {
+        view.EOF = true;
+        spyOn(view, "isLoaderDivVisible").andReturn(false);
+        spyOn(view.$loader, "show");
+        view.fetchPage();
+      });
+
+      it("should not increment page", function() {
+        expect(view.filter.page).toEqual(1);
+      });
+
+      it("should not show loader", function() {
+        expect(view.$loader.show).wasNotCalled();
+      });
+    });
+
+    describe("when EOF is false", function(){
+      beforeEach(function() {
+        view.EOF = false;
+        spyOn(view, "isLoaderDivVisible").andReturn(true);
+        spyOn(view.$loader, "show");
+        view.fetchPage();
+      });
+
+      it("should increment page", function() {
+        expect(view.filter.page).toEqual(2);
+      });
+
+      it("should show loader", function() {
+        expect(view.$loader.show).wasCalled();
+      });
+    });
+  });
+
+  describe("#onSuccess", function() {
+    beforeEach(function() {
+      spyOn(view.$results, "append");
+      spyOn(view.$loader, "hide");
+      
+      view.onSuccess('test data');
+    });
+
+    it("should append data to $results", function() {
+      expect(view.$results.append).wasCalledWith('test data');
+    });
+    
+    it("should show loader", function() {
+      expect(view.$loader.hide).wasCalled();
+    });
+  });  
+
+  describe("onScroll", function() {
+    beforeEach(function() {
+      spyOn(view, "fetchPage");
+      view.onScroll();
+    });
+    
+    it("call fetchPage", function() {
+      expect(view.fetchPage).wasCalled();
+    });
+    
+  });  
+  
+});  
+

data/spec/javascripts/feedback_support_spec.js

@@ -0,0 +1,41 @@
+describe("FeedbackSupport", function() {
+  var view;
+
+  beforeEach(function() {
+    view = new App.views.FeedbackSupport({el: $('<div></div>')});
+  });
+
+  describe("#openFeedbackSupport", function(){
+    beforeEach(function(){
+      spyOn(view.$feedbackSupportClosed, 'fadeOut');
+      spyOn(view.$feedbackSupportOpened, 'fadeIn');
+
+      view.openFeedbackSupport();
+    });
+
+    it("should call fadeIn on feedback opened", function() {
+      expect(view.$feedbackSupportOpened.fadeIn).wasCalled();
+    });
+
+    it("should call fadeOut on feedback closed", function() {
+      expect(view.$feedbackSupportClosed.fadeOut).wasCalled();
+    });
+  });
+
+  describe("#closeFeedbackSupport", function(){
+    beforeEach(function(){
+      spyOn(view.$feedbackSupportClosed, 'fadeIn');
+      spyOn(view.$feedbackSupportOpened, 'fadeOut');
+
+      view.closeFeedbackSupport();
+    });
+
+    it("should call fadeOut on feedback opened", function() {
+      expect(view.$feedbackSupportOpened.fadeOut).wasCalled();
+    });
+
+    it("should call fadeIn on feedback closed", function() {
+      expect(view.$feedbackSupportClosed.fadeIn).wasCalled();
+    });
+  });
+});

data/spec/javascripts/mix_panel_spec.js

@@ -0,0 +1,101 @@
+describe("MixPanel", function() {
+  var view;
+  var mixpanel;
+
+  beforeEach(function(){
+    view = new App.views.MixPanel();
+    window.mixpanel = mixpanel = {
+      name_tag: function(){},
+      identify: function(){},
+      track: function(){}
+    };
+    spyOn(mixpanel, "name_tag");
+    spyOn(mixpanel, "identify");
+    spyOn(mixpanel, "track");
+  });
+
+  describe("#identifyUser", function() {
+    var user = {id: 1, name: "Foo Bar"};
+
+    beforeEach(function() {
+      var $el = Backbone.$('<body></body>');
+      $el.data('user', user);
+      view.setElement($el, false);
+      view.identifyUser();
+    });
+
+    it("should set user", function() {
+      expect(view.user).toEqual(user);
+    });
+
+    it("should give a mixpanel nametag to user", function() {
+      expect(mixpanel.name_tag).wasCalledWith(user.id + '-' + user.name);
+    });
+    
+    it("should indentify user", function() {
+      expect(mixpanel.identify).wasCalledWith(user.id);
+    });
+  });  
+  
+  describe("#trackOnMixPanel", function() {
+    var on = jasmine.createSpy().andCallFake(function(event, callback){
+      callback();
+    });
+    var target = '#rewards .clickable';
+    var event = 'click';
+    var default_options = {
+      'page name':  document.title,
+      'user_id':    null,
+      'project':    null,
+      'url':        window.location
+    };
+    var text = 'Clicked on a reward';
+
+    beforeEach(function() {
+      spyOn(view, "$").andReturn({on: on});
+      spyOn(view, "identifyUser");
+      view.trackOnMixPanel(target, event, text);
+    });
+
+    it("should attach callback to event on target", function() {
+      expect(view.$).wasCalledWith(target);
+      expect(on).wasCalledWith(event, jasmine.any(Function));
+    });
+
+    it("should identify user in the callback", function() {
+      expect(view.identifyUser).wasCalled();
+    });
+
+    it("should call track with default options", function() {
+      expect(mixpanel.track).wasCalledWith(text, default_options);
+    });
+  });  
+  
+  describe("#activate", function() {
+    beforeEach(function() {
+      spyOn(view, "trackUserClickOnProjectsImage");
+      spyOn(view, "trackUserClickOnProjectsTitle");
+      spyOn(view, "trackUserClickOnBackButton");
+      spyOn(view, "trackUserClickOnRecommendedProject");
+      spyOn(view, "trackUserClickOnReviewAndMakePayment");
+      spyOn(view, "trackUserClickOnAcceptTerms");
+      spyOn(view, "trackUserClickOnPaymentButton");
+      spyOn(view, "trackUserClickOnReward");
+      view.activate();
+    });
+    
+    it("should call all track methods", function() {
+      expect(view.trackUserClickOnProjectsImage).wasCalled();
+      expect(view.trackUserClickOnProjectsTitle).wasCalled();
+      expect(view.trackUserClickOnBackButton).wasCalled();
+      expect(view.trackUserClickOnRecommendedProject).wasCalled();
+      expect(view.trackUserClickOnReviewAndMakePayment).wasCalled();
+      expect(view.trackUserClickOnAcceptTerms).wasCalled();
+      expect(view.trackUserClickOnPaymentButton).wasCalled();
+      expect(view.trackUserClickOnReward).wasCalled();
+    });
+    
+  });  
+  
+});  
+

data/spec/javascripts/permalink_spec.js

@@ -0,0 +1,50 @@
+describe("Permalink", function() {
+  var view;
+
+  beforeEach(function() {
+    view = new App.views.ProjectForm.views.Permalink({ el: $('<input pattern="^(\\w|-)+$">') });
+  });
+
+  describe("checkPermalink", function() {
+    var get;
+    beforeEach(function() {
+      get = spyOn($, "get");
+    });
+
+    describe("when pattern is matched", function() {
+      beforeEach(function() {
+        spyOn(view.$el, "trigger");
+        get.andReturn({ complete: function(callback){ callback({ status: 200 }); } });
+        view.$el.val('a');
+      });
+
+      it("should not trigger invalid if return status is 404", function() {
+        get.andReturn({ complete: function(callback){ callback({ status: 404 }); } });
+        view.checkPermalink();
+        expect(view.$el.trigger).wasNotCalled();
+      });
+
+      it("should trigger invalid if return status is not 404", function() {
+        view.checkPermalink();
+        expect(view.$el.trigger).wasCalledWith('invalid');
+      });
+      
+      it("should search for permalink", function() {
+        view.checkPermalink();
+        expect($.get).wasCalledWith('/pt/a');
+      });
+    });
+
+    describe("when pattern is not matched", function() {
+      beforeEach(function() {
+        view.$el.val('wont match');
+        view.checkPermalink();
+      });
+
+      it("should not search for permalink", function() {
+        expect($.get).wasNotCalled();
+      });
+    });  
+  });  
+});  
+