nf-e 0.2.26

data/spec/nfe/operations/nfe_discard_spec.rb

@@ -0,0 +1,172 @@
+require "spec_helper"
+require_relative "shared_examples_for_operations"
+
+describe Nfe::Operations::NfeDiscard do
+  let(:private_key) { OpenSSL::PKey::RSA.new(File.read("spec/nfe/fixtures/private-key.pem")) }
+  let(:certificate) { OpenSSL::X509::Certificate.new(File.read("spec/nfe/fixtures/certificate.pem")) }
+  let(:reason) { "example of justification" }
+  let(:uf) { "SC" }
+  let(:cnpj) { "03883369000188" }
+  let(:series) { 1 }
+  let(:initial_number) { 1100 }
+
+  subject do
+    described_class.new(certificate: certificate, private_key: private_key,
+      environment: :test, uf: uf, cnpj: cnpj, series: series, reason: reason,
+      initial_number: initial_number)
+  end
+
+  describe "#execute" do
+    context "when works" do
+      it "returns true" do
+        VCR.use_cassette("nfe_discard/success") do
+          expect(subject.execute).to be_truthy
+        end
+      end
+    end
+
+    context "when certificate is invalid" do
+      let(:certificate) { nil }
+
+      before { subject.execute }
+
+      it "fills an errors object" do
+        expect(subject.errors.full_messages).to include I18n.t("webservice.invalid_certificate")
+      end
+    end
+
+    context "when private_key is invalid" do
+      let(:private_key) { nil }
+
+      before { subject.execute }
+
+      it "fills an errors object" do
+        expect(subject.errors.full_messages).to include I18n.t("webservice.invalid_private_key")
+      end
+    end
+
+    context "when uf is invalid" do
+      let(:uf) { nil }
+
+      before { subject.execute }
+
+      it "fills an errors object" do
+        expect(subject.errors.full_messages).to include I18n.t("nfe_discard.invalid_uf")
+      end
+    end
+
+    context "when cnpj is invalid" do
+      let(:cnpj) { nil }
+
+      before { subject.execute }
+
+      it "fills an errors object" do
+        expect(subject.errors.full_messages).to include I18n.t("nfe_discard.invalid_cnpj")
+      end
+    end
+
+    context "when series is invalid" do
+      let(:series) { nil }
+
+      before { subject.execute }
+
+      it "fills an errors object" do
+        expect(subject.errors.full_messages).to include I18n.t("nfe_discard.invalid_series")
+      end
+    end
+
+    context "when number is invalid" do
+      let(:initial_number) { nil }
+
+      before { subject.execute }
+
+      it "fills an errors object" do
+        expect(subject.errors.full_messages).to include I18n.t("nfe_discard.invalid_number")
+      end
+    end
+
+    context "when reason is invalid" do
+      let(:reason) { nil }
+
+      before { subject.execute }
+
+      it "fills an errors object" do
+        expect(subject.errors.full_messages).to include I18n.t("nfe_discard.invalid_reason")
+      end
+    end
+
+    context "when result xml is unexpected" do
+      before { VCR.use_cassette("nfe_discard/invalid_response") { subject.execute } }
+
+      it "fills an errors object" do
+        expect(subject.errors).to_not be_empty
+      end
+    end
+  end
+
+  describe "#success?" do
+    context "when SEFAZ rejects the issue" do
+      before { VCR.use_cassette("nfe_discard/rejected") { subject.execute } }
+
+      it "returns false" do
+        expect(subject).to_not be_success
+      end
+    end
+
+    context "when SEFAZ returns discarded" do
+      before { VCR.use_cassette("nfe_discard/success") { subject.execute } }
+
+      it "returns true" do
+        expect(subject).to be_success
+      end
+    end
+  end
+
+  describe "#rejected?" do
+    context "when SEFAZ returns reject" do
+      before { VCR.use_cassette("nfe_discard/rejected") { subject.execute } }
+
+      it "returns true" do
+        expect(subject).to be_rejected
+      end
+    end
+
+    context "when SEFAZ doesn't reject" do
+      before { VCR.use_cassette("nfe_discard/success") { subject.execute } }
+
+      it "returns false" do
+        expect(subject).to_not be_rejected
+      end
+    end
+  end
+
+  describe "#message" do
+    ["success", "rejected"].each do |state|
+      context "when SEFAZ returns #{state}" do
+        before { VCR.use_cassette("nfe_discard/#{state}") { subject.execute } }
+
+        it "returns the SEFAZ message" do
+          expect(subject.message).to_not be_nil
+        end
+      end
+    end
+  end
+
+  describe "#discard_xml" do
+    context "when success" do
+      before { VCR.use_cassette("nfe_discard/success") { subject.execute } }
+
+      it "returns the XML" do
+        expect(subject.discard_xml).to start_with "<ProcInutNFe"
+      end
+    end
+
+    context "when not authorized" do
+      before { VCR.use_cassette("nfe_discard/rejected") { subject.execute } }
+
+      it "returns blank" do
+        expect(subject.discard_xml).to be_blank
+      end
+    end
+  end
+end

