focus_nfe 1.0.0

data/spec/focus_nfe/esquemas/esquema_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Esquemas::Esquema do
+  describe ".carregar" do
+    it "carrega o schema empacotado de um documento conhecido", :aggregate_failures do
+      esquema = described_class.carregar("nfe")
+
+      expect(esquema).to be_a(described_class)
+      expect(esquema.campos).to all(be_a(FocusNfe::Esquemas::Campo))
+      expect(esquema.campos).not_to be_empty
+    end
+
+    it "devolve nil quando não há schema para o documento" do
+      expect(described_class.carregar("nfce")).to be_nil
+    end
+
+    it "memoiza o schema carregado" do
+      expect(described_class.carregar("nfe")).to equal(described_class.carregar("nfe"))
+    end
+
+    it "devolve nil para nomes inválidos (traversal)", :aggregate_failures do
+      expect(described_class.carregar("../../../../etc/hostname")).to be_nil
+      expect(described_class.carregar("nfe/../nfe")).to be_nil
+      expect(described_class.carregar("../secret")).to be_nil
+    end
+
+    it "não consulta o filesystem para nomes inválidos" do
+      allow(File).to receive(:exist?).and_call_original
+
+      described_class.carregar("../../../../etc/passwd")
+
+      expect(File).not_to have_received(:exist?)
+    end
+
+    it "não memoiza nomes inválidos (cache permanece limitado)" do
+      described_class.carregar("../etc/hostname")
+
+      expect(described_class.send(:cache)).not_to have_key("../etc/hostname")
+    end
+  end
+
+  describe "#campos" do
+    let(:definicoes) do
+      [
+        { "name" => "serie", "type" => "String[1-3]", "required" => true },
+        { "name" => "numero", "type" => "Integer[1-9]", "required" => true }
+      ]
+    end
+
+    it "constrói Campos a partir das definições in-memory", :aggregate_failures do
+      esquema = described_class.new(definicoes)
+
+      expect(esquema.campos.map(&:nome)).to eq(%w[serie numero])
+      expect(esquema.campos.first).to be_obrigatorio
+    end
+  end
+
+  describe "#descrever" do
+    let(:definicoes) do
+      [
+        { "name" => "serie", "type" => "String[1-3]", "required" => true },
+        { "name" => "numero", "type" => "Integer[1-9]", "required" => true }
+      ]
+    end
+
+    it "descreve cada campo como um Hash", :aggregate_failures do
+      descricao = described_class.new(definicoes).descrever
+
+      expect(descricao).to eq(definicoes.map { |d| FocusNfe::Esquemas::Campo.new(d).to_h })
+      expect(descricao.map { |c| c[:nome] }).to eq(%w[serie numero])
+    end
+  end
+end

