harvested2 5.0.3

data/spec/functional/errors_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'harvest errors' do
+  let(:harvest) { Harvest.client(access_token: 'mytoken', account_id: '123') }
+
+  before { WebMock.disable_net_connect! }
+
+  context 'wraps errors' do
+    it 'sould returns a Harvest::BadRequest error' do
+      stub_request(:get, /\/clients/).to_return({ status: ['400', 'Bad Request']},
+        { body: '[]', status: 200})
+      expect { harvest.clients.all }.to raise_error(Harvest::BadRequest)
+    end
+
+    it 'sould returns a Harvest::NotFound error' do
+      stub_request(:get, /\/clients/)
+        .to_return({ status: ['404', 'Not Found'] }, { body: '[]', status: 200})
+      expect { harvest.clients.all }.to raise_error(Harvest::NotFound)
+    end
+
+    it 'sould returns a Harvest::ServerError error' do
+      stub_request(:get, /\/clients/)
+        .to_return({ status: ['500', 'Server Error'] },
+          { body: '[]', status: 200 })
+      expect { harvest.clients.all }.to raise_error(Harvest::ServerError)
+    end
+
+    it 'sould returns a Harvest::Unavailable error' do
+      stub_request(:get, /\/clients/)
+        .to_return({ status: ['502', 'Bad Gateway'] },
+          { body: '[]', status: 200 })
+      expect { harvest.clients.all }.to raise_error(Harvest::Unavailable)
+    end
+
+    it 'sould returns a Harvest::RateLimited error' do
+      stub_request(:get, /\/clients/)
+        .to_return({ status: ['503', 'Rate Limited'] },
+          { body: '[]', status: 200 })
+      expect { harvest.clients.all }.to raise_error(Harvest::RateLimited)
+    end
+  end
+end

data/spec/functional/expenses_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe 'harvest expenses' do
+  let(:harvest) { Harvest.client(access_token: 'mytoken', account_id: '123') }
+
+  describe 'categories' do
+    let(:expense_category) { create(:expense_category) }
+    let(:expense_category_attributes) do
+      FactoryBot.attributes_for(:expense_category)
+    end
+
+    context 'allows to add clients' do
+      before do
+        allow(harvest.expense_categories).to receive(:create)
+          .and_return(expense_category)
+      end
+
+      it 'returns true' do
+        expect(expense_category.name).to eql('Mileage')
+      end
+    end
+
+    context 'allows to update clients' do
+      before do
+        allow(harvest.expense_categories).to receive(:update)
+          .and_return(expense_category)
+        expense_category.name = 'Travel'
+        expense_category = harvest.expense_categories.update(expense_category)
+      end
+
+      it 'returns true' do
+        expect(expense_category.name).to eql('Travel')
+      end
+    end
+
+    context 'allows to delete clients' do
+      before do
+        allow(harvest.expense_categories).to receive(:delete).and_return([])
+        allow(harvest.expense_categories).to receive(:all).and_return([])
+        harvest.expense_categories.delete(expense_category)
+      end
+
+      it 'returns true' do
+        expect(harvest.expense_categories.all.select do |e|
+          e.name == 'Travel'
+        end).to eql([])
+      end
+    end
+  end
+
+  describe 'expenses' do
+    let(:client) { create(:client) }
+    let(:project) { create(:project, client: client) }
+    let(:expense_category) { create(:expense_category) }
+    let(:expense) do
+      create(:expense, project: project, expense_category: expense_category)
+    end
+
+    context 'allows to add expense' do
+      before do
+        allow(harvest.expenses).to receive(:create)
+          .and_return(expense)
+      end
+
+      it 'returns true' do
+        expect(expense.notes).to eql('Drive to Chicago')
+      end
+    end
+
+    context 'allows to update expense' do
+      before do
+        allow(harvest.expenses).to receive(:update)
+          .and_return(expense)
+        expense.notes = 'Off to Chicago'
+        expense = harvest.expenses.update(expense)
+      end
+
+      it 'returns true' do
+        expect(expense.notes).to eql('Off to Chicago')
+      end
+    end
+
+    context 'allows to delete clients' do
+      before do
+        allow(harvest.expenses).to receive(:delete).and_return([])
+        allow(harvest.expenses).to receive(:all).and_return([])
+        harvest.expenses.delete(expense)
+      end
+
+      it 'returns true' do
+        expect(harvest.expenses.all(Time.utc(2009, 12, 28)).select do |e|
+          e.notes == 'Off to Chicago'
+        end).to eql([])
+      end
+    end
+  end
+end

