focus_nfe 1.0.0

data/spec/focus_nfe/modelos/inutilizacao_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Modelos::Inutilizacao do
+  def response(body:, status: 200)
+    FocusNfe::HTTP::Response.new(
+      status: status,
+      headers: { "Content-Type" => "application/json" },
+      body: JSON.generate(body)
+    )
+  end
+
+  describe ".from_response" do
+    it "mapeia status, status_sefaz e mensagem_sefaz", :aggregate_failures do
+      corpo = { "status" => "autorizado", "status_sefaz" => "102", "mensagem_sefaz" => "ok" }
+      inut = described_class.from_response(response(body: corpo))
+
+      expect(inut).to have_attributes(status: "autorizado", status_sefaz: "102", mensagem_sefaz: "ok")
+    end
+
+    it "mapeia serie, numero_inicial e numero_final", :aggregate_failures do
+      corpo = { "serie" => "1", "numero_inicial" => "10", "numero_final" => "20" }
+      inut = described_class.from_response(response(body: corpo))
+
+      expect(inut).to have_attributes(serie: "1", numero_inicial: "10", numero_final: "20")
+    end
+
+    it "expõe protocolo a partir de protocolo_sefaz" do
+      inut = described_class.from_response(response(body: { "protocolo_sefaz" => "135200" }))
+
+      expect(inut.protocolo).to eq("135200")
+    end
+
+    it "guarda a resposta original para inspeção" do
+      resp = response(body: { "status" => "autorizado" })
+
+      expect(described_class.from_response(resp).response).to be(resp)
+    end
+
+    it "usa dados vazios quando o corpo não é um Hash", :aggregate_failures do
+      inut = described_class.from_response(response(body: ["x"]))
+
+      expect(inut.dados).to eq({})
+      expect(inut.status).to be_nil
+    end
+  end
+
+  describe ".from_item" do
+    it "constrói a partir de um Hash cru, sem resposta", :aggregate_failures do
+      inut = described_class.from_item("status" => "autorizado", "protocolo_sefaz" => "1")
+
+      expect(inut.response).to be_nil
+      expect(inut).to have_attributes(status: "autorizado", protocolo: "1")
+    end
+
+    it "usa dados vazios quando o item não é um Hash" do
+      expect(described_class.from_item(nil).dados).to eq({})
+    end
+  end
+
+  describe "#autorizado?" do
+    def inut(status)
+      described_class.from_item("status" => status)
+    end
+
+    it "é verdadeiro só para 'autorizado'", :aggregate_failures do
+      expect(inut("autorizado")).to be_autorizado
+      expect(inut("erro_autorizacao")).not_to be_autorizado
+    end
+  end
+
+  describe "acesso bruto" do
+    subject(:inut) do
+      described_class.from_item("status" => "autorizado", "cnpj" => "123", "modelo" => "55", "caminho_xml" => "/x.xml")
+    end
+
+    it "expõe o Hash cru via #dados" do
+      expect(inut.dados).to include("cnpj" => "123", "modelo" => "55", "caminho_xml" => "/x.xml")
+    end
+
+    it "delega #[] ao Hash para campos não mapeados", :aggregate_failures do
+      expect(inut["cnpj"]).to eq("123")
+      expect(inut["caminho_xml"]).to eq("/x.xml")
+    end
+  end
+
+  describe "imutabilidade" do
+    it "congela a instância" do
+      expect(described_class.from_item("status" => "autorizado")).to be_frozen
+    end
+  end
+end

