nf-e 0.2.26

data/spec/nfe/helpers/xml_model/factory_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Nfe::Helpers::XmlModel::Factory do
+  describe ".create" do
+    context "when type is omitted" do
+      it "returns an AttributeText instance" do
+        attribute = described_class.create(:foo)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeText
+      end
+    end
+
+    context "when type is :text" do
+      let(:options) { { type: :text } }
+
+      it "returns an AttributeText instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeText
+      end
+    end
+
+    context "when type is :bigdecimal" do
+      let(:options) { { type: :bigdecimal } }
+
+      it "returns an AttributeBigdecimal instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeBigdecimal
+      end
+    end
+
+    context "when type is :collection" do
+      let(:options) { { type: :collection } }
+
+      it "returns an AttributeCollection instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeCollection
+      end
+    end
+
+    context "when type is :date" do
+      let(:options) { { type: :date } }
+
+      it "returns an AttributeDate instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeDate
+      end
+    end
+
+    context "when type is :datetime" do
+      let(:options) { { type: :datetime } }
+
+      it "returns an AttributeDatetime instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeDatetime
+      end
+    end
+
+    context "when type is :enumerize" do
+      let(:options) { { type: :enumerize } }
+
+      it "returns an AttributeEnumerize instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeEnumerize
+      end
+    end
+
+    context "when type is :float" do
+      let(:options) { { type: :float } }
+
+      it "returns an AttributeFloat instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeFloat
+      end
+    end
+
+    context "when type is :integer" do
+      let(:options) { { type: :integer } }
+
+      it "returns an AttributeInteger instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeInteger
+      end
+    end
+
+    context "when type is :node" do
+      let(:options) { { type: :node } }
+
+      it "returns an AttributeNode instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeNode
+      end
+    end
+
+    context "when type is :attribute" do
+      let(:options) { { type: :attribute } }
+
+      it "returns an AttributeNodeattribute instance" do
+        attribute = described_class.create(:foo, options)
+        expect(attribute).to be_an_instance_of Nfe::Helpers::XmlModel::AttributeNodeattribute
+      end
+    end
+  end
+end

data/spec/nfe/helpers/xml_model/nfe_model_spec.rb

