nf-e 0.2.26

data/spec/nfe/models/bigdecimal_greater_than_validator_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe BigdecimalGreaterThanValidator do
+  before(:each) do
+    @validator = BigdecimalGreaterThanValidator.new(attributes: "bigdecimal")
+    @mock = double("model")
+    allow(@mock).to receive(:errors).and_return([])
+    allow(@mock.errors).to receive(:messages).and_return({})
+    allow(@mock.errors).to receive(:add) do |attribute, error|
+       @mock.errors.messages[attribute] = [error]
+    end
+  end
+
+  subject { @validator }
+
+  context "when big decimal is valid" do
+    it "doesn't add errors in model" do
+      valid = BigDecimal("99_999_999_999.9999999999")
+
+      subject.validate_each(@mock, "bigdecimal", valid)
+      expect(@mock.errors.messages).to be_empty
+    end
+  end
+
+  context "when big decimal is not valid" do
+    it "add errors in model" do
+      invalid = BigDecimal("100_000_000_000.9999999999")
+
+      subject.validate_each(@mock, "bigdecimal", invalid)
+      expect(@mock.errors.messages).to_not be_empty
+    end
+  end
+end

data/spec/nfe/models/bigdecimal_less_than_validator_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe BigdecimalLessThanValidator do
+  before(:each) do
+    @validator = BigdecimalLessThanValidator.new(attributes: "bigdecimal")
+    @mock = double("model")
+    allow(@mock).to receive(:errors).and_return([])
+    allow(@mock.errors).to receive(:messages).and_return({})
+    allow(@mock.errors).to receive(:add) do |attribute, error|
+       @mock.errors.messages[attribute] = [error]
+    end
+  end
+
+  subject { @validator }
+
+  context "when big decimal is valid" do
+    it "doesn't add errors in model" do
+      valid = BigDecimal("99_999_999_999.9999999999")
+
+      subject.validate_each(@mock, "bigdecimal", valid)
+      expect(@mock.errors.messages).to be_empty
+    end
+  end
+
+  context "when big decimal is not valid" do
+    it "add errors in model" do
+      invalid = -1
+
+      subject.validate_each(@mock, "bigdecimal", invalid)
+      expect(@mock.errors.messages).to_not be_empty
+    end
+  end
+end

data/spec/nfe/models/bill/cobr_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+describe Nfe::Models::Bill::Cobr do
+  subject { build(:cobr) }
+
+  context "when fat is present and invalid" do
+    it "returns an error on fat" do
+      subject.fat.vOrig = 999_999_999_999_999.99
+      subject.valid?
+
+      expect(subject.errors.to_json).to match(/fat/)
+    end
+  end
+
+  context "when dup is present and invalid" do
+    it "returns an error on dup" do
+      subject.dup[0].vDup = 999_999_999_999_999.99
+      subject.valid?
+
+      expect(subject.errors.to_json).to match(/dup/)
+    end
+  end
+
+  it "has a valid factory" do
+    expect(subject).to be_valid
+  end
+
+  describe "#dup" do
+    it "should be less than or equal to 120" do
+      121.times { subject.dup << build(:dup) }
+      subject.valid?
+      expect(subject.errors[:dup].to_s).to match(/deve ser menor ou igual a 120/)
+    end
+  end
+
+  describe "#present?" do
+    subject { Nfe::Models::Bill::Cobr.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.dup << "X"  }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  context "when xml has all tags" do
+    let(:xml) do
+      xml = "<fat>#{build(:fat).to_xml}</fat>"
+      3.times { |n| xml += "<dup>#{build(:dup, nDup: n).to_xml}</dup>" }
+      xml
+    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::Bill::Cobr.new }
+      before { subject.parse!("<root>#{xml}</root>") }
+
+      it "parses xml" do
+        expect(subject.fat.to_xml).to eql build(:fat).to_xml
+        expect(subject.dup[0].to_xml).to eql build(:dup, nDup: 0).to_xml
+        expect(subject.dup[1].to_xml).to eql build(:dup, nDup: 1).to_xml
+        expect(subject.dup[2].to_xml).to eql build(:dup, nDup: 2).to_xml
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context "when xml doesn't have optional tags" do
+    subject { Nfe::Models::Bill::Cobr.new }
+
+    describe "#to_xml" do
+      it "returns a formatted xml" do
+        expect(subject.to_xml).to_not be_present
+      end
+    end
+
+    describe "#parse!" do
+      before { subject.parse!("<root></root>") }
+
+      it "parses xml" do
+        expect(subject.fat).to_not be_present
+        expect(subject.dup).to be_blank
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+end

