catarse_full 0.0.1

data/spec/models/user_total_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe UserTotal do
+  pending "put some tests here"
+end

data/spec/observers/backer_observer_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe BackerObserver do
+  let(:project_owner_backer_confirmed){ create(:notification_type, name: 'project_owner_backer_confirmed') }
+  let(:confirm_backer){ create(:notification_type, name: 'confirm_backer') }
+  let(:project_success){ create(:notification_type, name: 'project_success') }
+  let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: nil) }
+  subject{ backer }
+
+  before do
+    Notification.unstub(:create_notification)
+    Notification.unstub(:create_notification_once)
+    confirm_backer # It should create the NotificationType before creating the Backer
+    project_success
+    project_owner_backer_confirmed
+  end
+
+  describe "after_create" do
+    before{ Kernel.stub(:rand).and_return(1) }
+    its(:key){ should == Digest::MD5.new.update("#{backer.id}###{backer.created_at}##1").to_s }
+    its(:payment_method){ should == 'MoIP' }
+  end
+
+  describe "before_save" do
+    context "when payment_choice is updated to BoletoBancario" do
+      let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: Time.now) }
+      before do
+        Notification.should_receive(:create_notification).with(:payment_slip, backer.user, backer: backer, project_name: backer.project.name)
+        backer.payment_choice = 'BoletoBancario'
+        backer.save!
+      end
+      it("should notify the backer"){ subject }
+    end
+
+    context "when project reached the goal" do
+      let(:project){ create(:project, state: 'failed', goal: 20) }
+      let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: Time.now, value: 20) }
+      before do
+        project_total = mock()
+        project_total.stub(:pledged).and_return(20.0)
+        project_total.stub(:total_backers).and_return(1)
+        project.stub(:project_total).and_return(project_total)
+        backer.project = project
+        Notification.should_receive(:create_notification).with(:project_success, backer.project.user, project: backer.project)
+        backer.save!
+      end
+      it("should notify the project owner"){ subject }
+    end
+
+    context "when project is already successful" do
+      let(:project){ create(:project, state: 'online') }
+      let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: Time.now, project: project) }
+      before do
+        backer
+        project.update_attributes state: 'successful'
+        Notification.should_receive(:create_notification).never
+        backer.save!
+      end
+      it("should not send project_successful notification again"){ subject }
+    end
+
+    context "when is not yet confirmed" do
+      context 'notify the backer' do
+        before do
+          Notification.should_receive(:create_notification).at_least(:once).with(:confirm_backer,
+            backer.user, backer: backer,  project_name: backer.project.name)
+        end
+
+        it("should send confirm_backer notification"){ subject }
+        its(:confirmed_at) { should_not be_nil }
+      end
+
+      context 'notify project owner about this backer' do
+        before do
+          Notification.should_receive(:create_notification).at_least(:once).with(:project_owner_backer_confirmed,
+            backer.project.user, backer: backer, project_name: backer.project.name)
+        end
+
+        it("should send project_owner_backer_confirmed notification"){ subject }
+        its(:confirmed_at) { should_not be_nil }
+      end
+    end
+
+    context "when is already confirmed" do
+      let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: Time.now) }
+      before do
+        Notification.should_receive(:create_notification).never
+      end
+
+      it("should not send confirm_backer notification again"){ subject }
+    end
+  end
+
+  describe '.notify_backoffice_about_canceled' do
+    before do
+      Configuration[:email_payments] = 'finan@c.me'
+    end
+
+    let(:backer) { create(:backer) }
+    let(:user) { create(:user, email: 'finan@c.me') }
+
+    context "when backer is confirmed and change to canceled" do
+      before do
+        backer.confirm
+        Notification.should_receive(:create_notification_once).with(:backer_canceled_after_confirmed, user, {backer_id: backer.id}, backer: backer)
+      end
+
+      it { backer.cancel }
+    end
+
+    context "when backer change to confirmed" do
+      before do
+        Notification.should_not_receive(:create_notification).with(:backer_canceled_after_confirmed)
+      end
+
+      it { backer.confirm }
+    end
+  end
+end

data/spec/observers/notification_observer_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe NotificationObserver do
+  describe "after_create" do
+    before do
+      ActionMailer::Base.deliveries = []
+    end
+    it 'When email, subject and text are filled should delivery an email to user' do
+      FactoryGirl.create(:notification)
+      ActionMailer::Base.deliveries.should_not be_empty
+    end
+  end
+end

