rexpense 1.0.0

data/spec/lib/rexpense/resources/reimbursement_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Rexpense::Resources::Reimbursement, vcr: true do
+  let(:reimbursement_klass) { Rexpense::Entities::Reimbursement }
+
+  describe "#find_all" do
+    context "with success" do
+      subject { client.reimbursements.find_all }
+
+      it "show all reimbursements successfully" do
+        expect(subject.class).to eq(Rexpense::Entities::ReimbursementCollection)
+        expect(subject.collection.first.class).to eq(reimbursement_klass)
+      end
+    end
+
+    it "find reimbursements by attributes" do
+      params = { currency_in: ["USD"] }
+      result = client.reimbursements.find_all(params)
+
+      expect(result).to be_a(Rexpense::Entities::ReimbursementCollection)
+      expect(result.collection[0]).to be_a(reimbursement_klass)
+      expect(result.collection[0].currency).to eq("USD")
+    end
+
+    context "when error" do
+      let(:client) { Rexpense.client("") }
+
+      it "raises Rexpense::RequestError with 401 status code" do
+        expect { client.reimbursements.find_all({}) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(401)
+        end
+      end
+    end
+  end
+
+  describe "#find" do
+    context "with success" do
+      subject { client.reimbursements.find(51) }
+
+      it "returns a category successfully" do
+        expect(subject.class).to eq(reimbursement_klass)
+        expect(subject.id).to eq(51)
+      end
+    end
+
+    context "with error" do
+      it "raises Rexpense::RequestError with 404 status code" do
+        expect { client.reimbursements.find(000000) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(404)
+        end
+      end
+    end
+  end
+
+  describe "#create" do
+    let(:params) do
+      {
+        amount: 10.0,
+        expense_ids: [241],
+        currency: 'BRL',
+        date: '2014-10-16',
+        payer: {
+          id: 16,
+          type: 'Organization'
+        },
+        receiver: {
+          id: 2,
+          type: 'User'
+        }
+      }
+    end
+
+    context "with success" do
+      it "creates a category successfully" do
+        result = client.reimbursements.create(params)
+        expect(result).to be_a(reimbursement_klass)
+        expect(result.amount).to eq(10.0)
+      end
+    end
+
+    context "with error" do
+      it "raises Rexpense::RequestError with 422 status code" do
+        expect { client.reimbursements.create({}) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(422)
+        end
+      end
+    end
+  end
+
+  describe "#update" do
+    context "with success" do
+      it "updates a category successfully" do
+        expect(client.reimbursements.update(78, { description: 'something from nothing' })).to be_a(reimbursement_klass)
+      end
+    end
+
+    context "with error" do
+      it "raises Rexpense::RequestError with 404 status code" do
+        expect { client.reimbursements.update(88888888, {}) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(404)
+        end
+      end
+
+      it "raises Rexpense::RequestError with 422 status core" do
+        expect { client.reimbursements.update(78, { payer_id: nil }) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(422)
+        end
+      end
+    end
+  end
+
+  describe "#destroy" do
+    context "with success" do
+      it "destroy a category successfully" do
+        expect(client.reimbursements.destroy(78)).to be_truthy
+      end
+    end
+
+    context "with error" do
+      it "raises Rexpense::RequestError with 404 status code" do
+        expect { client.reimbursements.destroy(88888888) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(404)
+        end
+      end
+    end
+  end
+
+  context 'Comments' do
+    let(:comment_klass) { Rexpense::Entities::Comment }
+
+    describe '#comments' do
+      context "with success" do
+        subject { client.reimbursements.comments(11) }
+
+        it "show all reimbursement successfully" do
+          expect(subject.class).to eq(Rexpense::Entities::CommentCollection)
+          expect(subject.collection.first.class).to eq(comment_klass)
+        end
+      end
+    end
+
+    describe '#find_comment' do
+      context "with success" do
+        subject { client.reimbursements.find_comment(11, 287) }
+
+        it "show a reimbursement comment successfully" do
+          expect(subject.class).to eq(comment_klass)
+          expect(subject.id).to eq(287)
+        end
+      end
+    end
+
+    describe '#create_comment' do
+      context "with success" do
+        subject { client.reimbursements.create_comment(72, { content: 'Loren ipsun dollor' }) }
+
+        it "create a comment" do
+          expect(subject.class).to eq(comment_klass)
+          expect(subject.id).to eq(678)
+        end
+      end
+    end
+
+    describe '#update_comment' do
+      context "with success" do
+        subject { client.reimbursements.update_comment(72, 678, { content: 'Foo bar' }) }
+
+        it "update comment" do
+          expect(subject.class).to eq(comment_klass)
+          expect(subject.id).to eq(678)
+          expect(subject.content).to eq('Foo bar')
+        end
+      end
+    end
+
+    describe '#destroy_comment' do
+      subject { client.reimbursements.destroy_comment(72, 678) }
+
+      it "destroy comment" do
+        expect(subject).to be_truthy
+      end
+    end
+  end
+
+  context 'Participants' do
+    let(:user_klass) { Rexpense::Entities::User }
+
+    describe "#participants" do
+      context "with success" do
+        subject { client.reimbursements.participants(70) }
+
+        it "show all reimbursements successfully" do
+          expect(subject.class).to eq(Rexpense::Entities::UserCollection)
+          expect(subject.collection.first.class).to eq(user_klass)
+        end
+      end
+    end
+
+    describe '#leave_participant' do
+      subject { client.reimbursements.leave_participant(51) }
+
+        it "show all reimbursements successfully" do
+          expect(subject).to be_truthy
+        end
+    end
+  end
+end

data/spec/lib/rexpense/resources/tag_specs.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Rexpense::Resources::Tag, vcr: true do
+  let(:tag_klass) { Rexpense::Entities::Tag }
+
+  describe '#find_all' do
+    subject { client.tags.find_all(35) }
+
+    it "show all tags successfully" do
+      expect(subject.class).to eq(Rexpense::Entities::TagCollection)
+      expect(subject.collection.first.class).to eq(tag_klass)
+    end
+
+    context "when error" do
+      let(:client) { Rexpense.client("") }
+
+      it "raises Rexpense::RequestError with 401 status code" do
+        expect { client.tags.find_all(35) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(401)
+        end
+      end
+    end
+  end
+
+  describe '#find' do
+    subject { client.tags.find(35, 64) }
+
+    it "returns a category successfully" do
+      expect(subject.class).to eq(tag_klass)
+      expect(subject.id).to eq(64)
+    end
+  end
+
+  describe '#create' do
+    subject { client.tags.create(35, { name: 'teste gem 2' }) }
+
+    it "returns a category successfully" do
+      expect(subject.class).to eq(tag_klass)
+      expect(subject.name).to eq('teste gem 2')
+    end
+
+    context "with error" do
+      it "raises Rexpense::RequestError with 422 status core" do
+        expect { client.tags.create(35, { name: '' }) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(422)
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    subject { client.tags.update(35, 64, { name: 'updated tag' }) }
+
+    it "returns a category successfully" do
+      expect(subject.class).to eq(tag_klass)
+      expect(subject.name).to eq('updated tag')
+    end
+
+    context "with error" do
+      it "raises Rexpense::RequestError with 422 status core" do
+        expect { client.tags.update(35, 64, { name: '' }) }.to raise_error(Rexpense::RequestError) do |error|
+          expect(error.code).to eq(422)
+        end
+      end
+    end
+  end
+
+  describe '#destroy' do
+    subject { client.tags.destroy(35, 90) }
+
+    context "with success" do
+      it "destroy a category successfully" do
+        expect(subject).to be_truthy
+      end
+    end
+  end
+end

data/spec/lib/rexpense/resources/webhook_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Rexpense::Resources::Webhook, vcr: true do
+  let(:webhook_klass) { Rexpense::Entities::Webhook }
+
+  describe "#find_all" do
+    context "with success" do
+      subject { client.webhooks.find_all(35) }
+
+      it "show all webhooks successfully" do
+        expect(subject.class).to eq(Rexpense::Entities::WebhookCollection)
+        expect(subject.collection.first.class).to eq(webhook_klass)
+      end
+    end
+  end
+
+  describe "#find" do
+    subject { client.webhooks.find(35, 2) }
+
+    it "returns a category successfully" do
+      expect(subject.class).to eq(webhook_klass)
+      expect(subject.id).to eq(2)
+    end
+  end
+
+  describe "#create" do
+    subject { client.webhooks.create(35, { url: 'https://requestb.in/uxd48yux' }) }
+
+    it "returns a category successfully" do
+      expect(subject.class).to eq(webhook_klass)
+      expect(subject.url).to eq('https://requestb.in/uxd48yux')
+    end
+  end
+
+  describe "#update" do
+    subject { client.webhooks.update(35, 4, { description: 'foobar' }) }
+
+    it "returns a category successfully" do
+      expect(subject.class).to eq(webhook_klass)
+      expect(subject.description).to eq('foobar')
+    end
+  end
+
+  describe "#destroy" do
+    subject { client.webhooks.destroy(35, 2) }
+
+    it "destroy a webhook successfully" do
+      expect(subject).to be_truthy
+    end
+  end
+end

data/spec/lib/rexpense/response_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe Rexpense::Response do
+  subject { described_class.new(response) }
+
+  describe "#resolve!" do
+    context 'when success' do
+      let(:response) { double(success?: true) }
+
+      it 'returns self' do
+        expect(subject.resolve!).to eq(response)
+      end
+
+      context 'when block given' do
+        let(:response) { double(success?: true) }
+
+        it 'returns block' do
+          expect(subject.resolve!{ response }).to eq(response)
+        end
+      end
+    end
+
+    context 'when timeout' do
+      let(:response) { double(success?: false, timed_out?: true) }
+
+      it 'raises RequestTimeout' do
+        expect { subject.resolve! }.to raise_error(Rexpense::RequestTimeout)
+      end
+    end
+
+    context 'when not success neither timeout' do
+      let(:response) { double(success?: false, timed_out?: false, code: 301, status_message: 'Moved Permanently', body: '') }
+
+      it 'raises RequestError' do
+        expect { subject.resolve! }.to raise_error do |error|
+          expect(error).to be_a(Rexpense::RequestError)
+          expect(error.code).to eq(301)
+          expect(error.message).to eq("Moved Permanently")
+          expect(error.body).to eq({})
+        end
+      end
+
+      context "when status_message is empty" do
+        context "when body has an 'error' key" do
+          let(:response) { double(success?: false, timed_out?: false, code: 301, status_message: '', body: '{"error": "My custom error message"}') }
+
+          it "raises RequestError with custom message" do
+            expect { subject.resolve! }.to raise_error do |error|
+              expect(error).to be_a(Rexpense::RequestError)
+              expect(error.code).to eq(301)
+              expect(error.message).to eq("My custom error message")
+              expect(error.body).to eq({ "error" => "My custom error message" })
+            end
+          end
+        end
+
+        context "when body has an 'error' key" do
+          let(:response) { double(success?: false, timed_out?: false, code: 301, status_message: '', body: '') }
+
+          it "raises RequestError with empty message" do
+            expect { subject.resolve! }.to raise_error do |error|
+              expect(error).to be_a(Rexpense::RequestError)
+              expect(error.code).to eq(301)
+              expect(error.message).to eq("")
+              expect(error.body).to eq({})
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#body" do
+    let(:response) { double(success?: true) }
+
+    context "when JSON is invalid" do
+      it "returns empty hash" do
+        allow(subject).to receive(:body).and_return("{\"key\": ")
+        expect(subject.parsed_body).to eq({})
+      end
+    end
+
+    context "when JSON is valid" do
+      it "returns empty hash" do
+        allow(subject).to receive(:body).and_return("{\"key\": \"value\"}")
+        expect(JSON).to receive(:parse).with("{\"key\": \"value\"}").and_call_original
+        expect(subject.parsed_body).to eq({ "key" => "value" })
+      end
+    end
+  end
+end

data/spec/lib/rexpense_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Rexpense do
+  it "has a version number" do
+    expect(Rexpense::VERSION).to_not be_nil
+  end
+
+  describe "configuration" do
+    it "should be done via block initialization" do
+      Rexpense.configure do |c|
+        c.user_agent = "My App v1.0"
+        c.api_mode = "sandbox"
+        c.version = 'v1'
+      end
+
+      expect(Rexpense.configuration.user_agent).to eq("My App v1.0")
+      expect(Rexpense.configuration.api_mode).to eq("sandbox")
+      expect(Rexpense.configuration.version).to eq("v1")
+    end
+
+    it "uses a singleton object for the configuration values" do
+      config1 = Rexpense.configuration
+      config2 = Rexpense.configuration
+      expect(config1).to eq(config2)
+    end
+  end
+
+  describe ".client" do
+    it "instantiates a new client" do
+      expect(Rexpense::Client).to receive(:new).with("abc").and_call_original
+      Rexpense.client("abc")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require "codeclimate-test-reporter"
+require "simplecov"
+
+CodeClimate::TestReporter.start
+
+SimpleCov.start do
+  SimpleCov.maximum_coverage_drop 0.2
+
+  SimpleCov.start do
+    add_group  "Resources", "lib/rexpense/resources"
+    add_group  "Entities",  "lib/rexpense/entities"
+    add_filter "vendor"
+  end
+end
+
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "rexpense"
+require "pry"
+require "vcr"
+
+
+Dir["spec/support/**/*.rb"].each { |f| load f }
+
+VCR.configure do |config|
+  config.cassette_library_dir = "spec/vcr_cassettes"
+  config.hook_into :typhoeus
+  config.ignore_hosts "codeclimate.com"
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before(:each) do
+    Rexpense.configuration.api_mode = "sandbox"
+    Typhoeus::Expectation.clear
+  end
+end
+

data/spec/support/client.rb

@@ -0,0 +1,3 @@
+def client
+  Rexpense.client("8cd049b4afca9213fb2455528394ab2fb0bc34f5c905f33c")
+end

data/spec/support/matchers/have_attr_accessor.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :have_attr_accessor do |field|
+  match do |object_instance|
+    object_instance.respond_to?(field) &&
+      object_instance.respond_to?("#{field}=")
+  end
+
+  failure_message do |object_instance|
+    "expected attr_accessor for #{field} on #{object_instance}"
+  end
+
+  failure_message_when_negated do |object_instance|
+    "expected attr_accessor for #{field} not to be defined on #{object_instance}"
+  end
+
+  description do
+    "checks to see if there is an attr accessor on the supplied object"
+  end
+end

data/spec/support/shared_examples/entity_attributes.rb

@@ -0,0 +1,9 @@
+shared_examples "entity_attributes" do |attrs|
+  attrs.each do |attr|
+    it { is_expected.to have_attr_accessor(attr) }
+  end
+
+  it "expect to cover all attributes" do
+    expect(subject.attributes.keys).to match_array(attrs)
+  end
+end

data/spec/support/shared_examples/entity_collection.rb

@@ -0,0 +1,19 @@
+shared_examples :entity_collection do |entity_type, key|
+  let(:params) { double(headers: {}, parsed_body: { key => [] }) }
+
+  subject { described_class.new(params) }
+
+  context "#build" do
+    it "returns a collection(#{described_class})" do
+      expect(subject.build).to be_a(described_class)
+    end
+  end
+
+  context "#collection" do
+    before { subject.build }
+
+    it "returns items(#{entity_type})" do
+      expect(subject.collection).to all(be_a(entity_type))
+    end
+  end
+end

data/spec/support/shared_examples/http_request_methods.rb

@@ -0,0 +1,35 @@
+shared_examples "available http request methods" do
+  it "instantiates a new Request object" do
+    VCR.use_cassette("client/#{http_method}/request") do
+      expect(Rexpense::Request).to receive(:new).with(
+        body: params,
+        method: http_method,
+        token: "8cd049b4afca9213fb2455528394ab2fb0bc34f5c905f33c",
+        url: "https://sandbox.rexpense.com/api/v1#{url}",
+        user_agent: "Rexpense Ruby Client v#{Rexpense::VERSION}"
+      ).and_call_original
+      subject.send(http_method, url, body: params)
+    end
+  end
+
+  it "runs the request" do
+    VCR.use_cassette("client/#{http_method}/request") do
+      expect_any_instance_of(Rexpense::Request).to receive(:run).and_call_original
+      subject.send(http_method, url, body: params)
+    end
+  end
+
+  it "instantiates a new Response object" do
+    VCR.use_cassette("client/#{http_method}/request") do
+      expect(Rexpense::Response).to receive(:new).and_call_original
+      subject.send(http_method, url, body: params)
+    end
+  end
+
+  it "resolves the response of the request a new Response object" do
+    VCR.use_cassette("client/#{http_method}/request") do
+      expect_any_instance_of(Rexpense::Response).to receive(:resolve!).and_call_original
+      subject.send(http_method, url, body: params)
+    end
+  end
+end

data/spec/support/vcr.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  # pass `vcr: true` to an example to run it using VCR
+  config.around(:each, vcr: true) do |example|
+    name = example.metadata[:full_description].gsub(/\W+/, "_").split("_", 2).join("/").gsub('::', '_')[0, 94]
+    VCR.use_cassette(name, record: :once) { example.call }
+  end
+end