data/spec/focus_nfe/esquemas/validador_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Esquemas::Validador do
+  subject(:validador) { described_class.new(esquema) }
+
+  let(:esquema) do
+    FocusNfe::Esquemas::Esquema.new(
+      [
+        { "name" => "natureza_operacao", "type" => "String[1-60]", "required" => true },
+        { "name" => "serie", "type" => "String[1-3]", "required" => false },
+        { "name" => "numero", "type" => "Integer[1-9]", "required" => false },
+        { "name" => "items", "type" => "Coleção[1-990]", "required" => true,
+          "collection" => { "object_attributes" => [valor_obrigatorio] } }
+      ]
+    )
+  end
+
+  let(:valor_obrigatorio) { { "name" => "valor", "type" => "Decimal[13.2]", "required" => true } }
+
+  describe "#validar" do
+    it "acusa campo obrigatório ausente" do
+      erros = validador.validar("serie" => "1")
+
+      expect(erros.join).to include("natureza_operacao")
+    end
+
+    it "acusa string acima do tamanho máximo" do
+      erros = validador.validar("natureza_operacao" => "Venda", "serie" => "1234", "items" => [])
+
+      expect(erros.join).to include("serie")
+    end
+
+    it "não acusa nada para um payload válido" do
+      erros = validador.validar("natureza_operacao" => "Venda", "items" => [{ "valor" => "10.00" }])
+
+      expect(erros).to eq([])
+    end
+
+    it "propaga erro de decimal de dentro de uma coleção" do
+      erros = validador.validar("natureza_operacao" => "Venda", "items" => [{ "valor" => "10.123" }])
+
+      expect(erros.join).to include("items[1].valor")
+    end
+
+    it "propaga erro de enum de um campo de topo" do
+      esquema = FocusNfe::Esquemas::Esquema.new(
+        [{ "name" => "indicador", "type" => nil, "enum" => "* +0+: Não\\n* +1+: Sim", "required" => true }]
+      )
+
+      expect(described_class.new(esquema).validar("indicador" => "9").join).to include("indicador")
+    end
+
+    it "aceita chaves String e Symbol no payload", :aggregate_failures do
+      expect(validador.validar(natureza_operacao: "Venda", items: [])).to eq([])
+      expect(validador.validar("natureza_operacao" => "Venda", "items" => [])).to eq([])
+    end
+  end
+
+  describe "#validar!" do
+    it "levanta ErroDeValidacao com a lista de erros", :aggregate_failures do
+      expect { validador.validar!("serie" => "1") }.to raise_error(FocusNfe::Esquemas::ErroDeValidacao) do |erro|
+        expect(erro.erros.join).to include("natureza_operacao")
+        expect(erro.erros.join).to include("items")
+      end
+    end
+
+    it "não levanta para payload válido" do
+      expect { validador.validar!("natureza_operacao" => "Venda", "items" => []) }.not_to raise_error
+    end
+  end
+
+  describe "#validar recorrendo em coleções" do
+    subject(:validador) { described_class.new(esquema) }
+
+    let(:esquema) do
+      FocusNfe::Esquemas::Esquema.new(
+        [
+          { "name" => "itens", "type" => "Coleção[1-990]", "required" => true,
+            "collection" => { "object_attributes" => [
+              { "name" => "descricao", "type" => "String[1-5]", "required" => true },
+              { "name" => "adicoes", "type" => "Coleção[0-99]", "required" => false,
+                "collection" => { "object_attributes" => [
+                  { "name" => "numero", "type" => "Integer[1-3]", "required" => true }
+                ] } }
+            ] } }
+        ]
+      )
+    end
+
+    it "acusa subcampo obrigatório ausente dentro do item" do
+      erros = validador.validar("itens" => [{}])
+
+      expect(erros.join).to include("itens[1].descricao", "campo obrigatório ausente")
+    end
+
+    it "valida tipo/tamanho do subcampo dentro do item" do
+      erros = validador.validar("itens" => [{ "descricao" => "longa demais" }])
+
+      expect(erros.join).to include("itens[1].descricao")
+    end
+
+    it "usa a posição (base 1) no prefixo do erro" do
+      erros = validador.validar("itens" => [{ "descricao" => "ok" }, {}])
+
+      expect(erros.join).to include("itens[2].descricao")
+    end
+
+    it "acusa coleção que não é Array" do
+      expect(validador.validar("itens" => "x").join).to include("itens: deve ser uma coleção")
+    end
+
+    it "acusa item que não é objeto" do
+      expect(validador.validar("itens" => ["x"]).join).to include("itens[1]: deve ser um objeto")
+    end
+
+    it "recorre em coleções aninhadas em qualquer profundidade" do
+      erros = validador.validar("itens" => [{ "descricao" => "ok", "adicoes" => [{}] }])
+
+      expect(erros.join).to include("itens[1].adicoes[1].numero")
+    end
+
+    it "não acusa nada quando todos os itens são válidos" do
+      dados = { "itens" => [{ "descricao" => "ok", "adicoes" => [{ "numero" => "12" }] }] }
+
+      expect(validador.validar(dados)).to eq([])
+    end
+
+    it "não restringe o conteúdo de coleção sem object_attributes" do
+      esquema = FocusNfe::Esquemas::Esquema.new(
+        [{ "name" => "anexos", "type" => "Coleção[0-9]", "collection" => {} }]
+      )
+
+      expect(described_class.new(esquema).validar("anexos" => [{ "x" => "y" }])).to eq([])
+    end
+  end
+
+  describe "#validar com sub-esquemas aninhados" do
+    subject(:validador) { described_class.new(esquema_topo, aninhados: { "modal_rodoviario" => sub_esquema }) }
+
+    let(:esquema_topo) { FocusNfe::Esquemas::Esquema.new([]) }
+    let(:sub_esquema) do
+      FocusNfe::Esquemas::Esquema.new([{ "name" => "rntrc", "type" => "String[8]", "required" => true }])
+    end
+
+    it "não acusa nada quando o objeto aninhado é válido" do
+      expect(validador.validar("modal_rodoviario" => { "rntrc" => "12345678" })).to eq([])
+    end
+
+    it "valida o objeto aninhado com chaves Symbol" do
+      expect(validador.validar(modal_rodoviario: { rntrc: "12345678" })).to eq([])
+    end
+
+    it "prefixa os erros do aninhado com a chave" do
+      erros = validador.validar("modal_rodoviario" => { "rntrc" => "1" })
+
+      expect(erros.join).to include("modal_rodoviario.rntrc")
+    end
+
+    it "exige o objeto aninhado declarado" do
+      expect(validador.validar({}).join).to include("modal_rodoviario: campo obrigatório ausente")
+    end
+
+    it "acusa quando o aninhado não é um objeto" do
+      expect(validador.validar("modal_rodoviario" => "x").join).to include("modal_rodoviario: deve ser um objeto")
+    end
+  end
+end

