catarse_full 0.0.1

data/spec/javascripts/skull_spec.js

@@ -0,0 +1,103 @@
+describe("Skull.View", function(){
+  var ViewClass, view, parent, root;
+
+  beforeEach(function(){
+    root = { router: { route: function(){} } };
+    parent = { parent: root };
+    ViewClass = Skull.View.extend({ parent: parent, el: 'test' });
+    view = new ViewClass();
+  });
+  
+  describe(".addChild", function() {
+    beforeEach(function() {
+      ViewClass.addChild('NewChild', {el: 'test'}, {});
+    });
+
+    it("should assign new class to parent views object", function() {
+      expect(ViewClass.views.NewChild).toEqual(jasmine.any(Function));
+    });
+    
+    it("should assign el to view class", function() {
+      expect(ViewClass.views.NewChild.el).toEqual('test');
+    });
+
+    it("should initialize views object as empy in new class", function() {
+      expect(ViewClass.views.NewChild.views).toEqual({});
+    });
+  });  
+  
+  describe(".extend", function() {
+    it("should have object views in constructor", function() {
+      expect(ViewClass.views).toEqual(jasmine.any(Object));
+    });
+  });
+
+  describe("#addView", function() {
+    var ChildClass;
+
+    beforeEach(function() {
+      ChildClass = Skull.View.extend({ el: 'child' });
+      view.addView('childClass', ChildClass);
+    });
+    
+    it("should add instance of view object to the view if it is not there", function() {
+      expect(view._childClass).toEqual(jasmine.any(ChildClass));
+    });
+
+    it("should not create new instance if it's already in there", function() {
+      var AnotherClass = jasmine.createSpy('AnotherClass');
+      view.addView('childClass', AnotherClass);
+      expect(AnotherClass).wasNotCalled();
+      expect(view._childClass).toEqual(jasmine.any(ChildClass));
+    });
+  });  
+  
+  describe("#rootView", function() {
+    it("should return root view", function() {
+      expect(view.rootView()).toEqual(root);
+    });
+  });  
+
+  describe("#router", function() {
+    it("should return rootView router", function() {
+      view.router();
+      expect(view.router()).toEqual(view.rootView().router);
+    });
+  });  
+  
+  describe("#route", function() {
+    var routeName = 'route_name';
+    beforeEach(function() {
+      spyOn(view.router(), "route");
+      view.route(routeName);
+    });
+
+    it("should create route in rootView router", function() {
+      expect(view.router().route).wasCalledWith(routeName, routeName.split("/")[0], jasmine.any(Function));
+    });
+  });
+  
+  describe("#createViewGetters", function() {
+    beforeEach(function() {
+      ViewClass.addChild('ChildClass', { el: '.child' });
+      ViewClass.addChild('AnotherChildClass', { el: '.another-child' });
+      spyOn(view, "addView");
+      var $el = Backbone.$('<div><div class="child"></div></div>');
+      view.setElement($el, false);
+      view.createViewGetters();
+    });
+
+    it("should not call the getter if the child el is present in parent's DOM", function() {
+      expect(view.addView).wasNotCalledWith('anotherChildClass', ViewClass.views.AnotherChildClass);
+    });
+
+    it("should call the getter if the child el is present in parent's DOM", function() {
+      expect(view.addView).wasCalledWith('childClass', ViewClass.views.ChildClass);
+    });
+    
+    it("should define a getter that calls addView with keys and values of views object", function() {
+      view.anotherChildClass; 
+      expect(view.addView).wasCalledWith('anotherChildClass', ViewClass.views.AnotherChildClass);
+    });
+  });  
+});

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,93 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+  - application.js
+  - app/assets/javascripts/lib/jquery.js
+  - assets/jquery_ujs.js
+  - app/assets/javascripts/lib/underscore.js
+  - app/assets/javascripts/lib/backbone.js
+  - app/assets/javascripts/lib/skull.js
+  - app/assets/javascripts/lib/infinite_scroll.js
+  - assets/best_in_place.js
+  - app/assets/javascripts/lib/*.js
+  - app/assets/javascripts/app/app.js
+  - app/assets/javascripts/app/project.js
+  - app/assets/javascripts/app/review.js
+  - app/assets/javascripts/app/registration.js
+  - app/assets/javascripts/app/updates.js
+  - app/assets/javascripts/**/*.js
+
+asset_paths:
+  - app/assets/javascripts
+  - vendor/assets/javascripts
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+  - 'helpers/**/*.js'
+
+# spec_files
+#
+# Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - '**/*[sS]pec.js'
+#
+spec_files:
+  - '**/*[sS]pec.js'
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir:
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir: spec/javascripts

