dorsale 3.14.4 → 3.14.5

data/spec/controllers/dorsale/billing_machine/invoices_controller_spec.rb

@@ -0,0 +1,153 @@
+require "rails_helper"
+
+describe Dorsale::BillingMachine::InvoicesController, type: :controller do
+  routes { Dorsale::Engine.routes }
+
+  let(:user) { create(:user) }
+  before(:each) { sign_in(user) }
+
+  describe "#preview" do
+    render_views
+
+    it "should render show" do
+      post :preview
+      expect(response).to render_template(:show)
+    end
+
+    it "should not save" do
+      post :preview
+      @invoice = assigns(:invoice)
+      expect(@invoice).to be_valid
+      expect(@invoice).to_not be_persisted
+    end
+  end # describe "#preview" do
+
+  describe "XLSX export" do
+    render_views
+
+    it "should be ok" do
+      3.times { create(:billing_machine_invoice_line) }
+      get :index, params: {format: :xlsx}
+      expect(response).to be_ok
+    end
+  end # describe "XLSX export"
+
+  describe "PDF export" do
+    render_views
+
+    it "should be ok" do
+      3.times {
+        invoice = create(:billing_machine_invoice)
+        Dorsale::BillingMachine::PdfFileGenerator.(invoice)
+      }
+      get :index, params: {format: :pdf}
+      expect(response).to be_ok
+    end
+  end # describe "PDF export"
+
+  describe "filters" do
+    describe "filter by date" do
+      before do
+        Timecop.freeze "2016-11-08 12:00:00"
+        @today      = create(:billing_machine_invoice, date: "2016-11-08")
+        @yesterday  = create(:billing_machine_invoice, date: "2016-11-07")
+        @tomorrow   = create(:billing_machine_invoice, date: "2016-11-09")
+        @last_week  = create(:billing_machine_invoice, date: "2016-11-04")
+        @last_month = create(:billing_machine_invoice, date: "2016-10-18")
+        @last_year  = create(:billing_machine_invoice, date: "2015-10-18")
+      end
+
+      def filter(period)
+        cookies[:filters] = {"bm_time_period" => period.to_s}.to_json
+        get :index
+      end
+
+      it "should filter by all_time" do
+        filter :all_time
+        expect(assigns :invoices).to contain_exactly(
+          @today,
+          @yesterday,
+          @tomorrow,
+          @last_week,
+          @last_month,
+          @last_year,
+        )
+      end
+
+      it "should filter by today" do
+        filter :today
+        expect(assigns :invoices).to contain_exactly(@today)
+      end
+
+      it "should filter by yesterday" do
+        filter :yesterday
+        expect(assigns :invoices).to contain_exactly(@yesterday)
+      end
+
+      it "should filter by this_week" do
+        filter :this_week
+        expect(assigns :invoices).to contain_exactly(@today, @yesterday, @tomorrow)
+      end
+
+      it "should filter by this_month" do
+        filter :this_month
+        expect(assigns :invoices).to contain_exactly(@today, @yesterday, @tomorrow, @last_week)
+      end
+
+      it "should filter by this_year" do
+        filter :this_year
+        expect(assigns :invoices).to \
+          contain_exactly(@today, @yesterday, @tomorrow, @last_week, @last_month)
+      end
+
+      it "should filter by last_week" do
+        filter :last_week
+        expect(assigns :invoices).to contain_exactly(@last_week)
+      end
+
+      it "should filter by last_month" do
+        filter :last_month
+        expect(assigns :invoices).to contain_exactly(@last_month)
+      end
+
+      it "should filter by last_year" do
+        filter :last_year
+        expect(assigns :invoices).to contain_exactly(@last_year)
+      end
+    end # describe "filter by date"
+
+    describe "filter by payment status" do
+      before do
+        Timecop.freeze "2016-11-08 12:00:00"
+        @paid       = create(:billing_machine_invoice, paid: true,  due_date: "2016-01-08")
+        @pending    = create(:billing_machine_invoice, paid: false, due_date: "2016-11-10")
+        @late       = create(:billing_machine_invoice, paid: false, due_date: "2016-06-05")
+      end
+
+      def filter(value)
+        cookies[:filters] = {"bm_payment_status" => value.to_s}.to_json
+        get :index
+      end
+
+      it "should filter by paid" do
+        filter :paid
+        expect(assigns :invoices).to contain_exactly(@paid)
+      end
+
+      it "should filter by unpaid" do
+        filter :unpaid
+        expect(assigns :invoices).to contain_exactly(@pending, @late)
+      end
+
+      it "should filter by pending" do
+        filter :pending
+        expect(assigns :invoices).to contain_exactly(@pending)
+      end
+
+      it "should filter by late" do
+        filter :late
+        expect(assigns :invoices).to contain_exactly(@late)
+      end
+    end # describe "filter by payment status"
+  end # describe "filters"
+end

data/spec/controllers/dorsale/billing_machine/quotations_controller_spec.rb

