focus_nfe 1.0.0

data/spec/focus_nfe/webhook_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Webhook do
+  describe ".parse" do
+    it "parseia o corpo cru (String) em um Documento", :aggregate_failures do
+      doc = described_class.parse('{"status":"autorizado","ref":"pedido-1"}')
+
+      expect(doc).to be_a(FocusNfe::Modelos::Documento)
+      expect(doc).to be_autorizado
+      expect(doc.ref).to eq("pedido-1")
+    end
+
+    it "aceita um Hash já parseado" do
+      doc = described_class.parse({ "status" => "cancelado", "ref" => "pedido-2" })
+
+      expect(doc).to be_cancelado
+    end
+
+    it "injeta a ref informada quando o corpo não a traz" do
+      doc = described_class.parse('{"status":"autorizado"}', ref: "pedido-3")
+
+      expect(doc.ref).to eq("pedido-3")
+    end
+
+    it "não guarda resposta HTTP" do
+      expect(described_class.parse('{"status":"autorizado"}').response).to be_nil
+    end
+
+    it "levanta WebhookError quando o corpo não é JSON válido" do
+      expect { described_class.parse("nao é json") }
+        .to raise_error(FocusNfe::Errors::WebhookError, /não é JSON válido/)
+    end
+  end
+
+  describe ".autenticado?" do
+    let(:headers) { { "X-Focus-Authorization" => "s3cr3t" } }
+
+    def autenticado?(headers:, authorization: "s3cr3t", authorization_header: "X-Focus-Authorization")
+      described_class.autenticado?(headers: headers, authorization: authorization,
+                                   authorization_header: authorization_header)
+    end
+
+    it "é verdadeiro quando o header recebido bate com o authorization" do
+      expect(autenticado?(headers: headers)).to be(true)
+    end
+
+    it "é falso quando o valor do header diverge" do
+      expect(autenticado?(headers: { "X-Focus-Authorization" => "errado" })).to be(false)
+    end
+
+    it "é falso quando o header está ausente" do
+      expect(autenticado?(headers: {})).to be(false)
+    end
+
+    it "faz o lookup do header de forma case-insensitive" do
+      expect(autenticado?(headers: { "x-focus-authorization" => "s3cr3t" })).to be(true)
+    end
+
+    it "encontra o header via #[] em objetos sem #each (ex.: request.headers)" do
+      rails_like = Object.new
+      def rails_like.[](nome) = nome == "X-Focus-Authorization" ? "s3cr3t" : nil
+
+      expect(autenticado?(headers: rails_like)).to be(true)
+    end
+  end
+end

data/spec/focus_nfe_global_configuration_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe do
+  describe ".configure" do
+    it "cede uma Configuration para o bloco" do
+      cedida = nil
+      described_class.configure { |config| cedida = config }
+
+      expect(cedida).to be_a(FocusNfe::Configuration)
+    end
+
+    it "memoiza a configuração ajustada no bloco", :aggregate_failures do
+      described_class.configure do |config|
+        config.token_empresa = "tok-global"
+        config.environment = :producao
+      end
+
+      expect(described_class.configuration).to have_attributes(token_empresa: "tok-global", environment: :producao)
+    end
+
+    it "devolve a configuração global mesmo quando chamado sem bloco" do
+      expect(described_class.configure).to be(described_class.configuration)
+    end
+  end
+
+  describe ".configuration" do
+    it "cria uma Configuration default quando ainda não há" do
+      expect(described_class.configuration).to be_a(FocusNfe::Configuration)
+    end
+
+    it "devolve sempre a mesma instância global" do
+      primeira = described_class.configuration
+
+      expect(described_class.configuration).to be(primeira)
+    end
+  end
+
+  describe ".client" do
+    it "constrói um Client a partir da config global" do
+      described_class.configure { |config| config.token_empresa = "tok-global" }
+
+      expect(described_class.client).to be_a(FocusNfe::Client)
+    end
+
+    it "usa a config global no cliente" do
+      described_class.configure { |config| config.token_empresa = "tok-global" }
+
+      expect(described_class.client.configuration).to be(described_class.configuration)
+    end
+
+    it "levanta ConfigurationError quando a config global ainda não tem nenhum token" do
+      expect { described_class.client }.to raise_error(FocusNfe::Errors::ConfigurationError)
+    end
+  end
+
+  describe ".reset_configuration!" do
+    it "limpa o estado global, gerando uma nova instância depois" do
+      anterior = described_class.configuration
+      described_class.reset_configuration!
+
+      expect(described_class.configuration).not_to be(anterior)
+    end
+  end
+
+  describe "isolamento entre exemplos" do
+    it "não vê o token de um exemplo anterior" do
+      expect(described_class.configuration.token_empresa).to be_nil
+    end
+  end
+end