data/spec/javascripts/timed_input_spec.js

@@ -0,0 +1,64 @@
+describe("TimedInput", function() {
+  var ViewClass, view;
+
+  beforeEach(function() {
+    ViewClass = Skull.View.extend(_.extend({ el: 'test' }, Skull.TimedInput));
+    view = new ViewClass();
+  });
+
+  describe("setupTimedInput", function() {
+    beforeEach(function() {
+      spyOn(view.$el, "keyup");
+      view.setupTimedInput();
+    });
+
+    it("should bind the setTimer to the keyup event of $el", function() {
+      expect(view.$el.keyup).wasCalledWith(view.setTimer);
+    });
+  });
+
+  describe("setTimer", function() {
+    beforeEach(function() {
+      spyOn(window, "setTimeout").andCallFake(function(callback, timeout){
+        callback();
+        return 123;
+      });
+      spyOn(view.$el, "trigger");
+    });
+    
+    describe("when there is already a timer set", function() {
+      beforeEach(function() {
+        view.timeoutID = 456;
+        spyOn(window, "clearTimeout");
+        view.setTimer();
+      });
+
+      it("should cancell the previous timeout before setting a new one", function() {
+        expect(window.clearTimeout).wasCalledWith(456);
+      });
+
+      it("should store the timeoutID", function() {
+        expect(view.timeoutID).toEqual(123);
+      });
+    });
+
+    describe("when there is no timer set", function() {
+      beforeEach(function() {
+        view.setTimer('event');
+      });
+
+      it("should call the trigger the timedKeyup inside callback", function() {
+        expect(view.$el.trigger).wasCalledWith('timedKeyup', 'event');
+      });
+
+      it("should call the setTimeout", function() {
+        expect(window.setTimeout).wasCalledWith(jasmine.any(Function), view.timeout);
+      });
+
+      it("should store the timeoutID", function() {
+        expect(view.timeoutID).toEqual(123);
+      });
+    });  
+  });  
+});  
+

data/spec/javascripts/updates_spec.js