data/spec/focus_nfe/esquemas_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Esquemas do
+  describe ".disponiveis" do
+    it "lista os nomes dos documentos com schema empacotado", :aggregate_failures do
+      disponiveis = described_class.disponiveis
+
+      expect(disponiveis).to be_an(Array)
+      expect(disponiveis).to all(be_a(String))
+      expect(disponiveis).to include("nfe")
+    end
+
+    it "devolve os nomes ordenados e sem duplicatas", :aggregate_failures do
+      disponiveis = described_class.disponiveis
+
+      expect(disponiveis).to eq(disponiveis.uniq)
+      expect(disponiveis).to eq(disponiveis.sort)
+    end
+  end
+
+  describe ".descrever" do
+    it "devolve a descrição estruturada de cada campo do documento", :aggregate_failures do
+      campos = described_class.descrever("nfe")
+
+      expect(campos).to be_an(Array)
+      expect(campos).not_to be_empty
+      expect(campos.first).to include(:nome, :tipo, :obrigatorio)
+    end
+
+    it "devolve nil quando não há schema para o documento" do
+      expect(described_class.descrever("documento_inexistente")).to be_nil
+    end
+
+    it "devolve nil para nomes inválidos (traversal)" do
+      expect(described_class.descrever("../../foo")).to be_nil
+    end
+
+    it "expõe os campos sem exigir token nem conexão" do
+      expect { described_class.descrever("nfe") }.not_to raise_error
+    end
+  end
+end

data/spec/focus_nfe/http/adapter_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::HTTP::Adapter do
+  it "define #call como interface abstrata, levantando NotImplementedError" do
+    expect { described_class.new.call(:get, "https://exemplo.test/x") }
+      .to raise_error(NotImplementedError)
+  end
+end