@@ -0,0 +1,225 @@
+require "spec_helper"
+
+class Baz
+  include ActiveModel::Model
+  include Nfe::Helpers::XmlModel::NfeModel
+  attr_xml :value
+  validates :value, length: { is: 4 }
+end
+
+class Base
+  include ActiveModel::Model
+  include Nfe::Helpers::XmlModel::NfeModel
+  extend Enumerize
+  enumerize :glu, in: { aaa: 1 }
+
+  def initialize
+    @baz = Baz.new
+  end
+
+  attr_xml :foo, required: true, xml_alias: :FooAlias
+  attr_xml :jaz
+  attr_xml :baz, type: :node, required: false
+  attr_xml :glu, type: :enumerize
+end
+
+class Bar < Base
+  attr_xml :float, type: :float, format: "%0.2f"
+  attr_xml :integer, type: :integer
+end
+
+class Foo < Bar
+  attr_xml :date, type: :date
+  attr_xml :datetime, type: :datetime
+end
+
+describe Nfe::Helpers::XmlModel::NfeModel do
+  let(:xml) do
+    "<FooAlias>foo</FooAlias>"\
+    "<jaz>jaz</jaz>"\
+    "<baz><value>baz</value></baz>"\
+    "<glu>1</glu>"\
+    "<float>10.47</float>"\
+    "<integer>28</integer>"\
+    "<date>2004-10-24</date>"\
+    "<datetime>2004-10-24T02:01:12-03:00</datetime>"
+  end
+
+  subject { Foo.new }
+
+  describe ".attr_xml" do
+    it "add attribute in class" do
+      expect(subject.respond_to?(:foo)).to be
+      expect(subject.respond_to?(:jaz)).to be
+      expect(subject.respond_to?(:baz)).to be
+      expect(subject.respond_to?(:float)).to be
+      expect(subject.respond_to?(:integer)).to be
+      expect(subject.respond_to?(:date)).to be
+      expect(subject.respond_to?(:datetime)).to be
+    end
+  end
+
+  describe ".xml_attribute" do
+    it "get an xml_attribute" do
+      expect(subject.class.xml_attribute(:foo)).to be_a Nfe::Helpers::XmlModel::AttributeBase
+    end
+  end
+
+  describe ".xml_attributes" do
+    it "returns all xml_attributes" do
+      expect(subject.class.xml_attributes.size).to eql 8
+    end
+  end
+
+  shared_examples "parse all elements" do
+    it "parses all" do
+      expect(subject.foo).to eq "foo"
+      expect(subject.jaz).to eq "jaz"
+      expect(subject.baz.value).to eq "baz"
+      expect(subject.glu).to eq "aaa"
+      expect(subject.float).to eq 10.47
+      expect(subject.integer).to eq 28
+      expect(subject.date).to eq Date.parse("2004-10-24")
+      expect(subject.datetime).to eq DateTime.strptime("2004-10-24T02:01:12-03:00",
+        "%Y-%m-%dT%H:%M:%S%:z")
+    end
+  end
+
+  describe "#parse!" do
+    let(:doc) { "<root>#{xml}</root>" }
+
+    before { subject.parse! doc }
+
+    it_behaves_like "parse all elements"
+  end
+
+  describe "#parse_elements" do
+    let(:doc) { "<root>#{xml}</root>" }
+
+    context "when the attributes are informed" do
+      before do
+        subject.parse_elements doc, :foo, :jaz, :baz, :glu, :float, :integer,
+          :date, :datetime
+      end
+
+      it_behaves_like "parse all elements"
+    end
+
+    context "when the attributes aren't informed" do
+      before { subject.parse_elements doc }
+
+      it_behaves_like "parse all elements"
+    end
+
+    context "when doc is a Nokogiri's object" do
+      let(:doc) { Nokogiri::XML("<root>#{xml}</root>") }
+
+      before { subject.parse_elements doc }
+
+      it_behaves_like "parse all elements"
+    end
+  end
+
+  let(:full_subject) do
+    full = Foo.new
+    full.foo = "foo"
+    full.jaz = "jaz"
+    full.baz.value = "baz"
+    full.glu = "aaa"
+    full.float = 10.47
+    full.integer = 28
+    full.date = Date.parse("2004-10-24")
+    full.datetime = DateTime.strptime("2004-10-24T02:01:12-03:00",
+      "%Y-%m-%dT%H:%M:%S%:z")
+    full
+  end
+
+  describe "#to_xml" do
+    it "write all" do
+      expect(full_subject.to_xml).to eq xml
+    end
+  end
+
+  describe "#add_elements" do
+    let(:builder) { Builder::XmlMarkup.new }
+
+    shared_examples "write all elements in xml" do
+      it "write all" do
+        expect(builder.target!).to eq xml
+      end
+    end
+
+    context "when the attributes are informed" do
+      before do
+        subject = full_subject
+        subject.add_elements builder, :foo, :jaz, :baz, :glu, :float, :integer,
+          :date, :datetime
+      end
+
+      it_behaves_like "write all elements in xml"
+    end
+
+    context "when the attributes aren't informed" do
+      before do
+        subject = full_subject
+        subject.add_elements builder
+      end
+
+      it_behaves_like "write all elements in xml"
+    end
+  end
+
+  describe "#present?" do
+    context "when some attribute is present" do
+      before { subject.foo = "foo" }
+      it "returns true" do
+        expect(subject.present?).to be
+      end
+    end
+
+    context "when any attribute is present" do
+      it "returns false" do
+        expect(subject.present?).to_not be
+      end
+    end
+  end
+
+  describe "#check_present" do
+    context "when some attribute is present" do
+      before { subject.foo = "foo" }
+      it "returns true" do
+        expect(subject.check_present).to be
+      end
+    end
+
+    context "when any attribute is present" do
+      it "returns false" do
+        expect(subject.check_present).to_not be
+      end
+    end
+  end
+
+  describe "#validate_optional_attributes" do
+    context "when attribute is present and invalid" do
+      it "add errors" do
+        subject.baz.value = "invalid"
+        subject.validate_optional_attributes :baz
+        expect(subject.errors.to_json).to match(/baz/)
+      end
+    end
+
+    context "when attribute isn't present" do
+      it "doesn't add errors" do
+        subject.validate_optional_attributes :baz
+        expect(subject.errors).to be_empty
+      end
+    end
+  end
+
+  describe "#validate_required_attributes" do
+    it "add errors when attribute doesn't valid" do
+      subject.validate_required_attributes :baz
+      expect(subject.errors.to_json).to match(/baz/)
+    end
+  end
+end