data/spec/observers/payment_notification_observer_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe PaymentNotificationObserver do
+  describe 'before_save' do
+    before do
+      Notification.unstub(:create_notification)
+      Notification.unstub(:create_notification_once)
+      create(:notification_type, name: 'processing_payment')
+    end
+
+    context "when payment is being processed" do
+      before do
+        Notification.should_receive(:create_notification_once)
+        p = create(:payment_notification)
+        p.extra_data = {'status_pagamento' => '6'}
+        p.backer.project = create(:project)
+        p.save!
+      end
+      it("should notify the backer"){ p }
+    end
+
+    context "when payment is approved" do
+      before do
+        Notification.should_receive(:create_notification_once).never
+        p = create(:payment_notification)
+        p.extra_data = {'status_pagamento' => '1'}
+        p.backer.project = create(:project)
+        p.save!
+      end
+      it("should not notify the backer"){ p }
+    end
+
+  end
+end

data/spec/observers/project_observer_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+describe ProjectObserver do
+  let(:new_draft_project){ create(:notification_type, name: 'new_draft_project') }
+  let(:confirm_backer){ create(:notification_type, name: 'confirm_backer') }
+  let(:project_received){ create(:notification_type, name: 'project_received') }
+  let(:project_in_wainting_funds){ create(:notification_type, name: 'project_in_wainting_funds') }
+  let(:adm_project_deadline){ create(:notification_type, name: 'adm_project_deadline') }
+  let(:project_success){ create(:notification_type, name: 'project_success') }
+  let(:backer_successful){ create(:notification_type, name: 'backer_project_successful') }
+  let(:backer_unsuccessful){ create(:notification_type, name: 'backer_project_unsuccessful') }
+  let(:pending_backer_unsuccessful){ create(:notification_type, name: 'pending_backer_project_unsuccessful') }
+  let(:project_visible){ create(:notification_type, name: 'project_visible') }
+  let(:project_rejected){ create(:notification_type, name: 'project_rejected') }
+  let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: nil) }
+  let(:project) { create(:project, goal: 3000) }
+
+  subject{ backer }
+
+  before do
+    Notification.unstub(:create_notification)
+    Notification.unstub(:create_notification_once)
+    new_draft_project
+    project_received
+    confirm_backer
+    project_success
+    backer_successful
+    backer_unsuccessful
+  end
+
+  describe "after_create" do
+    before do
+      ProjectObserver.any_instance.should_receive(:after_create).and_call_original
+      ::Configuration[:facebook_url] = 'http://facebook.com'
+      ::Configuration[:blog_url] = 'http://blog.com'
+      ::Configuration[:company_name] = 'Catarse'
+      ::Configuration[:email_projects] = 'foo@foo.com'
+      user
+      project
+    end
+    let(:user) { create(:user, email: ::Configuration[:email_projects])}
+
+    it "should create notification for catarse admin" do
+      Notification.where(user_id: user.id, notification_type_id: new_draft_project.id, project_id: project.id).first.should_not be_nil
+    end
+
+    it "should create notification for project owner" do
+      Notification.where(user_id: project.user.id, notification_type_id: project_received.id, project_id: project.id).first.should_not be_nil
+    end
+  end
+
+  describe "before_save" do
+    let(:project){ create(:project, video_url: 'http://vimeo.com/11198435', state: 'draft')}
+    context "when project is approved" do
+      before do
+        project.should_receive(:download_video_thumbnail).never
+        project.should_receive(:update_video_embed_url).never
+      end
+
+      it "should call create_notification and do not call download_video_thumbnail" do
+        Notification.should_receive(:create_notification_once).with(:project_visible, project.user, {project_id: project.id}, {project: project})
+        project.approve
+      end
+    end
+
+    context "when video_url changes" do
+      before do
+        project.should_receive(:download_video_thumbnail)
+        project.should_receive(:update_video_embed_url)
+        Notification.should_receive(:create_notification).never
+        Notification.should_receive(:create_notification_once).never
+      end
+
+      it "should call download_video_thumbnail and do not call create_notification" do
+        project.video_url = 'http://vimeo.com/66698435'
+        project.save!
+      end
+    end
+  end
+
+  describe "#notify_owner_that_project_is_waiting_funds" do
+    let(:user) { create(:user) }
+    let(:project) { create(:project, user: user, goal: 100, online_days: -2, state: 'online') }
+
+    before do
+      create(:backer, project: project, value: 200, state: 'confirmed')
+      Notification.should_receive(:create_notification_once).with(:project_in_wainting_funds, project.user, {project_id: project.id}, {project: project})
+    end
+
+    it("should notify the project owner"){ project.finish }
+  end
+
+  describe "sync with mailchimp" do
+    before do
+      Configuration[:mailchimp_successful_projects_list] = 'OwnerListId'
+      Configuration[:mailchimp_failed_projects_list] = 'UnsuccesfulListId'
+    end
+
+    let(:user) { create(:user) }
+    let(:project) { create(:project, online_days: -7, goal: 10, state: 'online', user: user) }
+
+    context 'when project is successful' do
+      before do
+        create(:backer, value: 15, state: 'confirmed', project: project)
+        project.update_attributes state: 'waiting_funds'
+      end
+
+      it 'subscribe project owner to successful projects mailchimp list' do
+        CatarseMailchimp::API.should_receive(:subscribe).with({ EMAIL: user.email, FNAME: user.name,
+          CITY: user.address_city, STATE: user.address_state }, 'OwnerListId')
+      end
+
+      after { project.finish }
+    end
+
+    context 'when project is unsuccesful' do
+      it 'subscribe project owner to failed projects mailchimp list' do
+        CatarseMailchimp::API.should_receive(:subscribe).with({ EMAIL: user.email, FNAME: user.name,
+          CITY: user.address_city, STATE: user.address_state }, 'UnsuccesfulListId')
+      end
+
+      after { project.finish }
+    end
+  end
+
+  describe "notify_backers" do
+
+    context "when project is successful" do
+      let(:project){ create(:project, goal: 30, online_days: -7, state: 'online') }
+      let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: Time.now, value: 30, project: project) }
+
+      before do
+        backer
+        project.update_attributes state: 'waiting_funds'
+        Notification.should_receive(:create_notification_once).at_least(:once)
+        backer.save!
+        project.finish!
+      end
+      it("should notify the project backers"){ subject }
+    end
+
+    context "when project is unsuccessful" do
+      let(:project){ create(:project, goal: 30, online_days: -7, state: 'online') }
+      let(:backer){ create(:backer, key: 'should be updated', payment_method: 'should be updated', state: 'confirmed', confirmed_at: Time.now, value: 20) }
+      before do
+        backer
+        project.update_attributes state: 'waiting_funds'
+        Notification.should_receive(:create_notification_once).at_least(:once)
+        backer.save!
+        project.finish!
+      end
+      it("should notify the project backers and owner"){ subject }
+    end
+
+    context "when project is unsuccessful with pending backers" do
+      let(:project){ create(:project, goal: 30, online_days: -7, state: 'online') }
+
+      before do
+        create(:backer, project: project, key: 'ABC1', payment_method: 'ABC', payment_token: 'ABC', value: 20, state: 'confirmed')
+        create(:backer, project: project, key: 'ABC2', payment_method: 'ABC', payment_token: 'ABC', value: 20)
+        project.update_attributes state: 'waiting_funds'
+      end
+
+      before do
+        Notification.should_receive(:create_notification_once).at_least(3)
+        project.finish!
+      end
+      it("should notify the project backers and owner"){ subject }
+    end
+
+  end
+
+  describe '#notify_owner_that_project_is_successful' do
+    let(:project){ create(:project, goal: 30, online_days: -7, state: 'waiting_funds') }
+
+    before do
+      ::Configuration[:facebook_url] = 'http://facebook.com/foo'
+      ::Configuration[:blog_url] = 'http://blog.com/foo'
+      project.stub(:reached_goal?).and_return(true)
+      project.stub(:in_time_to_wait?).and_return(false)
+      project_success
+      project.finish
+    end
+
+    it "should create notification for project owner" do
+      Notification.where(user_id: project.user.id, notification_type_id: project_success.id, project_id: project.id).first.should_not be_nil
+    end
+  end
+
+  describe "#notify_owner_that_project_is_rejected" do
+    let(:project){ create(:project, state: 'draft') }
+    before do
+      ::Configuration[:facebook_url] = 'http://facebook.com/foo'
+      ::Configuration[:blog_url] = 'http://blog.com/foo'
+      project_rejected
+      project.reject
+    end
+
+    it "should create notification for project owner" do
+      Notification.where(user_id: project.user.id, notification_type_id: project_rejected.id, project_id: project.id).first.should_not be_nil
+    end
+
+  end
+
+  describe "#notify_admin_that_project_reached_deadline" do
+    let(:project){ create(:project, goal: 30, online_days: -7, state: 'waiting_funds') }
+    let(:user) { create(:user, email: 'foo@foo.com')}
+    before do
+      ::Configuration[:email_payments] = 'foo@foo.com'
+      ::Configuration[:email_system] = 'foo2@foo.com'
+      user
+      project.stub(:reached_goal?).and_return(true)
+      project.stub(:in_time_to_wait?).and_return(false)
+      adm_project_deadline
+      Project.finish_projects!
+    end
+
+    it "should create notification for admin" do
+      Notification.where(user_id: user.id, notification_type_id: adm_project_deadline.id, project_id: project.id).first.should_not be_nil
+    end
+
+  end
+
+end