data/spec/focus_nfe/modelos/pagina_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Modelos::Pagina do
+  def response(body:, headers: {})
+    FocusNfe::HTTP::Response.new(
+      status: 200,
+      headers: { "Content-Type" => "application/json" }.merge(headers),
+      body: JSON.generate(body)
+    )
+  end
+
+  describe ".from_response" do
+    it "expõe os itens do corpo (Array)" do
+      pagina = described_class.from_response(response(body: [{ "a" => 1 }, { "a" => 2 }]))
+
+      expect(pagina.itens).to eq([{ "a" => 1 }, { "a" => 2 }])
+    end
+
+    it "usa lista vazia quando o corpo não é um Array" do
+      pagina = described_class.from_response(response(body: { "erro" => "x" }))
+
+      expect(pagina.itens).to eq([])
+    end
+
+    it "lê total e versao_maxima dos headers de paginação", :aggregate_failures do
+      pagina = described_class.from_response(
+        response(body: [], headers: { "X-Total-Count" => "42", "X-Max-Version" => "7" })
+      )
+
+      expect(pagina.total).to eq(42)
+      expect(pagina.versao_maxima).to eq(7)
+    end
+
+    it "deixa total e versao_maxima nil quando os headers estão ausentes", :aggregate_failures do
+      pagina = described_class.from_response(response(body: []))
+
+      expect(pagina.total).to be_nil
+      expect(pagina.versao_maxima).to be_nil
+    end
+
+    it "guarda a resposta original" do
+      resp = response(body: [])
+
+      expect(described_class.from_response(resp).response).to be(resp)
+    end
+  end
+
+  describe "enumerável" do
+    subject(:pagina) { described_class.from_response(response(body: [1, 2, 3])) }
+
+    it "itera com cada", :aggregate_failures do
+      coletados = []
+      retorno = pagina.cada { |item| coletados << item }
+
+      expect(coletados).to eq([1, 2, 3])
+      expect(retorno).to be(pagina)
+    end
+
+    it "compõe os helpers de Enumerable (map/select)", :aggregate_failures do
+      expect(pagina.map { |i| i * 2 }).to eq([2, 4, 6])
+      expect(pagina.select(&:even?)).to eq([2])
+    end
+
+    it "devolve um Enumerator quando chamado sem bloco", :aggregate_failures do
+      enum = pagina.cada
+
+      expect(enum).to be_a(Enumerator)
+      expect(enum.to_a).to eq([1, 2, 3])
+    end
+  end
+
+  describe "imutabilidade" do
+    it "congela a instância" do
+      expect(described_class.from_response(response(body: []))).to be_frozen
+    end
+  end
+end

data/spec/focus_nfe/recursos/backups_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Backups do
+  include_context "com recurso conectado"
+
+  let(:cnpj) { "12345678000123" }
+
+  it "usa o caminho_base 'backups'" do
+    expect(recurso.caminho_base).to eq("backups")
+  end
+
+  describe "#consultar" do
+    it "faz GET em /v2/backups/{cnpj}.json e devolve o corpo cru" do
+      stub_get("backups/#{cnpj}.json", body: '[{"mes":"202605"}]')
+
+      expect(recurso.consultar(cnpj)).to eq([{ "mes" => "202605" }])
+    end
+
+    it "escapa o cnpj, sem injetar query nem traversal no path" do
+      stub_request(:get, /focusnfe/).to_return(status: 200, body: "[]", headers: json)
+
+      recurso.consultar("../empresas/1?x=y")
+
+      enviado = a_request(:get, /focusnfe/)
+                .with { |req| req.uri.query.nil? && req.uri.path.include?("..%2Fempresas%2F1%3Fx") }
+      expect(enviado).to have_been_made
+    end
+  end
+end