data/spec/nfe/models/NFe_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Nfe::Models::NFe do
+  subject { build :NFe }
+
+  it "has a valid factory" do
+    expect(subject).to be_valid
+  end
+
+  context "when infNFe is invalid" do
+    before { subject.infNFe.ide.uf = "" }
+
+    describe "#valid?" do
+      it { is_expected.to_not be_valid }
+    end
+  end
+
+  context "when xml has all tags" do
+    let(:xml) do
+      xml  = "<NFe xmlns=\"http://www.portalfiscal.inf.br/nfe\">"
+      xml +=   "<infNFe versao=\"3.10\" Id=\"NFe42130901144012000152551231234567891123456785\">"
+      xml +=     "#{build(:infNFe).to_xml}"
+      xml +=   "</infNFe>"
+      xml +=   "<Signature xmlns=\"#{Nfe::Models::Signature.namespace}\">"
+      xml +=     "#{build(:signature).value}"
+      xml +=   "</Signature>"
+      xml += "</NFe>"
+    end
+
+    describe "#to_xml" do
+      it "returns a formatted xml" do
+        expect(subject.to_xml).to eql xml
+      end
+    end
+
+    describe "#parse!" do
+      subject { Nfe::Models::NFe.new }
+      before { subject.parse!("<NFe xmlns='#{Nfe::Models::NFe.namespace}'>#{xml}</NFe>") }
+
+      it "parses xml" do
+        expect(subject.infNFe.to_xml).to eql build(:infNFe).to_xml
+        expect(subject.signature.value).to eql build(:signature).value
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+end