@@ -0,0 +1,24 @@
+require "rails_helper"
+
+describe Dorsale::BillingMachine::QuotationsController, type: :controller do
+  routes { Dorsale::Engine.routes }
+
+  let(:user) { create(:user) }
+  before(:each) { sign_in(user) }
+
+  describe "#preview" do
+    render_views
+
+    it "should render show" do
+      post :preview
+      expect(response).to render_template(:show)
+    end
+
+    it "should not save" do
+      post :preview
+      @quotation = assigns(:quotation)
+      expect(@quotation).to be_valid
+      expect(@quotation).to_not be_persisted
+    end
+  end # describe "#preview" do
+end

data/spec/controllers/dorsale/comments_controller_spec.rb

@@ -0,0 +1,50 @@
+require "rails_helper"
+
+describe Dorsale::CommentsController, type: :controller do
+  routes { Dorsale::Engine.routes }
+
+  let(:user) { create(:user) }
+
+  before(:each) { sign_in(user) }
+
+  let(:commentable) { create(:customer_vault_corporation) }
+  let(:valid_params) {
+    {
+      :comment => {
+        :commentable_id   => commentable.id,
+        :commentable_type => commentable.class.to_s,
+        :text => "Hello",
+      },
+      :back_url => "/",
+    }
+  }
+
+  describe "create" do
+    it "should create comment" do
+      post :create, params: valid_params
+      expect(assigns(:comment)).to be_persisted
+    end
+
+    it "should redirect to back_url" do
+      post :create, params: valid_params
+      expect(response).to redirect_to("/")
+    end
+  end
+
+  describe "update" do
+    it "should update comment text" do
+      comment = create(:dorsale_comment)
+      patch :update, params: {id: comment, comment: {text: "New-comment-text"}, back_url: "/"}
+      expect(response).to redirect_to("/")
+      expect(comment.reload.text).to eq "New-comment-text"
+    end
+  end
+
+  describe "destroy" do
+    it "should destroy comment" do
+      comment = create(:dorsale_comment)
+      delete :destroy, params: {id: comment, back_url: "/"}
+      expect(response).to redirect_to("/")
+    end
+  end
+end

data/spec/controllers/dorsale/customer_vault/events_controller_spec.rb

@@ -0,0 +1,42 @@
+require "rails_helper"
+
+describe ::Dorsale::CustomerVault::EventsController, type: :controller do
+  routes { Dorsale::Engine.routes }
+
+  let(:user) { create(:user) }
+
+  before(:each) { sign_in(user) }
+
+  describe "#filters" do
+    before do
+      @event1 = create(:customer_vault_event, action: "create")
+      @event2 = create(:customer_vault_event, action: "update")
+    end
+
+    it "should filter by event_action" do
+      cookies[:filters] = {event_action: "create"}.to_json
+      get :index
+      expect(assigns(:events)).to eq [@event1]
+    end
+
+    it "should filter by multiple event_action" do
+      cookies[:filters] = {event_action: "create update"}.to_json
+      get :index
+      expect(assigns(:events)).to contain_exactly(@event1, @event2)
+    end
+  end # describe "#filters"
+
+  describe "#index" do
+    before do
+      @corporation1 = create(:customer_vault_corporation)
+      @corporation2 = create(:customer_vault_corporation)
+      @event1       = create(:customer_vault_event, person: @corporation1, created_at: "2012-02-15")
+      @event2       = create(:customer_vault_event, person: @corporation2, created_at: "2012-03-15")
+    end
+
+    it "should assigns all events ordered by created_at DESC" do
+      get :index
+      expect(assigns(:events)).to eq [@event2, @event1]
+    end
+  end # describe "#index"
+end

data/spec/controllers/dorsale/customer_vault/people_controller_spec.rb