data/spec/nfe/models/bill/dup_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe Nfe::Models::Bill::Dup do
+  subject { build(:dup) }
+
+  it "has a valid factory" do
+    expect(subject).to be_valid
+  end
+
+  it { is_expected.to allow_value("", nil).for(:nDup) }
+  it { is_expected.to ensure_length_of(:nDup).is_at_most(60) }
+
+  it { is_expected.to allow_value("", nil).for(:dVenc) }
+
+  it { is_expected.to allow_value("", nil).for(:vDup) }
+  it { is_expected.to validate_numericality_of(:vDup) }
+
+  it "should require vDup to be greater than or equal to zero" do
+    subject.vDup = -1
+    subject.valid?
+
+    expect(subject.errors[:vDup].to_s).to match(/deve ser maior ou igual a 0/)
+  end
+
+  it "should require vDup to be less than or equal to 9999999999999.99" do
+    subject.vDup = 12_345_678_901_234.56
+    subject.valid?
+
+    expect(subject.errors[:vDup].to_s).to match(/deve ser menor ou igual a 9999999999999.99/)
+  end
+
+  context "when xml has all tags" do
+    let(:xml) do
+      xml  = "<nDup>100-1</nDup>"
+      xml += "<dVenc>2013-09-25</dVenc>"
+      xml += "<vDup>1234567890123.45</vDup>"
+    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::Bill::Dup.new }
+      before { subject.parse!("<root>#{xml}</root>") }
+
+      it "parses xml" do
+        expect(subject.nDup).to eql "100-1"
+        expect(subject.dVenc).to eql Date.parse("2013-09-25")
+        expect(subject.vDup).to eql 1_234_567_890_123.45
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context "when xml doesn't have optional tags" do
+    subject { Nfe::Models::Bill::Dup.new }
+
+    describe "#to_xml" do
+      it "returns a formatted xml" do
+        expect(subject.to_xml).to_not be_present
+      end
+    end
+
+    describe "#parse!" do
+      before { subject.parse!("<root></root>") }
+
+      it "parses xml" do
+        expect(subject.nDup).to be_blank
+        expect(subject.dVenc).to be_nil
+        expect(subject.vDup).to be_blank
+      end
+
+      it { is_expected.to be_valid}
+    end
+  end
+end

