emites-client 0.0.2

data/spec/emites/http_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Emites::Http do
+  let(:token) { "t0k3n" }
+  let!(:request) do
+    class_spy(Typhoeus::Request).
+      as_stubbed_const(transfer_nested_constants: true)
+  end
+
+  let!(:response) do
+    Typhoeus::Response.new(return_code: :ok, code: 200, body: "OK")
+  end
+
+  before :each do
+    Typhoeus.stub(/emites/).and_return(response)
+    allow(Typhoeus::Request).to receive(:new).
+      and_return(double :request, run: true, response: response)
+  end
+
+  subject { described_class.new(token) }
+
+  shared_examples "verbs" do |verb|
+    it "sends a #{verb.to_s.upcase} request to emites API" do
+      subject.send(verb, "/some_resource")
+      expect(request).to have_received(:new).
+        with("https://sandbox.emites.com.br/api/v1/some_resource",
+             method: verb,
+             userpwd: "#{token}:x",
+             accept_encoding: "gzip",
+             headers:  {
+                "Accept"      => "application/json",
+                "Content-Type"  => "application/json",
+                "User-Agent"  => Emites.configuration.user_agent
+              }
+            )
+    end
+
+    it "raises RequestTimeout when timed out" do
+      response = Typhoeus::Response.new(return_code: :operation_timedout)
+      Typhoeus.stub(/emites/).and_return(response)
+      allow(Typhoeus::Request).to receive(:new).
+        and_return(double :request, run: true, response: response)
+
+      expect { subject.send(verb, "/some_resource") }.to raise_error(Emites::RequestTimeout)
+    end
+
+    it "raises RequestError when an error occurred" do
+      response = Typhoeus::Response.new(return_code: :ok, code: 500, body: "")
+      Typhoeus.stub(/emites/).and_return(response)
+      allow(Typhoeus::Request).to receive(:new).
+        and_return(double :request, run: true, response: response)
+
+      expect { subject.send(verb, '/some_resource') }.to raise_error(Emites::RequestError)
+    end
+  end
+
+  [:get, :post, :put, :patch, :delete].each do |verb|
+    describe "##{verb.to_s}" do
+      it_behaves_like "verbs", verb
+    end
+  end
+end

data/spec/emites/resources/base_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+describe Emites::Resources::Base do
+
+  module Emites::Entities
+    class Dummy < Base
+    end
+  end
+
+  module Emites::Resources
+    class Dummy < Base
+      def parseable
+        response = http.get("/1mayrfq1")
+        parsed_body(response)
+      end
+
+      def fail
+        http.get("/fail")
+      end
+
+      def timeout
+        http.get("/timeout")
+      end
+
+      def notifiable(id)
+        "notifiable [#{id}]"
+      end
+
+      notify :notifiable
+    end
+  end
+
+  let(:http) { Emites::Http.new("7A75E575CFDEDB91FF7E2CE22089181A") }
+  let(:request) { double(body: nil, return_code: :ok) }
+
+  subject { Emites::Resources::Dummy.new(http) }
+
+  before do
+    allow(Emites.configuration).to receive(:url).and_return("http://requestb.in")
+  end
+
+  describe "#parsed_body" do
+    before do
+      allow(http).to receive(:send_request).and_return(request)
+    end
+
+    it "does not raise an error" do
+      expect{ subject.parseable }.not_to raise_error
+    end
+
+    it "response returns an empty hash" do
+      expect(subject.parseable).to eq({})
+    end
+  end
+
+  describe ".notify" do
+    before do
+      allow(http).to receive(:send_request).and_return(request)
+    end
+
+    class FakeListener
+      def call(result, args)
+        [result, args]
+      end
+    end
+
+    let(:listener) { FakeListener.new }
+
+    before do
+      Emites.subscribe("emites.dummy.notifiable", listener)
+    end
+
+    it "does not affect method return" do
+      expect(subject.notifiable(42)).to eq("notifiable [42]")
+    end
+
+    it "notifies listeners about event" do
+      expect(listener).to receive(:call).with("notifiable [42]", [42]).
+        and_return(["notifiable [42]", [42]])
+      subject.notifiable(42)
+    end
+  end
+
+  context "when request fails" do
+
+    it "raises an RequestError" do
+      Typhoeus.stub(/fail/).and_return(Typhoeus::Response.new(return_code: nil))
+      expect { subject.fail }.to raise_error(Emites::RequestError)
+    end
+
+    it "raises an RequestTimeout" do
+      Typhoeus.stub(/timeout/).and_return(Typhoeus::Response.new(return_code: :operation_timedout))
+      expect { subject.timeout }.to raise_error(Emites::RequestTimeout)
+    end
+  end
+end

