catarse_full 0.0.1

data/spec/javascripts/project_comments_spec.js

@@ -0,0 +1,66 @@
+describe("ProjectComments", function() {
+  var view, FB;
+  var parentView = { on: function() {} };
+
+  beforeEach(function() {
+    FB = {
+      XFBML: {
+        parse: function(){}
+      }
+    };
+    window.FB = FB;
+    spyOn(parentView, "on");
+    view = new App.views.Project.views.ProjectComments({parent: parentView, el: $('<div><div id="tab">foo</div><div id="emptyTab"></div></div>')});
+  });
+
+  describe("#activate", function(){
+    it("should bind render to parent's onSelectTab", function() {
+      expect(parentView.on).wasCalledWith('selectTab', view.render);
+    });
+  });
+
+  describe("#render", function() {
+    beforeEach(function(){
+      spyOn(FB.XFBML, "parse");
+    });
+
+    describe("when $el is not visible", function(){
+      beforeEach(function(){
+        spyOn(view.$el, "is").andReturn(false);
+        view.render();
+      });
+
+      it("should test $el visibility", function() {
+        expect(view.$el.is).wasCalledWith(':visible');
+      });
+
+      it("should not add div.fb-comments to DOM", function() {
+        expect(view.$('div.fb-comments').length).toEqual(0);
+      });
+
+      it("should not call FB.XFBML.parse", function() {
+        expect(FB.XFBML.parse).wasNotCalled();
+      });
+    });
+
+    describe("when $el is visible", function(){
+      beforeEach(function(){
+        spyOn(view.$el, "is").andReturn(true);
+        view.render();
+      });
+
+      it("should test $el visibility", function() {
+        expect(view.$el.is).wasCalledWith(':visible');
+      });
+
+      it("should add div.fb-comments to DOM", function() {
+        expect(view.$('div.fb-comments').length).toEqual(1);
+      });
+
+      it("should call FB.XFBML.parse", function() {
+        expect(FB.XFBML.parse).wasCalled();
+      });
+    });
+
+  });  
+});

data/spec/javascripts/project_sidebar_spec.js

@@ -0,0 +1,105 @@
+describe("ProjectSidebar", function() {
+  var view;
+
+  beforeEach(function() {
+    view = new App.views.Project.views.ProjectSidebar({el: $('<div></div>')});
+  });
+
+  describe("#selectReward", function(){
+    var reward = { data: function(){} };
+    beforeEach(function() {
+      spyOn(view, "$").andReturn(reward);
+      spyOn(reward, "data").andReturn('url');
+      spyOn(view, "navigate");
+      view.selectReward({ currentTarget: 'reward' });
+    });
+
+    it("should get reward and get its url", function() {
+      expect(view.$).wasCalledWith('reward');
+      expect(reward.data).wasCalledWith('new_backer_url');
+    });
+
+    it("should navigate to URL", function() {
+      expect(view.navigate).wasCalledWith('url');
+    });
+  });
+
+  describe("#sortableRewards", function() {
+    beforeEach(function() {
+      spyOn(view.$rewards, "sortable");
+    });
+
+    describe("when I can update rewards", function() {
+      beforeEach(function() {
+        spyOn(view.$rewards, "data").andReturn(true);
+        view.sortableRewards();
+      });
+
+      it("should test can_update", function() {
+        expect(view.$rewards.data).wasCalledWith('can_update');
+      });
+
+      it("should call sortable", function() {
+        expect(view.$rewards.sortable).wasCalledWith({
+          axis: 'y',
+          placeholder: "ui-state-highlight",
+          start: jasmine.any(Function),
+          stop: jasmine.any(Function),
+          update: jasmine.any(Function) 
+        });
+      });
+    });  
+
+    describe("when I can not update rewards", function() {
+      beforeEach(function() {
+        spyOn(view.$rewards, "data").andReturn(false);
+        view.sortableRewards();
+      });
+
+      it("should test can_update", function() {
+        expect(view.$rewards.data).wasCalledWith('can_update');
+      });
+
+      it("should not call sortable", function() {
+        expect(view.$rewards.sortable).wasNotCalled();
+      });
+    });
+  });  
+  
+  describe("#showNewRewardForm", function() {
+    var event = {
+      preventDefault: function() {},
+      currentTarget: {
+        data: function(){ return 'selector'; },
+        fadeOut: function(){}
+      }
+    };
+    var form = {
+      fadeIn: function(){}
+    };
+
+    beforeEach(function() {
+      spyOn(event, "preventDefault");
+      spyOn(view, "$").andCallFake(function(el){
+        return (el == 'selector' ? form : event.currentTarget);
+      });
+      spyOn(event.currentTarget, "fadeOut");
+      spyOn(form, "fadeIn");
+      view.showRewardForm(event);
+    });
+
+    it("should call fadeOut on currentTarget element", function() {
+      expect(event.currentTarget.fadeOut).wasCalled();
+    });
+
+    it("should call fadeIn on data('target') of currentTarget", function() {
+      expect(view.$).wasCalledWith('selector');
+      expect(form.fadeIn).wasCalled();
+    });
+    
+    it("should call preventDefault", function() {
+       expect(event.preventDefault).wasCalled();
+    });
+  });  
+  
+});