data/spec/nfe/models/bill/fat_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+describe Nfe::Models::Bill::Fat do
+  subject { build(:fat) }
+
+  it "has a valid factory" do
+    expect(subject).to be_valid
+  end
+
+  it { is_expected.to allow_value("", nil).for(:nFat) }
+  it { is_expected.to ensure_length_of(:nFat).is_at_most(60) }
+
+  it { is_expected.to allow_value("", nil).for(:vOrig) }
+  it { is_expected.to validate_numericality_of(:vOrig) }
+
+  it "should require vOrig to be greater than or equal to zero" do
+    subject.vOrig = -1
+    subject.valid?
+
+    expect(subject.errors[:vOrig].to_s).to match(/deve ser maior ou igual a 0/)
+  end
+
+  it "should require vOrig to be less than or equal to 9999999999999.99" do
+    subject.vOrig = 12_345_678_901_234.56
+    subject.valid?
+
+    expect(subject.errors[:vOrig].to_s).to match(/deve ser menor ou igual a 9999999999999.99/)
+  end
+
+  it { is_expected.to allow_value("", nil).for(:vDesc) }
+  it { is_expected.to validate_numericality_of(:vDesc) }
+
+  it "should require vDesc to be greater than or equal to zero" do
+    subject.vDesc = -1
+    subject.valid?
+
+    expect(subject.errors[:vDesc].to_s).to match(/deve ser maior ou igual a 0/)
+  end
+
+  it "should require vDesc to be less than or equal to 9999999999999.99" do
+    subject.vDesc = 12_345_678_901_234.56
+    subject.valid?
+
+    expect(subject.errors[:vDesc].to_s).to match(/deve ser menor ou igual a 9999999999999.99/)
+  end
+
+  it { is_expected.to allow_value("", nil).for(:vLiq) }
+  it { is_expected.to validate_numericality_of(:vLiq) }
+
+  it "should require vLiq to be greater than or equal to zero" do
+    subject.vLiq = -1
+    subject.valid?
+
+    expect(subject.errors[:vLiq].to_s).to match(/deve ser maior ou igual a 0/)
+  end
+
+  it "should require vLiq to be less than or equal to 9999999999999.99" do
+    subject.vLiq = 12_345_678_901_234.56
+    subject.valid?
+
+    expect(subject.errors[:vLiq].to_s).to match(/deve ser menor ou igual a 9999999999999.99/)
+  end
+
+  describe "#present?" do
+    subject { Nfe::Models::Bill::Fat.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.nFat = "1" }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  context "when xml has all tags" do
+    let(:xml) do
+      xml  = "<nFat>100</nFat>"
+      xml += "<vOrig>1234567890123.45</vOrig>"
+      xml += "<vDesc>1234567890123.45</vDesc>"
+      xml += "<vLiq>1234567890123.45</vLiq>"
+    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::Bill::Fat.new }
+      before { subject.parse!("<root>#{xml}</root>") }
+
+      it "parses xml" do
+        expect(subject.nFat).to eql "100"
+        expect(subject.vOrig).to eql 1_234_567_890_123.45
+        expect(subject.vDesc).to eql 1_234_567_890_123.45
+        expect(subject.vLiq).to eql 1_234_567_890_123.45
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context "when xml doesn't have optional tags" do
+    subject { Nfe::Models::Bill::Fat.new }
+
+    describe "#to_xml" do
+      it "returns a formatted xml" do
+        expect(subject.to_xml).to_not be_present
+      end
+    end
+
+    describe "#parse!" do
+      before { subject.parse!("<root></root>") }
+
+      it "parses xml" do
+        expect(subject.nFat).to  be_blank
+        expect(subject.vOrig).to be_blank
+        expect(subject.vDesc).to be_blank
+        expect(subject.vLiq).to  be_blank
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+end

data/spec/nfe/models/cane/cana_spec.rb