data/spec/nfe/operations/nfe_send_spec.rb

@@ -0,0 +1,220 @@
+require "spec_helper"
+
+describe Nfe::Operations::NfeSend do
+  let(:private_key) { OpenSSL::PKey::RSA.new(File.read("spec/nfe/fixtures/private-key.pem")) }
+  let(:certificate) { OpenSSL::X509::Certificate.new(File.read("spec/nfe/fixtures/certificate.pem")) }
+
+  let(:nfe) do
+    nfe = Nfe::Models::NFe.new
+    nfe.parse!(File.read("spec/nfe/fixtures/nfe.xml"))
+    nfe
+  end
+
+  subject { described_class.new(certificate, private_key, nfe) }
+
+  describe "#execute" do
+    context "when works" do
+      it "returns true" do
+        VCR.use_cassette("nfe_send/authorized") do
+          expect(subject.execute).to be_truthy
+        end
+      end
+    end
+
+    context "when webservice informs that is an invalid lot" do
+      before { VCR.use_cassette("nfe_send/error_in_lot") { subject.execute } }
+
+      it "fills an errors object" do
+        expect(subject.errors).to_not be_empty
+      end
+    end
+
+    context "when result xml is unexpected" do
+      before { VCR.use_cassette("nfe_send/invalid_response") { subject.execute } }
+
+      it "fills an errors object" do
+        expect(subject.errors).to_not be_empty
+      end
+    end
+
+    context "when nfe is invalid" do
+      let(:nfe) do
+        nfe = Nfe::Models::NFe.new
+        nfe.parse!(File.read("spec/nfe/fixtures/nfe.xml"))
+        nfe.infNFe.emit.xNome = nil
+        nfe
+      end
+
+      before { VCR.use_cassette("nfe_send/authorized") { subject.execute } }
+
+      it "fills an errors object" do
+        expect(subject.errors).to_not be_empty
+      end
+    end
+  end
+
+  describe "#nfe_status" do
+    ["authorized", "denied", "rejected"].each do |state|
+      context "when SEFAZ returns #{state}" do
+        before { VCR.use_cassette("nfe_send/#{state}") { subject.execute } }
+
+        it "returns #{state}" do
+          expect(subject.nfe_status).to be state.to_sym
+        end
+      end
+    end
+
+    context "when webservice doesn't process the NFe" do
+      before { VCR.use_cassette("nfe_send/error_in_lot") { subject.execute } }
+
+      it "returns false" do
+        expect(subject.nfe_status).to eq :pending
+      end
+    end
+  end
+
+
+  describe "#authorized?" do
+    context "when SEFAZ doesn't authorize" do
+      before { VCR.use_cassette("nfe_send/rejected") { subject.execute } }
+
+      it "returns false" do
+        expect(subject).to_not be_authorized
+      end
+    end
+
+    context "when SEFAZ returns authorized" do
+      before { VCR.use_cassette("nfe_send/authorized") { subject.execute } }
+
+      it "returns true" do
+        expect(subject).to be_authorized
+      end
+    end
+  end
+
+  describe "#denied?" do
+    context "when SEFAZ returns denied" do
+      before { VCR.use_cassette("nfe_send/denied") { subject.execute } }
+
+      it "returns true" do
+        expect(subject).to be_denied
+      end
+    end
+
+    context "when SEFAZ doesn't denied" do
+      before { VCR.use_cassette("nfe_send/rejected") { subject.execute } }
+
+      it "returns false" do
+        expect(subject).to_not be_denied
+      end
+    end
+  end
+
+  describe "#rejected?" do
+    context "when SEFAZ returns reject" do
+      before { VCR.use_cassette("nfe_send/rejected") { subject.execute } }
+
+      it "returns true" do
+        expect(subject).to be_rejected
+      end
+    end
+
+    context "when SEFAZ doesn't reject" do
+      before { VCR.use_cassette("nfe_send/authorized") { subject.execute } }
+
+      it "returns false" do
+        expect(subject).to_not be_rejected
+      end
+    end
+  end
+
+  describe "#processed?" do
+    ["authorized", "denied", "rejected"].each do |state|
+      context "when SEFAZ returns #{state}" do
+        before { VCR.use_cassette("nfe_send/#{state}") { subject.execute } }
+
+        it "returns true" do
+          expect(subject).to be_processed
+        end
+
+        it "doesn't add messages in errors" do
+          expect(subject.errors).to be_empty
+        end
+      end
+    end
+  end
+
+  describe "#message" do
+    context "when SEFAZ doesn't return a NFe's state" do
+      before { VCR.use_cassette("nfe_send/error_in_lot") { subject.execute } }
+
+      it "returns nil" do
+        expect(subject.message).to be_nil
+      end
+    end
+
+    ["authorized", "denied", "rejected"].each do |state|
+      context "when SEFAZ returns #{state}" do
+        before { VCR.use_cassette("nfe_send/#{state}") { subject.execute } }
+
+        it "returns the SEFAZ message" do
+          expect(subject.message).to_not be_nil
+        end
+      end
+    end
+  end
+
+  describe "#authorized_xml" do
+    context "when authorized" do
+      before { VCR.use_cassette("nfe_send/authorized") { subject.execute } }
+
+      it "returns the XML" do
+        expect(subject.authorized_xml).to start_with "<nfeProc"
+      end
+    end
+
+    context "when not authorized" do
+      before { VCR.use_cassette("nfe_send/rejected") { subject.execute } }
+
+      it "returns blank" do
+        expect(subject.authorized_xml).to be_blank
+      end
+    end
+  end
+
+  describe "#protocol_number" do
+    context "when authorized" do
+      before { VCR.use_cassette("nfe_send/authorized") { subject.execute } }
+
+      it "returns the protocol number" do
+        expect(subject.protocol_number).to eq "342140000245084"
+      end
+    end
+
+    context "when not authorized" do
+      before { VCR.use_cassette("nfe_send/rejected") { subject.execute } }
+
+      it "returns blank" do
+        expect(subject.protocol_number).to be_blank
+      end
+    end
+  end
+
+  describe "#nfe_key" do
+    context "when authorized" do
+      before { VCR.use_cassette("nfe_send/authorized") { subject.execute } }
+
+      it "returns the nfe key" do
+        expect(subject.nfe_key).to eq "42150101144012000152550010000001111000000734"
+      end
+    end
+
+    context "when not authorized" do
+      before { VCR.use_cassette("nfe_send/rejected") { subject.execute } }
+
+      it "returns blank" do
+        expect(subject.nfe_key).to be_blank
+      end
+    end
+  end
+end