data/spec/functional/invoice_messages_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'harvest invoice messages' do
+  let(:harvest) { Harvest.client(access_token: 'mytoken', account_id: '123') }
+
+  describe 'invoice messages' do
+    let(:invoice) { create(:invoice) }
+    let(:invoice_message) { create(:invoice_message) }
+
+    context 'allows to add invoice_messages' do
+      before do
+        allow(harvest.invoice_messages).to receive(:create)
+          .and_return(invoice_message)
+      end
+
+      it 'returns true' do
+        expect(invoice_message.body).to eql('The message body goes here')
+      end
+    end
+
+    context 'allows to update invoice_messages' do
+      before do
+        allow(harvest.invoice_messages).to receive(:update)
+          .and_return(invoice_message)
+        invoice_message.body = 'New body text'
+        invoice_message = harvest.invoice_messages.update(invoice_message)
+      end
+
+      it 'returns true' do
+        expect(invoice_message.body).to eql('New body text')
+      end
+    end
+
+    context 'allows to remove invoice_messages' do
+      before do
+        allow(harvest.invoice_messages).to receive(:delete).and_return([])
+        allow(harvest.invoice_messages).to receive(:all).and_return([])
+        harvest.invoice_messages.delete(invoice_message)
+      end
+
+      it 'returns true' do
+        expect(harvest.invoice_messages.all.select do |i|
+          i.body == 'New body text'
+        end).to eql([])
+      end
+    end
+  end
+end

data/spec/functional/invoice_payments_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'harvest invoice payments' do
+  let(:harvest) { Harvest.client(access_token: 'mytoken', account_id: '123') }
+
+  describe 'invoice payments' do
+    let(:invoice) { create(:invoice) }
+    let(:invoice_payment) { create(:invoice_payment, amount: invoice.amount) }
+    let(:invoice_payment_attributes) do
+      FactoryBot.attributes_for(:invoice_payment)
+    end
+
+    context 'allows to add invoice_payments' do
+      before do
+        allow(harvest.invoice_payments).to receive(:create)
+          .and_return(invoice_payment)
+      end
+
+      it 'returns true' do
+        expect(invoice_payment.amount).to eql(invoice.amount)
+      end
+    end
+
+    context 'allows to update invoice_payments' do
+      before do
+        allow(harvest.invoice_payments).to receive(:update)
+          .and_return(invoice_payment)
+        invoice_payment.amount = 200
+        invoice_payment = harvest.invoice_payments.update(invoice_payment)
+      end
+
+      it 'returns true' do
+        expect(invoice_payment.amount).to eql(200)
+      end
+    end
+
+    context 'allows to remove invoice_payments' do
+      before do
+        allow(harvest.invoice_payments).to receive(:delete).and_return([])
+        allow(harvest.invoice_payments).to receive(:all).and_return([])
+        harvest.invoice_payments.delete(invoice_payment)
+      end
+
+      it 'returns true' do
+        expect(harvest.invoice_payments.all.select do |i|
+          i.amount == 200
+        end).to eql([])
+      end
+    end
+  end
+end