data/spec/focus_nfe/recursos/base_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Base do
+  let(:connection) { instance_double(FocusNfe::HTTP::Connection) }
+
+  describe "DSL caminho_base" do
+    it "expõe o caminho declarado na classe via método de instância" do
+      classe = Class.new(described_class) { caminho_base "nfe" }
+
+      expect(classe.new(connection).caminho_base).to eq("nfe")
+    end
+
+    it "é por classe — subclasses não vazam entre si", :aggregate_failures do
+      uma = Class.new(described_class) { caminho_base "nfe" }
+      outra = Class.new(described_class) { caminho_base "nfce" }
+
+      expect(uma.new(connection).caminho_base).to eq("nfe")
+      expect(outra.new(connection).caminho_base).to eq("nfce")
+    end
+  end
+
+  describe "#validar_referencia!" do
+    subject(:recurso) { Class.new(described_class) { caminho_base "nfe" }.new(connection) }
+
+    it "aceita refs alfanuméricas com hífen/underscore", :aggregate_failures do
+      expect { recurso.send(:validar_referencia!, "pedido-42") }.not_to raise_error
+      expect { recurso.send(:validar_referencia!, "venda_1001") }.not_to raise_error
+    end
+
+    it "rejeita refs com espaço ou vazias", :aggregate_failures do
+      expect { recurso.send(:validar_referencia!, "a b") }.to raise_error(ArgumentError)
+      expect { recurso.send(:validar_referencia!, "") }.to raise_error(ArgumentError)
+      expect { recurso.send(:validar_referencia!, nil) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#caminho_referencia" do
+    subject(:recurso) { Class.new(described_class) { caminho_base "nfe" }.new(connection) }
+
+    it "combina o caminho base com a ref" do
+      expect(recurso.send(:caminho_referencia, "pedido-42")).to eq("nfe/pedido-42")
+    end
+
+    it "preserva identificadores comuns (dígitos, hífen, underscore, ponto)", :aggregate_failures do
+      expect(recurso.send(:caminho_referencia, "12345678000190")).to eq("nfe/12345678000190")
+      expect(recurso.send(:caminho_referencia, "venda_1001")).to eq("nfe/venda_1001")
+      expect(recurso.send(:caminho_referencia, "35200114200166000187.55")).to eq("nfe/35200114200166000187.55")
+    end
+
+    it "escapa caracteres que sequestrariam o path ou injetariam query", :aggregate_failures do
+      expect(recurso.send(:caminho_referencia, "a/b")).to eq("nfe/a%2Fb")
+      expect(recurso.send(:caminho_referencia, "x?y")).to eq("nfe/x%3Fy")
+      expect(recurso.send(:caminho_referencia, "../../empresas")).to eq("nfe/..%2F..%2Fempresas")
+    end
+  end
+end

data/spec/focus_nfe/recursos/ceps_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Ceps do
+  it_behaves_like "um recurso listável", "ceps"
+  it_behaves_like "um recurso localizável", "ceps"
+
+  include_context "com recurso conectado"
+
+  describe "#buscar" do
+    it "é um apelido de #listar e devolve uma Pagina" do
+      stub_get("ceps", query: { uf: "AM", logradouro: "Eduardo" }, body: "[]")
+
+      expect(recurso.buscar(uf: "AM", logradouro: "Eduardo")).to be_a(FocusNfe::Modelos::Pagina)
+    end
+  end
+end

data/spec/focus_nfe/recursos/cfops_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Cfops do
+  it_behaves_like "um recurso listável", "cfops"
+  it_behaves_like "um recurso localizável", "cfops"
+
+  include_context "com recurso conectado"
+
+  describe "#buscar" do
+    it "é um apelido de #listar" do
+      stub_get("cfops", query: { descricao: "venda" }, body: "[]")
+
+      expect(recurso.buscar(descricao: "venda")).to be_a(FocusNfe::Modelos::Pagina)
+    end
+  end
+end

data/spec/focus_nfe/recursos/cnaes_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Cnaes do
+  it_behaves_like "um recurso listável", "codigos_cnae"
+  it_behaves_like "um recurso localizável", "codigos_cnae"
+
+  include_context "com recurso conectado"
+
+  it "usa o caminho_base 'codigos_cnae'" do
+    expect(recurso.caminho_base).to eq("codigos_cnae")
+  end
+
+  describe "#buscar" do
+    it "é um apelido de #listar" do
+      stub_get("codigos_cnae", query: { descricao: "software" }, body: "[]")
+
+      expect(recurso.buscar(descricao: "software")).to be_a(FocusNfe::Modelos::Pagina)
+    end
+  end
+end

data/spec/focus_nfe/recursos/cnpjs_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Cnpjs do
+  it_behaves_like "um recurso localizável", "cnpjs"
+
+  include_context "com recurso conectado"
+
+  it "não expõe listagem" do
+    expect(recurso).not_to respond_to(:listar)
+  end
+end

data/spec/focus_nfe/recursos/concerns/emitivel_validacao_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Concerns::Emitivel do
+  let(:client) { FocusNfe::Client.new(token_empresa: "tok", environment: :homologacao) }
+  let(:nfe) { FocusNfe::Recursos::Nfe.new(client.connection) }
+  let(:nfce) { FocusNfe::Recursos::Nfce.new(client.connection) }
+  let(:cte) { FocusNfe::Recursos::Cte.new(client.connection) }
+  let(:cte_os) { FocusNfe::Recursos::CteOs.new(client.connection) }
+  let(:mdfe) { FocusNfe::Recursos::Mdfe.new(client.connection) }
+
+  def json = { "Content-Type" => "application/json" }
+  def processando = '{"status":"processando_autorizacao"}'
+  def homologacao = "https://homologacao.focusnfe.com.br"
+
+  def stub_emissao(path, status: 202)
+    stub_request(:post, "#{homologacao}/v2/#{path}").to_return(status: status, body: processando, headers: json)
+  end
+
+  describe "#emitir com validar: true" do
+    context "quando o documento tem schema empacotado" do
+      it "levanta ErroDeValidacao sem fazer requisição quando faltam obrigatórios", :aggregate_failures do
+        stub = stub_emissao("nfe?ref=pedido-1")
+
+        expect { nfe.emitir(ref: "pedido-1", dados: {}, validar: true) }
+          .to raise_error(FocusNfe::Esquemas::ErroDeValidacao)
+        expect(stub).not_to have_been_requested
+      end
+
+      it "emite normalmente quando os dados são válidos" do
+        esquema = FocusNfe::Esquemas::Esquema.new([{ "name" => "natureza_operacao", "type" => "String[1-60]" }])
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).with("nfe").and_return(esquema)
+        stub_emissao("nfe?ref=pedido-1")
+
+        nfe.emitir(ref: "pedido-1", dados: { "natureza_operacao" => "Venda" }, validar: true)
+
+        expect(a_request(:post, "#{homologacao}/v2/nfe?ref=pedido-1")).to have_been_made
+      end
+
+      it "não vaza o parâmetro validar para a query string" do
+        esquema = FocusNfe::Esquemas::Esquema.new([])
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).with("nfe").and_return(esquema)
+        stub_emissao("nfe?ref=pedido-1")
+
+        nfe.emitir(ref: "pedido-1", dados: {}, validar: true)
+
+        expect(a_request(:post, "#{homologacao}/v2/nfe").with(query: { "ref" => "pedido-1" })).to have_been_made
+      end
+    end
+
+    context "quando o documento tem modal condicional (CTe)" do
+      def stub_esquema_base_vazio
+        vazio = FocusNfe::Esquemas::Esquema.new([])
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).and_call_original
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).with("cte").and_return(vazio)
+      end
+
+      it "valida o sub-esquema do modal e bloqueia a emissão" do
+        stub_esquema_base_vazio
+
+        expect do
+          cte.emitir(ref: "cte-1", dados: { "modal" => "01", "modal_rodoviario" => { "rntrc" => "1" } }, validar: true)
+        end.to raise_error(FocusNfe::Esquemas::ErroDeValidacao, /modal_rodoviario/)
+      end
+
+      it "emite quando base e modal são válidos" do
+        stub_esquema_base_vazio
+        stub_emissao("cte?ref=cte-1")
+
+        cte.emitir(ref: "cte-1", dados: { "modal" => "01", "modal_rodoviario" => { "rntrc" => "12345678" } },
+                   validar: true)
+
+        expect(a_request(:post, "#{homologacao}/v2/cte?ref=cte-1")).to have_been_made
+      end
+    end
+
+    context "quando o CTe OS tem modal condicional" do
+      def stub_cte_os_base_vazio
+        vazio = FocusNfe::Esquemas::Esquema.new([])
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).and_call_original
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).with("cte_os").and_return(vazio)
+      end
+
+      it "valida o sub-esquema do modal e bloqueia a emissão" do
+        stub_cte_os_base_vazio
+
+        expect do
+          cte_os.emitir(ref: "cte-os-1", dados: { "modal" => "01", "modal_rodoviario" => { "placa" => "ABC1234" } },
+                        validar: true)
+        end.to raise_error(FocusNfe::Esquemas::ErroDeValidacao, /modal_rodoviario\.placa/)
+      end
+
+      it "emite quando base e modal são válidos" do
+        stub_cte_os_base_vazio
+        stub_emissao("cte_os?ref=cte-os-1")
+
+        cte_os.emitir(ref: "cte-os-1", dados: { "modal" => "01", "modal_rodoviario" => { "placa" => "AB12" } },
+                      validar: true)
+
+        expect(a_request(:post, "#{homologacao}/v2/cte_os?ref=cte-os-1")).to have_been_made
+      end
+
+      it "não valida modal quando o campo modal não é 01" do
+        stub_cte_os_base_vazio
+        stub_emissao("cte_os?ref=cte-os-1")
+
+        cte_os.emitir(ref: "cte-os-1", dados: { "modal" => "02", "modal_rodoviario" => { "placa" => "ABC1234" } },
+                      validar: true)
+
+        expect(a_request(:post, "#{homologacao}/v2/cte_os?ref=cte-os-1")).to have_been_made
+      end
+    end
+
+    context "quando a MDFe deduz o modal pela chave presente" do
+      def stub_mdfe_base_vazia
+        vazio = FocusNfe::Esquemas::Esquema.new([])
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).and_call_original
+        allow(FocusNfe::Esquemas::Esquema).to receive(:carregar).with("mdfe").and_return(vazio)
+      end
+
+      it "valida o sub-esquema do modal presente e bloqueia a emissão" do
+        stub_mdfe_base_vazia
+
+        expect do
+          mdfe.emitir(ref: "mdfe-1", dados: { "modal_rodoviario" => {} }, validar: true)
+        end.to raise_error(FocusNfe::Esquemas::ErroDeValidacao, /modal_rodoviario/)
+      end
+
+      it "emite quando nenhuma chave de modal está presente" do
+        stub_mdfe_base_vazia
+        stub_emissao("mdfe?ref=mdfe-1")
+
+        mdfe.emitir(ref: "mdfe-1", dados: { "cnpj_emitente" => "12345678000123" }, validar: true)
+
+        expect(a_request(:post, "#{homologacao}/v2/mdfe?ref=mdfe-1")).to have_been_made
+      end
+    end
+
+    context "quando o documento não tem schema (pula silenciosamente)" do
+      it "emite sem validar" do
+        stub_emissao("nfce?ref=venda-1")
+
+        nfce.emitir(ref: "venda-1", dados: {}, validar: true)
+
+        expect(a_request(:post, "#{homologacao}/v2/nfce?ref=venda-1")).to have_been_made
+      end
+    end
+  end
+
+  describe "#emitir sem validar (padrão)" do
+    it "não valida mesmo com dados vazios" do
+      stub_emissao("nfe?ref=pedido-1")
+
+      nfe.emitir(ref: "pedido-1", dados: {})
+
+      expect(a_request(:post, "#{homologacao}/v2/nfe?ref=pedido-1")).to have_been_made
+    end
+  end
+end