data/spec/nfe/operations/nfe_situation_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require_relative "shared_examples_for_operations"
+
+describe Nfe::Operations::NfeSituation do
+  let(:private_key) { OpenSSL::PKey::RSA.new(File.read("spec/nfe/fixtures/private-key.pem")) }
+  let(:certificate) { OpenSSL::X509::Certificate.new(File.read("spec/nfe/fixtures/certificate.pem")) }
+  let(:nfe_key) { "43140101144012000152550010000000011123456781" }
+  let(:invalid_nfe_key) { "4314010114401200015255001000000001112345678" }
+
+  let(:operation) { described_class.new(certificate, private_key, :test, nfe_key) }
+
+  it_should_behave_like "an operation", "retConsSitNFe",
+    Nfe::Services::Dispatch::ConsSitNFe, Nfe::Services::Regress::RetConsSitNFe
+end

data/spec/nfe/operations/service_status_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+require_relative "shared_examples_for_operations"
+
+describe Nfe::Operations::ServiceStatus do
+  let(:private_key) { OpenSSL::PKey::RSA.new(File.read("spec/nfe/fixtures/private-key.pem")) }
+  let(:certificate) { OpenSSL::X509::Certificate.new(File.read("spec/nfe/fixtures/certificate.pem")) }
+  let(:operation) { described_class.new(certificate, private_key, :test, "SC") }
+
+  it_should_behave_like "an operation", "retConsStatServ",
+    Nfe::Services::Dispatch::ConsStatServ, Nfe::Services::Regress::RetConsStatServ
+end