data/spec/focus_nfe/http/adapters/net_http_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::HTTP::Adapters::NetHttp do
+  subject(:adapter) { described_class.new(timeout: 30, open_timeout: 10) }
+
+  let(:url) { "https://api.exemplo.test/recurso" }
+  let(:json) { { "Content-Type" => "application/json" } }
+
+  def capture_http
+    http = nil
+    allow(Net::HTTP).to receive(:new).and_wrap_original do |original, *args|
+      http = original.call(*args)
+    end
+    yield
+    http
+  end
+
+  def bytes_escritos(request)
+    escrito = +""
+    sock = Object.new
+    sock.define_singleton_method(:write) do |data|
+      escrito << data.to_s
+      data.to_s.bytesize
+    end
+    sock.define_singleton_method(:continue_timeout) { nil }
+    request.exec(sock, "1.1", "/recurso")
+    escrito
+  end
+
+  it "é um Adapter" do
+    expect(adapter).to be_a(FocusNfe::HTTP::Adapter)
+  end
+
+  describe "#call" do
+    it "devolve uma Response com status e corpo parseado", :aggregate_failures do
+      stub_request(:get, url).to_return(status: 200, body: '{"ok":true}', headers: json)
+
+      response = adapter.call(:get, url)
+
+      expect(response).to be_a(FocusNfe::HTTP::Response)
+      expect(response).to have_attributes(status: 200, body: { "ok" => true })
+    end
+
+    %i[get post put delete].each do |verb|
+      it "suporta o verbo #{verb}" do
+        stub = stub_request(verb, url).to_return(status: 200, body: "")
+
+        adapter.call(verb, url)
+
+        expect(stub).to have_been_requested
+      end
+    end
+
+    it "envia o corpo no POST" do
+      stub = stub_request(:post, url).with(body: '{"a":1}').to_return(status: 201, body: "")
+
+      adapter.call(:post, url, headers: json, body: '{"a":1}')
+
+      expect(stub).to have_been_requested
+    end
+
+    it "envia o corpo no DELETE (cancelamento com justificativa)" do
+      stub = stub_request(:delete, url).with(body: '{"justificativa":"erro"}').to_return(status: 200, body: "")
+
+      adapter.call(:delete, url, body: '{"justificativa":"erro"}')
+
+      expect(stub).to have_been_requested
+    end
+
+    it "de fato grava corpo e Content-Length ao serializar um Net::HTTP::Delete", :aggregate_failures do
+      request = adapter.send(:build_request, :delete, URI(url), json, '{"tipo_evento":"x"}')
+      escrito = bytes_escritos(request)
+
+      expect(escrito).to include('{"tipo_evento":"x"}')
+      expect(escrito).to match(/content-length: 19/i)
+    end
+
+    it "respeita um Content-Type não-JSON no corpo da requisição" do
+      headers = { "Content-Type" => "application/xml" }
+      stub = stub_request(:post, url).with(body: "<x/>", headers: headers).to_return(status: 200, body: "")
+
+      adapter.call(:post, url, headers: headers, body: "<x/>")
+
+      expect(stub).to have_been_requested
+    end
+
+    it "repassa corpo de resposta não-JSON cru, sem estourar" do
+      headers = { "Content-Type" => "application/xml" }
+      stub_request(:get, url).to_return(status: 200, body: "<nfe>...</nfe>", headers: headers)
+
+      expect(adapter.call(:get, url).body).to eq("<nfe>...</nfe>")
+    end
+
+    it "aplica timeout e open_timeout ao cliente Net::HTTP", :aggregate_failures do
+      stub_request(:get, url).to_return(status: 200, body: "")
+
+      http = capture_http { described_class.new(timeout: 7, open_timeout: 3).call(:get, url) }
+
+      expect(http).to have_attributes(read_timeout: 7, open_timeout: 3)
+    end
+
+    it "não força timeouts quando não configurados, mantendo os defaults do Net::HTTP", :aggregate_failures do
+      stub_request(:get, url).to_return(status: 200, body: "")
+      padrao = Net::HTTP.new("x")
+
+      http = capture_http { described_class.new.call(:get, url) }
+
+      expect(http.read_timeout).to eq(padrao.read_timeout)
+      expect(http.open_timeout).to eq(padrao.open_timeout)
+    end
+
+    it "usa TLS quando a URL é https" do
+      stub_request(:get, url).to_return(status: 200, body: "")
+
+      http = capture_http { adapter.call(:get, url) }
+
+      expect(http.use_ssl?).to be(true)
+    end
+  end
+
+  describe "redirecionamento 302" do
+    let(:origin) { "https://api.exemplo.test/nfe/123.pdf" }
+    let(:target) { "https://arquivos.exemplo.test/assinado/123.pdf" }
+
+    def stub_redirect
+      stub_request(:get, origin).to_return(status: 302, headers: { "Location" => target })
+      stub_request(:get, target).to_return(status: 200, body: "PDF")
+    end
+
+    it "segue o Location com um novo GET e devolve a resposta final" do
+      stub_redirect
+
+      response = adapter.call(:get, origin, headers: { "Authorization" => "Basic abc" })
+
+      expect(response.status).to eq(200)
+    end
+
+    it "não reenvia o cabeçalho Authorization ao seguir o 302" do
+      stub_redirect
+
+      adapter.call(:get, origin, headers: { "Authorization" => "Basic abc" })
+
+      expect(a_request(:get, target).with { |req| req.headers["Authorization"].nil? }).to have_been_made
+    end
+
+    it "recusa redirecionamento para destino não-https", :aggregate_failures do
+      destino_http = "http://arquivos.exemplo.test/assinado/123.pdf"
+      stub_request(:get, origin).to_return(status: 302, headers: { "Location" => destino_http })
+      segundo = stub_request(:get, destino_http)
+
+      expect { adapter.call(:get, origin) }.to raise_error(FocusNfe::Errors::ConnectionError, /não-https/)
+      expect(segundo).not_to have_been_requested
+    end
+
+    it "não segue outros 3xx além de 302 (devolve a resposta crua)" do
+      stub_request(:get, url).to_return(status: 301, headers: { "Location" => "https://outro.test/x" })
+
+      expect(adapter.call(:get, url).status).to eq(301)
+    end
+
+    it "levanta ConnectionError ao exceder o teto de 5 redirecionamentos" do
+      stub_request(:get, url).to_return(status: 302, headers: { "Location" => url })
+
+      expect { adapter.call(:get, url) }.to raise_error(FocusNfe::Errors::ConnectionError)
+    end
+  end
+
+  describe "falhas de transporte" do
+    it "relança timeout como ConnectionError" do
+      stub_request(:get, url).to_timeout
+
+      expect { adapter.call(:get, url) }.to raise_error(FocusNfe::Errors::ConnectionError)
+    end
+
+    it "relança conexão recusada como ConnectionError" do
+      stub_request(:get, url).to_raise(Errno::ECONNREFUSED)
+
+      expect { adapter.call(:get, url) }.to raise_error(FocusNfe::Errors::ConnectionError)
+    end
+  end
+end

data/spec/focus_nfe/http/authentication_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::HTTP::Authentication do
+  it "produz o par { \"Authorization\" => \"Basic <base64>\" }", :aggregate_failures do
+    header = described_class.header("abc")
+
+    expect(header.keys).to eq(["Authorization"])
+    expect(header["Authorization"]).to start_with("Basic ")
+  end
+
+  it "decodifica de volta para 'token:' — token como usuário, senha vazia", :aggregate_failures do
+    value = described_class.header("meu-token").fetch("Authorization")
+    decoded = value.delete_prefix("Basic ").unpack1("m0")
+
+    expect(decoded).to eq("meu-token:")
+    expect(decoded).to end_with(":")
+  end
+
+  it "gera Base64 sem quebra de linha (equivalente exato a strict_encode64)" do
+    value = described_class.header("x").fetch("Authorization")
+
+    expect(value).to eq("Basic eDo=")
+  end
+end