@@ -0,0 +1,161 @@
+require "spec_helper"
+
+describe Nfe::Models::Cane::Cana do
+  subject { build(:cana) }
+
+  it "has a valid factory" do
+    expect(subject).to be_valid
+  end
+
+  it { is_expected.to ensure_length_of(:safra).is_at_least(4).is_at_most(9) }
+
+  it { is_expected.to ensure_length_of(:ref).is_equal_to(7) }
+
+  it { is_expected.to validate_presence_of :vFor }
+  it { is_expected.to validate_numericality_of(:vFor) }
+
+  it { is_expected.to validate_presence_of :vTotDed }
+  it { is_expected.to validate_numericality_of(:vTotDed) }
+
+  it { is_expected.to validate_presence_of :vLiqFor }
+  it { is_expected.to validate_numericality_of(:vLiqFor) }
+
+  context "when forDia is present and invalid" do
+    it "returns an error on fat" do
+      forDia = Nfe::Models::Cane::ForDia.new
+      subject.forDia << build(:forDia, dia: :invalid)
+      subject.valid?
+
+      expect(subject.errors.to_json).to match(/forDia/)
+    end
+  end
+
+  context "when deduc is present and invalid" do
+    it "returns an error on dup" do
+      deduc = Nfe::Models::Cane::Deduc.new
+      subject.deduc << build(:deduc, vDed: :invalid)
+      subject.valid?
+
+      expect(subject.errors.to_json).to match(/deduc/)
+    end
+  end
+
+  describe "#qTotMes" do
+    it "should be greater than or equal to 0" do
+      subject.qTotMes = -1
+      subject.valid?
+
+      expect(subject.errors[:qTotMes].to_s).to match(/deve ser maior ou igual a 0/)
+    end
+
+    it "should be less than or equal to 99999999999.9999999999" do
+      subject.qTotMes = "100_000_000_000.0000000000"
+      subject.valid?
+
+      expect(subject.errors[:qTotMes].to_s).to match(/deve ser menor ou igual a 99999999999.9999999999/)
+    end
+  end
+
+  describe "#qTotAnt" do
+    it "should be greater than or equal to 0" do
+      subject.qTotAnt = -1
+      subject.valid?
+
+      expect(subject.errors[:qTotAnt].to_s).to match(/deve ser maior ou igual a 0/)
+    end
+
+    it "should be less than or equal to 99999999999.9999999999" do
+      subject.qTotAnt = "100_000_000_000.0000000000"
+      subject.valid?
+
+      expect(subject.errors[:qTotAnt].to_s).to match(/deve ser menor ou igual a 99999999999.9999999999/)
+    end
+  end
+
+  describe "#qTotGer" do
+    it "should be greater than or equal to 0" do
+      subject.qTotGer = -1
+      subject.valid?
+
+      expect(subject.errors[:qTotGer].to_s).to match(/deve ser maior ou igual a 0/)
+    end
+
+    it "should be less than or equal to 99999999999.9999999999" do
+      subject.qTotGer = "100_000_000_000.0000000000"
+      subject.valid?
+
+      expect(subject.errors[:qTotGer].to_s).to match(/deve ser menor ou igual a 99999999999.9999999999/)
+    end
+  end
+
+  describe "#present?" do
+    subject { Nfe::Models::Cane::Cana.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.ref = "11/2013" }
+
+      it { is_expected.to be_present }
+    end
+  end
+
+  context "when xml has all tags" do
+    let(:xml) do
+      xml = "<safra>2013</safra>"
+      xml += "<ref>11/2013</ref>"
+      xml += "<forDia dia=\"1\"><qtde>99999999999.9999999999</qtde></forDia>"
+      xml += "<forDia dia=\"2\"><qtde>99999999999.9999999999</qtde></forDia>"
+      xml += "<forDia dia=\"3\"><qtde>99999999999.9999999999</qtde></forDia>"
+      xml += "<qTotMes>99999999999.9999999999</qTotMes>"
+      xml += "<qTotAnt>99999999999.9999999999</qTotAnt>"
+      xml += "<qTotGer>99999999999.9999999999</qTotGer>"
+      xml += "<deduc><xDed>Deduc0</xDed><vDed>12345.67</vDed></deduc>"
+      xml += "<deduc><xDed>Deduc1</xDed><vDed>12345.67</vDed></deduc>"
+      xml += "<vFor>12345.67</vFor>"
+      xml += "<vTotDed>12345.67</vTotDed>"
+      xml += "<vLiqFor>12345.67</vLiqFor>"
+      xml
+    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::Cane::Cana.new }
+      before(:each) { subject.parse!("<root>#{xml}</root>") }
+
+      it "parses xml" do
+        expect(subject.safra).to eql "2013"
+        expect(subject.ref).to eql "11/2013"
+
+        expect(subject.forDia[0].dia).to eql "1"
+        expect(subject.forDia[0].qtde).to eql BigDecimal("99999999999.9999999999")
+        expect(subject.forDia[1].dia).to eql "2"
+        expect(subject.forDia[1].qtde).to eql BigDecimal("99999999999.9999999999")
+        expect(subject.forDia[2].dia).to eql "3"
+        expect(subject.forDia[2].qtde).to eql BigDecimal("99999999999.9999999999")
+
+        expect(subject.qTotMes).to eql BigDecimal("99999999999.9999999999")
+        expect(subject.qTotAnt).to eql BigDecimal("99999999999.9999999999")
+        expect(subject.qTotGer).to eql BigDecimal("99999999999.9999999999")
+
+        expect(subject.deduc[0].xDed).to eql "Deduc0"
+        expect(subject.deduc[0].vDed).to eql 12345.67
+        expect(subject.deduc[1].xDed).to eql "Deduc1"
+        expect(subject.deduc[1].vDed).to eql 12345.67
+
+        expect(subject.vFor).to eql 12345.67
+        expect(subject.vTotDed).to eql 12345.67
+        expect(subject.vLiqFor).to eql 12345.67
+      end
+
+      it { is_expected.to be_valid }
+    end
+  end
+end