data/spec/observers/update_observer_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe UpdateObserver do
+  describe 'after_create' do
+    context "call notify update worker" do
+      before do
+        NotifyUpdateWorker.jobs.clear
+        @project = FactoryGirl.create(:project)
+      end
+
+      it "should send to queue" do
+        update = Update.create!(user: @project.user, project: @project, comment: "this is a comment")
+        NotifyUpdateWorker.jobs.size.should == 1
+      end
+    end
+  end
+end

data/spec/observers/user_observer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe UserObserver do
+
+  describe "after_create" do
+    before do
+      UserObserver.any_instance.should_receive(:after_create).and_call_original
+      Notification.unstub(:create_notification_once)
+    end
+
+    let(:user) { create(:user) }
+
+    it "send new user registration notification" do
+      Notification.should_receive(:create_notification_once).with(:new_user_registration, user, {user_id: user.id}, {user: user})
+    end
+  end
+
+  context 'before_save' do
+    subject { create(:user, twitter: '@should_be_change') }
+
+    its(:twitter) { should == 'should_be_change' }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,82 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require 'coveralls'
+Coveralls.wear!('rails')
+
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'sidekiq/testing'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+  config.include ActionView::Helpers::TextHelper
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = false
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  #config.infer_base_class_for_anonymous_controllers = false
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  config.before(:suite) do
+    ActiveRecord::Base.connection.execute "SET client_min_messages TO warning;"
+    DatabaseCleaner.clean_with :truncation
+    I18n.locale = :pt
+    I18n.default_locale = :pt
+  end
+
+  config.before(:each) do
+    if example.metadata[:type] == :feature
+      DatabaseCleaner.strategy = :truncation
+    else
+      DatabaseCleaner.strategy = :transaction
+    end
+    DatabaseCleaner.start
+    ActionMailer::Base.deliveries.clear
+    RoutingFilter.active = false # Because this issue: https://github.com/svenfuchs/routing-filter/issues/36
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  # Stubs and configuration
+  config.before(:each) do
+    CatarseMailchimp::API.stub(:subscribe).and_return(true)
+    CatarseMailchimp::API.stub(:unsubscribe).and_return(true)
+    PaperTrail.controller_info = {}
+    PaperTrail.whodunnit = nil
+    Project.any_instance.stub(:store_image_url).and_return('http://www.store_image_url.com')
+    ProjectObserver.any_instance.stub(:after_create)
+    UserObserver.any_instance.stub(:after_create)
+    Project.any_instance.stub(:download_video_thumbnail)
+    CatarseMailchimp::API.stub(:subscribe)
+    CatarseMailchimp::API.stub(:unsubscribe)
+    Notification.stub(:create_notification)
+    Notification.stub(:create_notification_once)
+    Calendar.any_instance.stub(:fetch_events_from)
+    Blog.stub(:fetch_last_posts).and_return([])
+    [Projects::BackersController, Users::BackersController, UsersController, UnsubscribesController, ProjectsController, ExploreController].each do |c|
+      c.any_instance.stub(:render_facebook_sdk)
+      c.any_instance.stub(:render_facebook_like)
+      c.any_instance.stub(:render_twitter)
+      c.any_instance.stub(:display_uservoice_sso)
+    end
+    Configuration[:base_domain] = 'localhost'
+    ::Configuration['email_contact'] = 'foo@bar.com'
+  end
+end
+