@@ -0,0 +1,49 @@
+describe("Updates", function() {
+  var view;
+
+  beforeEach(function() {
+    view = new App.views.Project.views.Updates({ parent: { on: function(){} } });
+    app = new App();
+  });
+
+  describe("#onUpdateCreate", function() {
+    beforeEach(function() {
+      spyOn(view.$results, "prepend");
+      spyOn(app, "flash");
+      view.onUpdateCreate(null, 'test');
+    });
+
+    it("should prepend data", function() {
+      expect(view.$results.prepend).wasCalledWith('test');
+    });
+
+    it("should display flash", function() {
+      expect(app.flash.wasCalled();
+    });
+  });
+
+  describe("#onUpdateDestroy", function() {
+    var $target;
+    var $count;
+    beforeEach(function() {
+      view.parent = { $: function(){} };
+      $target = $('<div class="update">');
+      $count = $('<div class="count">');
+      spyOn(window, "$").andReturn($target);
+      spyOn($target, "remove");
+      spyOn(view.parent, "$").andReturn($count);
+      spyOn($count, "html");
+
+      view.onUpdateDestroy({currentTarget: $target});
+    });
+
+    it("should get currentTarget and remove it", function() {
+      expect(window.$).wasCalledWith($target);
+      expect($target.remove).wasCalled();
+    });
+
+     it("should update count", function() {
+       expect($count.html).wasCalledWith(' (0)');
+     });
+  });
+});

data/spec/javascripts/video_url_spec.js

@@ -0,0 +1,42 @@
+describe("VideoUrl", function(){
+  var view;
+
+  beforeEach(function(){
+    view = new App.views.ProjectForm.views.VideoUrl({ el: $('<input value="http://video.url" data-path="check_video_path">') });
+  });
+
+  describe("checkVideoUrl", function(){
+    var get;
+    beforeEach(function() {
+      get = spyOn($, "get").andReturn({ success: function(){} });
+      spyOn(view.$el, "trigger");
+    });
+
+    it("should call using path in data-path and send the val as url", function(){
+      view.checkVideoUrl();
+      expect($.get).wasCalledWith('check_video_path?url=' + encodeURIComponent('http://video.url'));
+    });
+
+    describe("when video url is not valid", function(){
+      beforeEach(function(){
+        get.andReturn({ success: function(callback){ callback(null); } });
+        view.checkVideoUrl();
+      });
+
+      it("should trigger invalid", function(){
+        expect(view.$el.trigger).wasCalledWith('invalid');
+      });
+    });
+
+    describe("when video url is valid", function(){
+      beforeEach(function(){
+        get.andReturn({ success: function(callback){ callback({ video_id: 111 }); } });
+        view.checkVideoUrl();
+      });
+
+      it("should not trigger invalid", function(){
+        expect(view.$el.trigger).wasNotCalled();
+      });
+    });
+  });
+});

data/spec/lib/blog_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Blog do
+  describe ".fetch_last_posts" do
+    it "should fetch last posts from the blog url in configuration" do
+      ::Configuration[:blog_url] = 'test'
+      Blog.fetch_last_posts
+    end
+  end
+end

data/spec/lib/payment_engines_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe PaymentEngines do
+  let(:engine){ {name: 'test', review_path: ->(backer){ "/#{backer}" }, locale: 'en'} }
+  let(:engine_pt){ {name: 'test pt', review_path: ->(backer){ "/#{backer}" }, locale: 'pt'} }
+  let(:backer){ FactoryGirl.create(:backer) }
+  before{ PaymentEngines.clear }
+
+  describe ".register" do
+    before{ PaymentEngines.register engine }
+    subject{ PaymentEngines.engines }
+    it{ should == [engine] }
+  end
+
+  describe ".clear" do
+    before do
+      PaymentEngines.register engine
+      PaymentEngines.clear
+    end
+    subject{ PaymentEngines.engines }
+    it{ should be_empty }
+  end
+
+  describe ".configuration" do
+    subject{ PaymentEngines.configuration }
+    it{ should == ::Configuration }
+  end
+
+  describe ".create_payment_notification" do
+    subject{ PaymentEngines.create_payment_notification({ backer_id: backer.id, extra_data: { test: true } }) }
+    it{ should == PaymentNotification.where(backer_id: backer.id).first }
+  end
+
+  describe ".find_payment" do
+    subject{ PaymentEngines.find_payment({ id: backer.id }) }
+    it{ should == backer }
+  end
+
+  describe ".engines" do
+    subject{ PaymentEngines.engines }
+    before do
+      PaymentEngines.register engine 
+      PaymentEngines.register engine_pt
+    end
+    context "when locale is pt" do
+      before do
+        I18n.locale = :pt
+      end
+      it{ should == [engine_pt, engine] }
+    end
+
+    context "when locale is en" do
+      before do
+        I18n.locale = :en
+      end
+      it{ should == [engine, engine_pt] }
+    end
+  end
+end

data/spec/mailers/notifications_mailer_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe NotificationsMailer do
+  let(:notification){ create(:notification, notification_type: create(:notification_type, name: 'confirm_backer'), mail_params: {project_name: create(:project).name}, user: create(:user)) }
+  subject{ NotificationsMailer.notify(notification) }
+
+  before do
+    notification
+    ::Configuration['email_contact'] = 'contact@foo.bar'
+    ::Configuration['company_name'] = 'Catarse'
+    Mail::Message.any_instance.stub(:deliver)
+    NotificationsMailer.any_instance.should_receive(:mail).with({
+      from: "#{::Configuration[:company_name]} <#{::Configuration[:email_contact]}>",
+      to: notification.user.email,
+      subject: I18n.t('notifications.confirm_backer.subject', project_name: notification.project.name)
+    })
+  end
+
+  it("should satisfy expectations"){ subject }
+end