data/spec/functional/invoice_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe 'harvest invoices' do
+  let(:harvest) { Harvest.client(access_token: 'mytoken', account_id: '123') }
+
+  describe 'categories' do
+    let(:invoice_category) { create(:invoice_category) }
+
+    context 'allows to add invoice categories' do
+      before do
+        allow(harvest.invoice_categories).to receive(:create)
+          .and_return(invoice_category)
+      end
+
+      it 'returns true' do
+        expect(invoice_category.name).to eql('New Category')
+      end
+    end
+
+    context 'allows to update invoice categories' do
+      before do
+        allow(harvest.invoice_categories).to receive(:update)
+          .and_return(invoice_category)
+        invoice_category.name = 'Updated Category'
+        invoice_category = harvest.invoice_categories.update(invoice_category)
+      end
+
+      it 'returns true' do
+        expect(invoice_category.name).to eql('Updated Category')
+      end
+    end
+
+    context 'allows to remove invoice categories' do
+      before do
+        allow(harvest.invoice_categories).to receive(:delete).and_return([])
+        allow(harvest.invoice_categories).to receive(:all).and_return([])
+        harvest.invoice_categories.delete(invoice_category)
+      end
+
+      it 'returns true' do
+        expect(harvest.invoice_categories.all.select do |p|
+          p.name == 'Updated Category'
+        end).to eql([])
+      end
+    end
+  end
+
+  describe 'invoices' do
+    let(:invoice_category) { create(:invoice_category) }
+    let(:invoice) { create(:invoice) }
+    let(:line_item) { create(:line_item) }
+
+    context 'allows to add invoice invoices' do
+      before do
+        allow(harvest.invoices).to receive(:create)
+          .and_return(invoice)
+      end
+
+      it 'returns true' do
+        expect(invoice.subject)
+          .to eql("Invoice for Joe's Stream Cleaning")
+        expect(invoice.amount).to eql(2400.0)
+        expect(invoice.line_items.size).to eql(0)
+      end
+    end
+
+    context 'allows to update invoices' do
+      before do
+        allow(harvest.invoices).to receive(:update)
+          .and_return(invoice)
+        invoice.subject = 'Updated Invoice for Joe'
+        invoice.line_items << line_item
+        invoice.update_line_items = true
+        invoice.amount = 4800.0
+        invoice = harvest.invoices.update(invoice)
+      end
+
+      it 'returns true' do
+        expect(invoice.subject).to eql('Updated Invoice for Joe')
+        expect(invoice.amount).to eql(4800.0)
+        expect(invoice.line_items.size).to eql(1)
+      end
+    end
+
+    context 'allows to remove invoices' do
+      before do
+        allow(harvest.invoices).to receive(:delete).and_return([])
+        allow(harvest.invoices).to receive(:all).and_return([])
+        harvest.invoices.delete(invoice)
+      end
+
+      it 'returns true' do
+        expect(harvest.invoices.all.select do |i|
+          i.number == '1000'
+        end).to eql([])
+      end
+    end
+  end
+
+  describe 'read' do
+    let(:invoice_category) { create(:invoice_category) }
+    let(:invoice) { create(:invoice) }
+    let(:line_item) { create(:line_item) }
+    let(:invoice_attributes) { FactoryBot.attributes_for(:invoice) }
+    let(:invoices) { [invoice] }
+
+    context 'allows finding one invoice with parameters' do
+       before do
+        allow(harvest.invoices).to receive(:create)
+          .and_return(invoice)
+        allow(harvest.invoices).to receive(:find)
+          .and_return(invoice)
+        allow(harvest.invoices).to receive(:all).and_return(invoices)
+
+        invoice = harvest.invoices.create(invoice_attributes)
+        invoice.line_items << line_item
+        result = harvest.invoices.find(invoice.id)
+      end
+
+      it 'returns a specific invoice' do
+        expect(invoice.subject).to eql("Invoice for Joe's Stream Cleaning")
+        expect(invoice.amount).to eql(2400.0)
+        expect(invoice.line_items.size).to eql(1)
+        expect(invoice.due_at).to eql('2011-03-31')
+        expect(invoices.count).to eql(1)
+      end
+
+      it 'returns invoices' do
+        invoices = harvest.invoices.all(status: 'draft')
+        expect(invoice.subject).to eql("Invoice for Joe's Stream Cleaning")
+        expect(invoice.amount).to eql(2400.0)
+        expect(invoice.line_items.size).to eql(1)
+        expect(invoice.due_at).to eql('2011-03-31')
+        expect(invoices.count).to eql(1)
+      end
+    end
+  end
+end

data/spec/functional/project_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'harvest projects' do
+  let(:harvest) { Harvest.client(access_token: 'mytoken', account_id: '123') }
+
+  describe 'projects' do
+    let(:client) { create(:client) }
+    let(:project) { create(:project, client: client) }
+    let(:project_attributes) { FactoryBot.attributes_for(:project) }
+
+    context 'allows to add projects' do
+      before do
+        allow(harvest.projects).to receive(:create).and_return(project)
+        project = harvest.projects.create(project_attributes)
+      end
+
+      it 'should return true' do
+        expect(project.name).to eql('Project Test')
+      end
+    end
+
+    context 'allows to update projects' do
+      before do
+        allow(harvest.projects).to receive(:update).and_return(project)
+        project.name = 'Updated Project'
+        project = harvest.projects.update(project)
+      end
+
+      it 'should return true' do
+        expect(project.name).to eql('Updated Project')
+      end
+    end
+
+    context 'allows to remove projects' do
+      before do
+        allow(harvest.projects).to receive(:delete).and_return([])
+        allow(harvest.projects).to receive(:all).and_return([])
+        harvest.projects.delete(project)
+      end
+
+      it 'returns true' do
+        expect(harvest.projects.all.select do |p|
+          p.name == 'Updated Project'
+        end).to eql([])
+      end
+    end
+  end
+
+  describe 'clients' do
+    context 'allows activating and deactivating clients' do
+      let(:active_project) { create(:project, :active) }
+      let(:deactive_project) { create(:project, :deactive) }
+
+      before do
+        allow(harvest.projects).to receive(:deactivate)
+          .and_return(deactive_project)
+        allow(harvest.projects).to receive(:activate)
+          .and_return(active_project)
+      end
+
+      it 'should be active' do
+        expect(active_project).to be_active
+      end
+
+      it 'should be deactive' do
+        project = harvest.projects.deactivate(project)
+        expect(deactive_project).not_to be_active
+      end
+
+      it 'should reactive a project' do
+        project = harvest.projects.activate(project)
+        expect(active_project).to be_active
+      end
+    end
+  end
+end