data/spec/nfe/operations/shared_examples_for_operations.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+shared_examples "an operation" do | fixture, object_send, object_result |
+  let(:webservice) { Nfe::Webservices::Sender }
+
+  let(:xml) do
+    Nokogiri::XML(File.read("spec/nfe/webservices/fixtures/#{fixture}.xml"))
+  end
+
+  let(:errors) do
+    errors = ActiveModel::Errors.new(described_class)
+    errors.add(:base, "x")
+    errors
+  end
+
+  let(:invalid) { Nokogiri::XML::Document.new }
+
+  describe "#execute" do
+    context "when works" do
+      before do
+        allow_any_instance_of(webservice).to receive(:execute).and_return(true)
+        allow_any_instance_of(webservice).to receive(:result).and_return(xml)
+      end
+
+      it "returns true" do
+        expect(operation.execute).to be_truthy
+      end
+
+      it "fills a #{object_result} object" do
+        operation.execute
+        expect(operation.result).to be_an_instance_of object_result
+      end
+    end
+
+    context "when webservice don't work" do
+      before do
+        allow_any_instance_of(webservice).to receive(:execute).and_return(false)
+        allow_any_instance_of(webservice).to receive(:errors).and_return(errors)
+      end
+
+      it "returns false" do
+        expect(operation.execute).to be_falsey
+      end
+
+      it "fills an errors object" do
+        operation.execute
+        expect(operation.errors).to_not be_empty
+      end
+    end
+
+    context "when result xml is unexpected" do
+      before do
+        allow_any_instance_of(webservice).to receive(:execute).and_return(true)
+        allow_any_instance_of(webservice).to receive(:result).and_return(invalid)
+      end
+
+      it "returns false" do
+        expect(operation.execute).to be_falsey
+      end
+
+      it "fills an errors object" do
+        operation.execute
+        expect(operation.errors).to_not be_empty
+      end
+    end
+
+    context "when object has invalid attributes" do
+      before do
+        allow_any_instance_of(webservice).to receive(:execute).and_return(true)
+        allow_any_instance_of(webservice).to receive(:result).and_return(xml)
+        allow_any_instance_of(object_send).to receive(:versao).and_return("XX")
+      end
+
+      it "returns false" do
+        expect(operation.execute).to be_falsey
+      end
+
+      it "fills an errors object" do
+        operation.execute
+        expect(operation.errors).to_not be_empty
+      end
+    end
+  end
+end