data/spec/javascripts/project_spec.js

@@ -0,0 +1,175 @@
+describe("Project", function() {
+  var view;
+  var parentView = { router: {route: function(){} } };
+
+  beforeEach(function() {
+    view = new App.views.Project({ parent: parentView, el: $('<div><div id="tab">foo</div><div id="emptyTab"></div></div>')});
+  });
+
+  describe("#toggleWarning", function() {
+    beforeEach(function() {
+      spyOn(view.$warning, "slideToggle");
+      view.toggleWarning();
+    });
+
+    it("should call slideToggle", function() {
+      expect(view.$warning.slideToggle).wasCalled();
+    });
+  });
+
+  describe("#loadEmbed", function() {
+    beforeEach(function(){
+      spyOn(view.$embed, "data").andReturn('path');
+      spyOn($, "get").andReturn({
+        success: function(callback) {
+          callback('HTML');
+        }
+      });
+    });
+
+    it("should call $.get when .loader is present", function(){
+      spyOn(view.$embed, 'find').andReturn([1]);
+      spyOn(view.$embed, 'html');
+
+      view.loadEmbed();
+
+      expect($.get).wasCalledWith('path');
+      expect(view.$embed.html).wasCalledWith('HTML');
+    });
+
+    it("should not call $.get when .loader is not present", function(){
+      spyOn(view.$embed, 'find').andReturn([]);
+
+      view.loadEmbed();
+
+      expect($.get).wasNotCalled();
+    });
+  });
+
+  describe("#toggleEmbed", function() {
+    beforeEach(function() {
+      spyOn(view.$embed, "slideToggle");
+      spyOn(view, "loadEmbed");
+      view.toggleEmbed();
+    });
+
+    it("should call slideToggle", function() {
+      expect(view.$embed.slideToggle).wasCalled();
+    });
+
+    it("should call loadEmbed", function() {
+      expect(view.loadEmbed).wasCalled();
+    });
+  });
+
+  describe("#selectTab", function() {
+    var $tab = { addClass: function(){}, siblings: function(){}, data: function(){} };
+    var $tabContent = { show: function(){}, siblings: function(){} };
+    var $tabSiblings = { removeClass: function(){} };
+    var $tabContentSiblings = { hide: function(){} };
+    var eventTriggered = false;
+
+    beforeEach(function() {
+      spyOn($tab, "addClass");
+      spyOn($tabContent, "show");
+      spyOn($tab, "siblings").andReturn($tabSiblings);
+      spyOn($tabContent, "siblings").andReturn($tabContentSiblings);
+      spyOn($tabSiblings, "removeClass");
+      spyOn($tabContentSiblings, "hide");
+      spyOn(view, "$").andReturn($tabContent);
+      view.on('selectTab', function(){
+        eventTriggered = true;
+      });
+      view.selectTab($tab, $tabContent);
+    });
+    
+    it("should trigger onSelectTab event", function() {
+      expect(eventTriggered).toEqual(true);
+    });
+
+    it("should remove selected class from siblings", function() {
+      expect($tab.siblings).wasCalledWith('.selected');
+      expect($tabSiblings.removeClass).wasCalledWith('selected');
+    });
+
+    it("should add selected class", function() {
+      expect($tab.addClass).wasCalledWith('selected');
+    });
+
+    it("should show tab content", function() {
+      expect($tabContent.show).wasCalled();
+    });
+
+    it("should hide other tab contents", function() {
+      expect($tabContentSiblings.hide).wasCalled();
+    });
+  });  
+  
+  describe("#onTabClick", function() {
+    var $target = $('<a data-target="#selector">');
+    var $tab = $('<div>');
+    beforeEach(function() {
+      spyOn(view, "loadTab");
+      spyOn(view, "selectTab");
+      spyOn(view, "$").andReturn($tab);
+      view.onTabClick({target: $target});
+    });
+
+    it("should call selectTab", function() {
+      expect(view.selectTab).wasCalledWith($target, $tab);
+    });
+
+    it("should call loadTab passing the obj from selector", function() {
+      expect(view.$).wasCalledWith('#selector');
+      expect(view.loadTab).wasCalledWith($tab);
+    });
+  });  
+  
+  describe("#loadTab", function() {
+    beforeEach(function() {
+      spyOn($, "get").andReturn({success: function(callback){ callback('qux'); } });
+    });
+
+    describe("when tab is empty", function() {
+      var tab = {html: function(){ return '' }, data: function(){ return '/bar' }};
+
+      beforeEach(function() {
+        spyOn(tab, "html");
+        view.loadTab(tab);
+      });
+
+      it("should fill tab with data", function() {
+        expect(tab.html).wasCalledWith('qux');
+      });
+
+      it("should get content", function() {
+        expect($.get).wasCalledWith('/bar');
+      });
+    });
+
+    describe("when tab is empty but does not have a path", function() {
+      var tab = {html: function(){ return '' }, data: function(){ return undefined; }};
+
+      beforeEach(function() {
+        view.loadTab(tab);
+      });
+
+      it("should not get content", function() {
+        expect($.get).wasNotCalled();
+      });
+    });
+
+    describe("when tab has content", function() {
+      beforeEach(function() {
+        view.loadTab(view.$('#tab'));
+      });
+
+      it("should not get content", function() {
+        expect($.get).wasNotCalled();
+      });
+    });  
+    
+    
+    
+  });  
+});