data/spec/focus_nfe/recursos/cte_os_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::CteOs do
+  it_behaves_like "um recurso emitível", "cte_os"
+  it_behaves_like "um recurso consultável", "cte_os"
+  it_behaves_like "um recurso cancelável", "cte_os"
+  it_behaves_like "um recurso corrigível por campo", "cte_os"
+  it_behaves_like "um recurso notificável", "cte_os"
+end

data/spec/focus_nfe/recursos/cte_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Cte do
+  it_behaves_like "um recurso emitível", "cte"
+  it_behaves_like "um recurso consultável", "cte"
+  it_behaves_like "um recurso cancelável", "cte"
+  it_behaves_like "um recurso corrigível por campo", "cte"
+  it_behaves_like "um recurso notificável", "cte"
+end

data/spec/focus_nfe/recursos/ctes_recebidas_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::CtesRecebidas do
+  include_context "com recurso conectado"
+
+  let(:chave) { "35200114200166000187570010000000201234567890" }
+
+  it_behaves_like "um recurso listável", "ctes_recebidas"
+  it_behaves_like "um recurso baixável", "ctes_recebidas"
+  it_behaves_like "um recurso notificável", "ctes_recebidas"
+
+  describe "#consultar" do
+    it "faz GET em /v2/ctes_recebidas/{chave} e devolve o corpo cru" do
+      stub_get("ctes_recebidas/#{chave}", body: '{"situacao":"autorizado"}')
+
+      expect(recurso.consultar(chave)).to eq("situacao" => "autorizado")
+    end
+  end
+
+  describe "#desacordo" do
+    it "faz POST em /{chave}/desacordo com as observações" do
+      corpo = '{"observacoes":"Mercadoria não recebida conforme."}'
+      stub = stub_envio(:post, "ctes_recebidas/#{chave}/desacordo", body: corpo)
+
+      recurso.desacordo(chave, observacoes: "Mercadoria não recebida conforme.")
+
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe "#consultar_desacordo" do
+    it "faz GET em /{chave}/desacordo e devolve o corpo cru" do
+      stub_get("ctes_recebidas/#{chave}/desacordo", body: '{"status":"registrado"}')
+
+      expect(recurso.consultar_desacordo(chave)).to eq("status" => "registrado")
+    end
+  end
+
+  describe "#download_xml_cancelamento" do
+    it "faz GET em /{chave}/cancelamento.xml e devolve o XML cru" do
+      stub_get("ctes_recebidas/#{chave}/cancelamento.xml",
+               body: "<procEventoCTe/>", headers: { "Content-Type" => "application/xml" })
+
+      expect(recurso.download_xml_cancelamento(chave)).to eq("<procEventoCTe/>")
+    end
+  end
+
+  describe "#download_xml_carta_correcao" do
+    it "faz GET em /{chave}/carta_correcao.xml e devolve o XML cru" do
+      stub_get("ctes_recebidas/#{chave}/carta_correcao.xml",
+               body: "<procEventoCTe/>", headers: { "Content-Type" => "application/xml" })
+
+      expect(recurso.download_xml_carta_correcao(chave)).to eq("<procEventoCTe/>")
+    end
+  end
+end