data/spec/nfe/models/avulsa_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+require_relative "shared_examples_for_tdec_1302"
+
+describe Nfe::Models::Avulsa do
+  subject { build(:avulsa) }
+
+  it "has a valid factory" do
+    expect(subject).to be_valid
+  end
+
+  it { is_expected.to ensure_length_of(:xOrgao).is_at_least(1).is_at_most(60) }
+
+  it { is_expected.to ensure_length_of(:matr).is_at_most(60) }
+
+  it { is_expected.to ensure_length_of(:xAgente).is_at_least(1).is_at_most(60) }
+
+  it { is_expected.to allow_value("", nil).for(:fone) }
+  it { is_expected.to ensure_length_of(:fone).is_at_least(6).is_at_most(14) }
+  it { is_expected.to validate_numericality_of(:fone).only_integer }
+
+  it { is_expected.to ensure_length_of(:uf).is_equal_to(2) }
+
+  it { is_expected.to allow_value("", nil).for(:nDAR) }
+  it { is_expected.to ensure_length_of(:nDAR).is_at_most(60) }
+
+  it { is_expected.to allow_value("", nil).for(:dEmi) }
+
+  it { is_expected.to allow_value("", nil).for(:vDAR) }
+  it { is_expected.to validate_numericality_of(:vDAR ) }
+
+  it { is_expected.to ensure_length_of(:repEmi).is_at_least(1).is_at_most(60) }
+
+  it { is_expected.to allow_value("", nil).for(:dPag) }
+
+  it_should_behave_like "a numeric TDec_1302Opc field", :vDAR
+
+  describe "#CNPJ" do
+    context "when number is invalid" do
+      before { subject.cnpj = "04001155000103" }
+      it { is_expected.not_to be_valid }
+    end
+
+    it {
+      is_expected.to ensure_length_of(:cnpj)
+        .is_equal_to(14)
+        .with_message(/não possui o tamanho esperado/)
+    }
+  end
+
+  describe "#present?" do
+    subject { Nfe::Models::Avulsa.new }
+
+    context "when any attribute is present" do
+      it { is_expected.to_not be_present }
+    end
+
+    context "when some attribute is present" do
+      before { subject.xAgente = "James Bond" }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  context "when xml has all tags" do
+    let(:xml) do
+      xml  = "<CNPJ>01144012000152</CNPJ>"
+      xml += "<xOrgao>Secretaria de Segurança Pública</xOrgao>"
+      xml += "<matr>PN13654987</matr>"
+      xml += "<xAgente>James Bond</xAgente>"
+      xml += "<fone>4832630000</fone>"
+      xml += "<UF>SC</UF>"
+      xml += "<nDAR>11213551684313513516846832136518</nDAR>"
+      xml += "<dEmi>2013-10-20</dEmi>"
+      xml += "<vDAR>123456.78</vDAR>"
+      xml += "<repEmi>Tributos</repEmi>"
+      xml += "<dPag>2013-11-25</dPag>"
+    end
+
+    describe "#to_xml" do
+      it "returns a formatted xml" do
+        expect(subject.to_xml).to eql xml
+      end
+    end
+
+    describe "#parse!" do
+      subject { Nfe::Models::Avulsa.new }
+      before { subject.parse!("<root>#{xml}</root>") }
+
+      it "parses xml" do
+        expect(subject.cnpj ).to eql "01144012000152"
+        expect(subject.xOrgao).to eql "Secretaria de Segurança Pública"
+        expect(subject.matr).to eql "PN13654987"
+        expect(subject.xAgente).to eql "James Bond"
+        expect(subject.fone).to eql "4832630000"
+        expect(subject.uf).to eql "SC"
+        expect(subject.nDAR).to eql "11213551684313513516846832136518"
+        expect(subject.dEmi).to eql Date.parse("2013-10-20")
+        expect(subject.vDAR).to eql 123456.78
+        expect(subject.repEmi).to eql "Tributos"
+        expect(subject.dPag).to eql Date.parse("2013-11-25")
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context "when xml doesn't have optional tags" do
+    let(:xml) do
+      xml  = "<CNPJ>01144012000152</CNPJ>"
+      xml += "<xOrgao>Secretaria de Segurança Pública</xOrgao>"
+      xml += "<matr>PN13654987</matr>"
+      xml += "<xAgente>James Bond</xAgente>"
+      xml += "<UF>SC</UF>"
+      xml += "<repEmi>Tributos</repEmi>"
+    end
+
+    describe "#to_xml" do
+      it "returns a formatted xml" do
+        subject = build(:avulsa, fone: nil, nDAR: nil, dEmi: nil, vDAR: nil, dPag: nil)
+        expect(subject.to_xml).to eql xml
+      end
+    end
+
+    describe "#parse!" do
+      subject { Nfe::Models::Avulsa.new }
+      before { subject.parse!("<root>#{xml}</root>") }
+
+      it "parses xml values to itself" do
+        expect(subject.cnpj ).to eql "01144012000152"
+        expect(subject.xOrgao).to eql "Secretaria de Segurança Pública"
+        expect(subject.matr).to eql "PN13654987"
+        expect(subject.xAgente).to eql "James Bond"
+        expect(subject.uf).to eql "SC"
+        expect(subject.repEmi).to eql "Tributos"
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+end