data/spec/javascripts/registration_spec.js

@@ -0,0 +1,38 @@
+describe("Registration", function() {
+  var view;
+
+  beforeEach(function(){
+    view = new App.views.Registration({el: $('<div id="foo"></div>')});
+  });
+
+  describe("#showPassword", function() {
+    beforeEach(function() {
+      spyOn(view.$password_input, 'prop');
+    });
+
+    describe("when show password is cheked", function() {
+      beforeEach(function(){
+        spyOn(view, '$').andReturn({prop: function() { return true; } });
+
+        view.showPassword({target: 'checkbox_checked'});
+      });
+
+      it("should change password input type to text", function(){
+        expect(view.$password_input.prop).wasCalledWith('type', 'text');
+      });
+    });
+
+    describe("when show password is not cheked", function() {
+      beforeEach(function(){
+        spyOn(view, '$').andReturn({prop: function() { return false; } });
+
+        view.showPassword({target: 'unchecked_checkbox'});
+      });
+
+      it("should change password input type to text", function(){
+        expect(view.$password_input.prop).wasCalledWith('type', 'password');
+      });
+    });
+
+  });
+});

data/spec/javascripts/review_form_spec.js

@@ -0,0 +1,140 @@
+describe("ReviewForm", function() {
+  var view;
+
+  beforeEach(function() {
+    view = new App.views.ReviewForm({ el: $('<form style="display:none;"></form>')});
+  });
+
+  describe("#activate", function() {
+    describe("when live_in_brazil is not checked", function(){
+      var el;
+      beforeEach(function(){
+        el = { length: 0, on: function(){}, hide: function(){} };
+        spyOn(view, '$').andReturn(el);
+        spyOn(el, "hide");
+        view.activate();
+      });
+
+      it("should fadeOut address_data fieldset", function(){
+        expect(view.$).wasCalledWith("#live_in_brazil:checked");
+        expect(view.$).wasCalledWith("fieldset.address_data");
+        expect(el.hide).wasCalled();
+      });
+
+    });
+  });
+
+  describe("#validate", function() {
+    describe("when all inputs are valid", function() {
+      var valid;
+
+      beforeEach(function() {
+        view.$el.append('<input required="required"/><input />');
+        $('html').append(view.$el);
+        var $inputs = view.$('input');
+        spyOn(view, "$").andReturn($inputs);
+        valid = view.validate();
+      });
+      
+      it("should look only for visible elements", function() {
+        expect(view.$).wasCalledWith('input:visible');
+      });
+
+      it("should return false", function() {
+        expect(valid).toEqual(false);
+      });
+    });  
+
+    describe("when all inputs are valid", function() {
+      beforeEach(function() {
+        view.$el.html('<input /><input />');
+      });
+
+      it("should return true", function() {
+        expect(view.validate()).toEqual(true);
+      });
+    });  
+  });  
+
+  describe("#acceptTerms", function() {
+    beforeEach(function() {
+      spyOn(view, "updateBacker");
+    });
+
+    describe("when validate is true", function() {
+      beforeEach(function() {
+        spyOn(view, "validate").andReturn(true);
+        view.acceptTerms();
+      });
+
+      it("should call updateBacker", function() {
+        expect(view.updateBacker).wasCalled();
+      });
+    });  
+    
+    describe("when validate is false", function() {
+      beforeEach(function() {
+        spyOn(view, "validate").andReturn(false);
+        view.acceptTerms();
+      });
+
+      it("should not call updateBacker", function() {
+        expect(view.updateBacker).wasNotCalled();
+      });
+    });  
+  });  
+
+  describe("#invalid", function() {
+    var input = { addClass: function(){} };
+
+    beforeEach(function() {
+      spyOn(input, "addClass");
+      spyOn(view, "$").andReturn(input);
+      view.invalid({ currentTarget: 'error input' })
+    });
+
+    it("should get event currentTarget", function() {
+       expect(view.$).wasCalledWith('error input');
+    });
+    
+    it("should add class to input", function() {
+      expect(input.addClass).wasCalledWith('error');
+    });
+  });  
+  
+  describe("#checkInput", function() {
+    var input = { removeClass: function(){} };
+
+    beforeEach(function() {
+      spyOn(input, "removeClass");
+      spyOn(view, "$").andReturn(input);
+    });
+    
+    describe("when event.currentTarget.checkValidity is false", function() {
+      var currentTarget = { checkValidity: function(){ return false; } };
+      beforeEach(function() {
+        view.checkInput({ currentTarget: currentTarget })
+      });
+
+      it("should not call removeClass", function() {
+        expect(input.removeClass).wasNotCalled();
+      });
+    });
+
+    describe("when event.currentTarget.checkValidity is true", function() {
+      var currentTarget = { checkValidity: function(){ return true; } };
+      beforeEach(function() {
+        view.checkInput({ currentTarget: currentTarget })
+      });
+
+      it("should get event currentTarget", function() {
+        expect(view.$).wasCalledWith(currentTarget);
+      });
+
+      it("should remove class to input", function() {
+        expect(input.removeClass).wasCalledWith('error');
+      });
+    });  
+  });  
+});
+