data/spec/emites/resources/emitter_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Emites::Resources::Emitter do
+  let(:http)          { Emites::Http.new("7A75E575CFDEDB91FF7E2CE22089181A") }
+  let(:entity_klass)  { Emites::Entities::Emitter }
+  let(:params) do
+    {
+      email:            "wanderson.policarpo@myfreecomm.com.br",
+      social_reason:    "My Fake, Inc",
+      cnpj:             "01001001000113",
+      fancy_name:       "My Fake",
+      city_inscription: "3304557",
+      state:            "RJ",
+      city:             "3",
+      neighborhood:     "Icaraí",
+      street_type:      "RUA",
+      street:           "Avenida Roberto Silveira - de 472 ao fim - lado par",
+      number:           43,
+      zip_code:         "24230-163",
+      phone:            "2199999999",
+      certificate:      Base64.encode64(File.read("spec/fixtures/certificate.pfx")),
+      password:         "123456"
+    }
+  end
+
+  subject { described_class.new(http) }
+
+  it "has a instance of Emites::Http" do
+    expect(subject.http).to eq http
+  end
+
+  it_behaves_like "bound_notifiers", [:create, :destroy]
+
+  describe "#create" do
+    it "creates an emitter" do
+      VCR.use_cassette("emitters/create/success") do
+        emitter = subject.create(params)
+        expect(emitter).to be_a(entity_klass)
+        expect(emitter.cnpj).to eq(params[:cnpj])
+      end
+    end
+
+    it "returns RequestError" do
+      VCR.use_cassette("emitters/create/error") do
+        expect {
+          subject.create({ email: "email@example.com" })
+        }.to raise_error(Emites::RequestError)
+      end
+    end
+  end
+
+  describe "#info" do
+    it "returns an Emitter instance where id is 4" do
+      VCR.use_cassette("emitters/info/success") do
+        emitter = subject.info(4)
+        expect(emitter).to be_a(entity_klass)
+        expect(emitter.cnpj).to eq("17799377000155")
+      end
+    end
+
+    it "returns RequestError" do
+      VCR.use_cassette("emitters/info/error") do
+        expect {
+          subject.info(2)
+        }.to raise_error(Emites::RequestError)
+      end
+    end
+  end
+
+  describe "#list" do
+    it "returns an array of emitters" do
+      VCR.use_cassette("emitters/list/success") do
+        entities = subject.list
+        expect(entities).to be_a(Array)
+        entities.each do |e|
+          expect(e).to be_a(entity_klass)
+        end
+      end
+    end
+  end
+
+  describe "#search" do
+    it "returns an array of emitters where CNPJ is '17799377000155'" do
+      VCR.use_cassette("emitters/search/success") do
+        entities = subject.search({ cnpj: "17799377000155" })
+        expect(entities).to be_a(Array)
+        expect(entities.count).to eq(1)
+        entities.each do |e|
+          expect(e).to be_a(entity_klass)
+        end
+      end
+    end
+
+    it "returns empty" do
+      VCR.use_cassette("emitters/search/returns_empty") do
+        entities = subject.search({ cnpj: "1775" })
+        expect(entities).to be_a(Array)
+        expect(entities).to be_empty
+      end
+    end
+  end
+
+  describe "#destroy" do
+    it "deletes an emitter" do
+      VCR.use_cassette("emitters/destroy/success") do
+        result = subject.destroy(18)
+        expect(result).to be_truthy
+      end
+    end
+
+    it "returns RequestError" do
+      VCR.use_cassette("emitters/destroy/error") do
+        expect {
+          subject.destroy(2)
+        }.to raise_error(Emites::RequestError)
+      end
+    end
+  end
+end