@@ -0,0 +1,129 @@
+require "rails_helper"
+
+RSpec.describe ::Dorsale::CustomerVault::PeopleController, type: :controller do
+  routes { Dorsale::Engine.routes }
+
+  let(:user) { create(:user) }
+
+  before(:each) { sign_in(user) }
+
+  describe "#corporations" do
+    render_views
+
+    it "should return corporations only" do
+      corporation = create(:customer_vault_corporation)
+      individual  = create(:customer_vault_individual)
+      get :corporations
+      expect(assigns :people).to eq [corporation]
+    end
+  end # describe "#corporations"
+
+  describe "#individuals" do
+    render_views
+
+    it "should return individuals only" do
+      corporation = create(:customer_vault_corporation)
+      individual  = create(:customer_vault_individual)
+      get :individuals
+      expect(assigns :people).to eq [individual]
+    end
+  end # describe "#individuals"
+
+  describe "#list" do
+    describe "sorting" do
+      it "should sort people by name by default" do
+        abc   = create(:customer_vault_corporation, name: "Abc Corp")
+        bob   = create(:customer_vault_individual, last_name: "Bob")
+        alice = create(:customer_vault_individual, last_name: "Alice")
+        zorg  = create(:customer_vault_corporation, name: "Zorg Corp")
+
+        get :index
+
+        expect(assigns(:people)).to eq([abc, alice, bob, zorg])
+      end
+    end # describe "sorting"
+
+    describe "filters" do
+      it "should filter by person type" do
+        individual  = create(:customer_vault_individual)
+        corporation = create(:customer_vault_corporation)
+
+        cookies[:filters] = {person_type: "Dorsale::CustomerVault::Individual"}.to_json
+
+        get :index
+
+        expect(assigns(:people)).to eq [individual]
+      end
+
+      it "should filter by person origin" do
+        origin      = create(:customer_vault_origin)
+        individual1 = create(:customer_vault_individual, origin: origin)
+        individual2 = create(:customer_vault_individual)
+
+        cookies[:filters] = {person_origin: origin.id}.to_json
+        get :index
+
+        expect(assigns(:people)).to eq [individual1]
+      end
+
+      it "should filter by person activity_type" do
+        activity_type = create(:customer_vault_activity_type)
+        corporation1  = create(:customer_vault_corporation, activity_type: activity_type)
+        corporation2  = create(:customer_vault_corporation)
+
+        cookies[:filters] = {person_activity: activity_type.id}.to_json
+        get :index
+
+        expect(assigns(:people)).to eq [corporation1]
+      end
+    end # describe "filters"
+
+    describe "search" do
+      it "search should ignore filters" do
+        corporation1 = create(:customer_vault_corporation, tag_list: "abc", name: "aaa")
+        corporation2 = create(:customer_vault_corporation, tag_list: "xyz", name: "bbb")
+        @request.cookies["filters"] = {tags: ["abc"]}.to_json
+        get :index, params: {q: "bbb"}
+        expect(assigns(:people)).to eq [corporation2]
+      end
+    end # describe "search"
+  end # describe "#list"
+
+  describe "#create" do
+    before do
+      allow_any_instance_of(Dorsale::CustomerVault::PeopleController).to \
+        receive(:model) { Dorsale::CustomerVault::Corporation }
+    end
+
+    it "should generate an event" do
+      expect {
+        post :create, params: {person: {corporation_name: "agilidée"}}
+      }.to change(Dorsale::CustomerVault::Event, :count).by(1)
+
+      event = Dorsale::CustomerVault::Event.last_created
+      expect(event.author).to eq user
+      expect(event.person).to eq Dorsale::CustomerVault::Person.last_created
+      expect(event.action).to eq "create"
+    end
+  end # describe "#create"
+
+  describe "#update" do
+    before do
+      allow_any_instance_of(Dorsale::CustomerVault::PeopleController).to \
+        receive(:model) { Dorsale::CustomerVault::Corporation }
+    end
+
+    it "should generate an event" do
+      corporation = create(:customer_vault_corporation)
+
+      expect {
+        patch :update, params: {id: corporation, person: {corporation_name: "agilidée"}}
+      }.to change(Dorsale::CustomerVault::Event, :count).by(1)
+
+      event = Dorsale::CustomerVault::Event.last_created
+      expect(event.author).to eq user
+      expect(event.person).to eq corporation
+      expect(event.action).to eq "update"
+    end
+  end # describe "#update"
+end

data/spec/controllers/dorsale/expense_gun/expenses_controller_spec.rb

@@ -0,0 +1,55 @@
+require "rails_helper"
+
+RSpec.describe ::Dorsale::ExpenseGun::ExpensesController, type: :controller do
+  routes { Dorsale::Engine.routes }
+  let(:user) { create(:user) }
+  before(:each) { sign_in(user) }
+
+  describe "#index" do
+    describe "filters" do
+      render_views
+
+      it "should filter by state" do
+        expense1 = create(:expense_gun_expense, state: "accepted")
+        expense2 = create(:expense_gun_expense, state: "refused")
+
+        cookies[:filters] = {expense_state: "accepted"}.to_json
+        get :index
+
+        expect(assigns :expenses).to eq [expense1]
+      end
+
+      it "should filter by user" do
+        user1    = create(:user)
+        user2    = create(:user)
+        expense1 = create(:expense_gun_expense, user: user1)
+        expense2 = create(:expense_gun_expense, user: user2)
+
+        cookies[:filters] = {expense_user_id: user1.id}.to_json
+        get :index
+
+        expect(assigns :expenses).to eq [expense1]
+      end
+
+      it "should assigns only users having expenses" do
+        user1    = create(:user)
+        user2    = create(:user)
+        expense2 = create(:expense_gun_expense, user: user2)
+
+        get :index
+
+        expect(assigns :users).to eq [user2]
+      end
+    end # describe "filters"
+  end # describe "#index"
+
+  describe "#show" do
+    render_views
+
+    it "should be ok as PDF" do
+      expense = create(:expense_gun_expense, user: user)
+      get :show, params: {id: expense, format: :pdf}
+      expect(response).to be_ok
+    end
+  end # describe "#show"
+end