data/spec/focus_nfe/recursos/dce_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Dce do
+  it_behaves_like "um recurso emitível", "dce"
+  it_behaves_like "um recurso consultável", "dce"
+  it_behaves_like "um recurso cancelável", "dce"
+  it_behaves_like "um recurso notificável", "dce"
+end

data/spec/focus_nfe/recursos/emails_bloqueados_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::EmailsBloqueados do
+  include_context "com recurso conectado"
+
+  let(:email) { "bloqueado@exemplo.com" }
+
+  it "usa o caminho_base 'blocked_emails'" do
+    expect(recurso.caminho_base).to eq("blocked_emails")
+  end
+
+  describe "#consultar" do
+    it "faz GET em /v2/blocked_emails/{email} e devolve o corpo cru" do
+      stub_get("blocked_emails/#{email}", body: '{"block_type":"bounce"}')
+
+      expect(recurso.consultar(email)).to eq("block_type" => "bounce")
+    end
+  end
+
+  describe "#desbloquear" do
+    it "faz DELETE em /v2/blocked_emails/{email}" do
+      stub = stub_envio(:delete, "blocked_emails/#{email}")
+
+      recurso.desbloquear(email)
+
+      expect(stub).to have_been_requested
+    end
+  end
+end

data/spec/focus_nfe/recursos/empresas_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Recursos::Empresas do
+  include_context "com recurso conectado"
+
+  let(:dados) { { "nome" => "Loja", "cnpj" => "12345678000123" } }
+
+  it_behaves_like "um recurso listável", "empresas"
+  it_behaves_like "um recurso localizável", "empresas"
+  it_behaves_like "um recurso removível", "empresas"
+
+  describe "#criar" do
+    it "faz POST em /v2/empresas com os dados e devolve o corpo cru" do
+      stub_envio(:post, "empresas", body: JSON.generate(dados), resposta: '{"id":1}')
+
+      expect(recurso.criar(dados: dados)).to eq("id" => 1)
+    end
+
+    it "inclui dry_run=1 na query quando dry_run: true" do
+      stub = stub_envio(:post, "empresas", query: { dry_run: 1 }, body: JSON.generate(dados))
+
+      recurso.criar(dados: dados, dry_run: true)
+
+      expect(stub).to have_been_requested
+    end
+
+    it "não envia dry_run por padrão" do
+      stub = stub_envio(:post, "empresas", body: JSON.generate(dados))
+
+      recurso.criar(dados: dados)
+
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe "#atualizar" do
+    it "faz PUT em /v2/empresas/{id} com os dados" do
+      stub = stub_envio(:put, "empresas/7", body: JSON.generate(dados))
+
+      recurso.atualizar("7", dados: dados)
+
+      expect(stub).to have_been_requested
+    end
+  end
+end