data/spec/focus_nfe_require_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "open3"
+
+RSpec.describe FocusNfe do
+  describe "require \"focus_nfe\" em processo limpo" do
+    def constantes
+      %w[
+        FocusNfe::Client
+        FocusNfe::Configuration
+        FocusNfe::HTTP::Connection
+        FocusNfe::Error
+        FocusNfe::Errors::HttpError
+        FocusNfe::Errors::ConfigurationError
+        FocusNfe::Errors::ConnectionError
+      ]
+    end
+
+    def executar_ruby(corpo)
+      lib = File.expand_path("../lib", __dir__)
+      env = ENV.to_h
+      %w[RUBYOPT BUNDLE_GEMFILE BUNDLER_SETUP].each { |chave| env.delete(chave) }
+
+      Open3.capture2e(env, RbConfig.ruby, "--disable-gems", "-I#{lib}", "-e", corpo)
+    end
+
+    it "carrega sem levantar", :aggregate_failures do
+      saida, status = executar_ruby('require "focus_nfe"; print "ok"')
+
+      expect(status).to be_success
+      expect(saida).to eq("ok")
+    end
+
+    it "expõe Client, Configuration, HTTP::Connection, Error e Errors::*" do
+      checagem = constantes.map { |const| %(defined?(#{const}) || abort("faltou #{const}")) }.join("; ")
+      saida, status = executar_ruby(%(require "focus_nfe"; #{checagem}; print "ok"))
+
+      expect(status).to be_success, saida
+    end
+
+    it "não puxa a lib base64 transitivamente" do
+      saida, = executar_ruby('require "focus_nfe"; print $LOADED_FEATURES.grep(/base64/).inspect')
+
+      expect(saida).to eq("[]")
+    end
+
+    it "monta o Authorization sem depender de base64", :aggregate_failures do
+      corpo = 'require "focus_nfe"; print FocusNfe::HTTP::Authentication.header("x").fetch("Authorization")'
+      saida, status = executar_ruby(corpo)
+
+      expect(status).to be_success, saida
+      expect(saida).to eq("Basic eDo=")
+    end
+
+    def carregados(corpo)
+      executar_ruby(%(require "focus_nfe"; #{corpo}; print $LOADED_FEATURES.grep(%r{focus_nfe/}).join("\\n"))).first
+    end
+
+    it "não carrega nenhum recurso de documento só no require" do
+      expect(carregados("")).not_to match(%r{focus_nfe/recursos/})
+    end
+
+    it "não carrega os modelos só no require" do
+      expect(carregados("")).not_to match(%r{focus_nfe/modelos/})
+    end
+
+    it "não carrega a máquina de validação de esquemas só no require" do
+      expect(carregados("")).not_to match(%r{focus_nfe/esquemas/(esquema|campo|validador)\.rb})
+    end
+
+    it "carrega só o recurso referenciado sob demanda, e suas dependências", :aggregate_failures do
+      saida = carregados("FocusNfe::Recursos::NfseNacional")
+
+      expect(saida).to match(%r{focus_nfe/recursos/nfse_nacional\.rb})
+      expect(saida).to match(%r{focus_nfe/recursos/base\.rb})
+      expect(saida).to match(%r{focus_nfe/recursos/concerns/emitivel\.rb})
+    end
+
+    it "não puxa recursos irmãos nem os modelos ao referenciar um recurso", :aggregate_failures do
+      saida = carregados("FocusNfe::Recursos::NfseNacional")
+
+      expect(saida).not_to match(%r{focus_nfe/recursos/cte\.rb})
+      expect(saida).not_to match(%r{focus_nfe/recursos/nfe\.rb})
+      expect(saida).not_to match(%r{focus_nfe/modelos/documento\.rb})
+    end
+  end
+end

data/spec/focus_nfe_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe do
+  it "possui um número de versão" do
+    expect(FocusNfe::VERSION).not_to be_nil
+  end
+
+  it "define uma classe de erro base" do
+    expect(FocusNfe::Error.new).to be_a(StandardError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "simplecov"
+
+SimpleCov.start do
+  enable_coverage :branch
+
+  add_filter "/spec/"
+  add_filter "/tools/"
+  add_filter "lib/focus_nfe/version.rb"
+
+  add_group "Recursos", "lib/focus_nfe/recursos"
+  add_group "Esquemas", "lib/focus_nfe/esquemas"
+  add_group "HTTP", "lib/focus_nfe/http"
+  add_group "Modelos", "lib/focus_nfe/modelos"
+end
+
+require "focus_nfe"
+
+require "webmock/rspec"
+require "vcr"
+
+# Nenhuma requisição HTTP real é permitida durante os testes (ver CLAUDE.md).
+WebMock.disable_net_connect!(allow_localhost: false)
+
+VCR.configure do |config|
+  config.cassette_library_dir = "spec/cassettes"
+  config.hook_into :webmock
+  config.configure_rspec_metadata!
+  config.default_cassette_options = { record: :none }
+end
+
+Dir[File.join(__dir__, "support", "**", "*.rb")].each { |file| require file }
+
+RSpec.configure do |config|
+  # Habilita a sintaxe `expect` apenas.
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # Permite focar exemplos com `fit`/`fdescribe` e roda tudo se nenhum estiver focado.
+  config.filter_run_when_matching :focus
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  config.default_formatter = "doc" if config.files_to_run.one?
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.before { FocusNfe.reset_configuration! }
+end