data/spec/emites/resources/nfse_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+require "time"
+
+describe Emites::Resources::Nfse do
+  let(:http)          { Emites::Http.new("7A75E575CFDEDB91FF7E2CE22089181A") }
+  let(:entity_klass)  { Emites::Entities::Nfse }
+  let(:params) do
+    {
+      emitter_id:         4,
+      rps_type:           1,
+      serie:              "a",
+      emission_date:      Time.now.utc.iso8601,
+      operation_nature:   1,
+      rps_situation:      1,
+      service_values:     {
+        service_amount:       1000.0,
+        deduction_amount:     0,
+        retained_iss:         false,
+        calculation_base:     1000.0,
+        iss_percentage:       5.00,
+        iss_amount:           50.0,
+        pis_amount:           0,
+        cofins_amount:        0,
+        inss_amount:          0,
+        ir_amount:            0,
+        csll_amount:          0,
+        service_item_code:    "0105",
+        city_tax_code:        "010501",
+        description:          "RSPEC Servicos de informatica",
+        city_code:            3304557,
+        nfse_liquid_amount:   1000.0,
+        discount_conditioning_amount: 0
+      },
+      taker:               {
+        cpf:                  "83051507121",
+        city_inscription:     "92708711",
+        social_reason:        "Tomador RSPEC",
+        address:      {
+          street:             "Feijó Júnior",
+          number:             "535",
+          neighborhood:       "São Pelegrino",
+          neighborhood_type:  "COM",
+          city_code:          4305108,
+          state:              "RS",
+          zip_code:           95110550,
+          city:               "Caxias do Sul"
+        },
+        contact:      {
+          phone:              "32272144",
+          ddd:                54
+        }
+      }
+    }
+  end
+
+  subject { described_class.new(http) }
+
+  it "has a instance of Emites::Http" do
+    expect(subject.http).to eq http
+  end
+
+  it_behaves_like "bound_notifiers", [:create, :update, :cancel, :destroy]
+
+  describe "#list" do
+    it "returns an array of Nfse" do
+      VCR.use_cassette("nfse/list/success") do
+        nfses = subject.list
+        expect(nfses).to be_a(Array)
+        nfses.each do |e|
+          expect(e).to be_a(entity_klass)
+        end
+      end
+    end
+  end
+
+  describe "#info" do
+    it "returns a Nfse instance where id is 456" do
+      VCR.use_cassette("nfse/info/success") do
+        nfse = subject.info(456)
+        expect(nfse).to be_a(entity_klass)
+        expect(nfse.serie). to eq("MYFC")
+        expect(nfse.taker).to be_a(Emites::Entities::Taker)
+      end
+    end
+  end
+
+  describe "#status" do
+    it "returns a Nfse instance status representation" do
+      VCR.use_cassette("nfse/status/success") do
+        nfse_status = subject.status(456)
+        expect(nfse_status).to be_a(Emites::Entities::NfseStatus)
+        expect(nfse_status.status).to eq("accepted")
+        expect(nfse_status.description).to eq("Processado pela Sefaz")
+      end
+    end
+  end
+
+  describe "#history" do
+    it "returns a Nfse instance status history" do
+      VCR.use_cassette("nfse/history/success") do
+        nfse_status_history = subject.history(456)
+        expect(nfse_status_history).to be_a(Array)
+        nfse_status_history.each do |e|
+          expect(e).to be_a(Emites::Entities::NfseStatusTransition)
+        end
+      end
+    end
+  end
+
+  describe "#pdf" do
+    it "returns a Nfse pdf" do
+      VCR.use_cassette("nfse/pdf/success") do
+        pdf_url = subject.pdf(456)
+        expect(pdf_url).to be_a(String)
+        expect(pdf_url).to match(/https?/)
+      end
+    end
+  end
+
+  describe "#xml" do
+    it "returns a Nfse xml" do
+      VCR.use_cassette("nfse/xml/success") do
+        xml_url = subject.xml(456)
+        expect(xml_url).to be_a(String)
+        expect(xml_url).to match(/https?/)
+      end
+    end
+  end
+
+  describe "#cancel" do
+    it "cancels a Nfse" do
+      VCR.use_cassette("nfse/cancel/success") do
+        nfse = subject.cancel(456)
+        expect(nfse).to be_a(Emites::Entities::NfseStatus)
+        expect(nfse.status).to eq("cancelling")
+      end
+    end
+  end
+
+  describe "#destroy" do
+    it "deletes a Nfse" do
+      VCR.use_cassette("nfse/destroy/success") do
+        result = subject.destroy(455)
+        expect(result).to be_truthy
+      end
+    end
+  end
+
+  describe "#create" do
+    it "creates a completely new Nfse" do
+      VCR.use_cassette("nfse/create/success") do
+        nfse   = subject.create(params)
+        taker  = nfse.taker
+        values = nfse.service_values
+
+        expect(nfse).to be_a(entity_klass)
+
+        expect(taker).to be_a(Emites::Entities::Taker)
+        expect(taker.social_reason).to eq(params[:taker][:social_reason])
+
+        expect(values).to be_a(Emites::Entities::NfseValues)
+        expect(values.description).to eq(params[:service_values][:description])
+      end
+    end
+
+    it "creates a Nfse where taker already exists" do
+      VCR.use_cassette("nfse/create/given_taker") do
+        params.delete(:taker)
+        params[:taker_id] = 6
+
+        nfse = subject.create(params)
+
+        expect(nfse.taker).to be_a(Emites::Entities::Taker)
+        expect(nfse.taker.social_reason).to eq("Fulano de Tal")
+      end
+    end
+
+    it "creates a Nfse without a taker" do
+      VCR.use_cassette("nfse/create/without_taker") do
+        params.delete(:taker)
+
+        nfse = subject.create(params)
+
+        expect(nfse.taker).to be_nil
+      end
+    end
+
+    it "creates an incomplete Nfse" do
+      VCR.use_cassette("nfse/create/incomplete") do
+        params.delete(:taker)
+        params.delete(:service_values)
+        params[:allow_incomplete] = true
+
+        nfse = subject.create(params)
+
+        expect(nfse).to be_a(entity_klass)
+        expect(nfse.status).to eq("created")
+      end
+    end
+  end
+
+  describe "#update" do
+    it "updates a Nfse" do
+      VCR.use_cassette("nfse/update/success") do
+        nfse = subject.update(564, params)
+
+        expect(nfse).to be_a(entity_klass)
+        expect(nfse.status).to eq("scheduled")
+        expect(nfse.service_values.service_amount).to eq(1000.0)
+      end
+    end
+  end
+
+end