focus_nfe 1.0.0

data/spec/focus_nfe/configuration_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Configuration do
+  describe "valores padrão" do
+    it "usa homologação, timeouts numéricos, tokens nil e cabeçalhos vazios" do
+      expect(described_class.new).to have_attributes(
+        token_empresa: nil, token_conta: nil, environment: :homologacao, timeout: 30,
+        open_timeout: 10, logger: nil, http_adapter: nil, headers: {}
+      )
+    end
+  end
+
+  describe "atributos" do
+    it "aceita todos os atributos via argumentos nomeados" do
+      logger = Object.new
+      config = described_class.new(token_empresa: "te", token_conta: "tc", environment: :producao,
+                                   timeout: 5, open_timeout: 2, logger: logger, headers: { "X" => "1" })
+
+      expect(config).to have_attributes(token_empresa: "te", token_conta: "tc", environment: :producao,
+                                        timeout: 5, open_timeout: 2, logger: logger, headers: { "X" => "1" })
+    end
+
+    it "permite escrever os tokens após a construção", :aggregate_failures do
+      config = described_class.new
+      config.token_empresa = "te-123"
+      config.token_conta = "tc-123"
+
+      expect(config).to have_attributes(token_empresa: "te-123", token_conta: "tc-123")
+    end
+
+    it "apenas armazena a referência ao logger nesta fase" do
+      logger = Object.new
+
+      expect(described_class.new(logger: logger).logger).to be(logger)
+    end
+  end
+
+  describe "#token_de" do
+    it "resolve o token de cada escopo", :aggregate_failures do
+      config = described_class.new(token_empresa: "te", token_conta: "tc")
+
+      expect(config.token_de(:empresa)).to eq("te")
+      expect(config.token_de(:conta)).to eq("tc")
+    end
+  end
+
+  describe "#base_url" do
+    it "resolve a URL de produção" do
+      expect(described_class.new(environment: :producao).base_url).to eq("https://api.focusnfe.com.br")
+    end
+
+    it "resolve a URL de homologação" do
+      expect(described_class.new(environment: :homologacao).base_url).to eq("https://homologacao.focusnfe.com.br")
+    end
+
+    it "levanta ConfigurationError para ambiente desconhecido" do
+      expect { described_class.new(environment: :sandbox).base_url }.to raise_error(FocusNfe::Errors::ConfigurationError)
+    end
+  end
+
+  describe "#validate!" do
+    it "levanta ConfigurationError quando nenhum token está presente" do
+      config = described_class.new(token_empresa: nil, token_conta: nil, environment: :producao)
+
+      expect { config.validate! }.to raise_error(FocusNfe::Errors::ConfigurationError, /token/)
+    end
+
+    it "levanta ConfigurationError quando os tokens são vazios ou só espaços" do
+      config = described_class.new(token_empresa: "   ", token_conta: "", environment: :producao)
+
+      expect { config.validate! }.to raise_error(FocusNfe::Errors::ConfigurationError, /token/)
+    end
+
+    it "aceita apenas o token de empresa" do
+      config = described_class.new(token_empresa: "te", environment: :producao)
+
+      expect(config.validate!).to be(config)
+    end
+
+    it "aceita apenas o token de conta" do
+      config = described_class.new(token_conta: "tc", environment: :producao)
+
+      expect(config.validate!).to be(config)
+    end
+
+    it "levanta ConfigurationError quando o ambiente é desconhecido" do
+      config = described_class.new(token_empresa: "te", environment: :sandbox)
+
+      expect { config.validate! }.to raise_error(FocusNfe::Errors::ConfigurationError, /ambiente/)
+    end
+  end
+
+  describe "#validate_token!" do
+    it "devolve a própria configuração quando o token do escopo está presente" do
+      config = described_class.new(token_empresa: "te", token_conta: "tc")
+
+      expect(config.validate_token!(:empresa)).to be(config)
+    end
+
+    it "levanta ConfigurationError citando token_empresa quando o escopo :empresa não tem token" do
+      config = described_class.new(token_conta: "tc")
+
+      expect { config.validate_token!(:empresa) }
+        .to raise_error(FocusNfe::Errors::ConfigurationError, /token_empresa/)
+    end
+
+    it "levanta ConfigurationError citando token_conta quando o escopo :conta não tem token" do
+      config = described_class.new(token_empresa: "te")
+
+      expect { config.validate_token!(:conta) }
+        .to raise_error(FocusNfe::Errors::ConfigurationError, /token_conta/)
+    end
+
+    it "valida o ambiente antes do token" do
+      config = described_class.new(token_empresa: "te", environment: :sandbox)
+
+      expect { config.validate_token!(:empresa) }
+        .to raise_error(FocusNfe::Errors::ConfigurationError, /ambiente/)
+    end
+  end
+end

data/spec/focus_nfe/errors_mapping_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Errors do
+  describe ".class_for" do
+    {
+      400 => FocusNfe::Errors::BadRequest,
+      401 => FocusNfe::Errors::Unauthorized,
+      403 => FocusNfe::Errors::Forbidden,
+      404 => FocusNfe::Errors::NotFound,
+      409 => FocusNfe::Errors::Conflict,
+      422 => FocusNfe::Errors::ValidationError,
+      429 => FocusNfe::Errors::RateLimited
+    }.each do |status, klass|
+      it "mapeia #{status} para #{klass}" do
+        expect(described_class.class_for(status)).to eq(klass)
+      end
+    end
+
+    it "mapeia qualquer 5xx para ServerError", :aggregate_failures do
+      expect(described_class.class_for(500)).to eq(described_class::ServerError)
+      expect(described_class.class_for(503)).to eq(described_class::ServerError)
+      expect(described_class.class_for(599)).to eq(described_class::ServerError)
+    end
+
+    it "mapeia status não-2xx não previstos para UnexpectedResponse", :aggregate_failures do
+      expect(described_class.class_for(418)).to eq(described_class::UnexpectedResponse)
+      expect(described_class.class_for(451)).to eq(described_class::UnexpectedResponse)
+      expect(described_class.class_for(300)).to eq(described_class::UnexpectedResponse)
+    end
+  end
+
+  describe ".from_response" do
+    def response(status:, body: nil)
+      FocusNfe::HTTP::Response.new(
+        status: status,
+        headers: { "Content-Type" => "application/json" },
+        body: body
+      )
+    end
+
+    it "instancia a classe correta conforme o status" do
+      error = described_class.from_response(response(status: 422))
+
+      expect(error).to be_a(described_class::ValidationError)
+    end
+
+    it "preenche status, corpo e resposta a partir da Response", :aggregate_failures do
+      original = response(status: 422, body: '{"mensagem":"ref inválida"}')
+      error = described_class.from_response(original)
+
+      expect(error.status).to eq(422)
+      expect(error.body).to eq("mensagem" => "ref inválida")
+      expect(error.response).to be(original)
+    end
+
+    it "usa UnexpectedResponse para status não mapeado" do
+      error = described_class.from_response(response(status: 418))
+
+      expect(error).to be_a(described_class::UnexpectedResponse)
+    end
+
+    it "produz uma exceção levantável que carrega o status na mensagem" do
+      error = described_class.from_response(response(status: 500))
+
+      expect { raise error }.to raise_error(described_class::ServerError, /500/)
+    end
+  end
+end

data/spec/focus_nfe/errors_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Errors do
+  describe "FocusNfe::Error (raiz da hierarquia)" do
+    it "descende de StandardError" do
+      expect(FocusNfe::Error.new).to be_a(StandardError)
+    end
+
+    it "substitui a antiga FocusNfe::Erro (português), que deixa de existir" do
+      expect(FocusNfe.const_defined?(:Erro, false)).to be(false)
+    end
+  end
+
+  describe FocusNfe::Errors::HttpError do
+    it "descende de FocusNfe::Error" do
+      expect(described_class.ancestors).to include(FocusNfe::Error)
+    end
+
+    it "expõe status, corpo e resposta informados na construção" do
+      response = Object.new
+      error = described_class.new("falhou", status: 422, body: { "msg" => "ref" }, response: response)
+
+      expect(error).to have_attributes(message: "falhou", status: 422, body: { "msg" => "ref" }, response: response)
+    end
+
+    it "pode ser construído sem argumentos, com leitores nil", :aggregate_failures do
+      error = described_class.new
+
+      expect(error.status).to be_nil
+      expect(error.body).to be_nil
+      expect(error.response).to be_nil
+    end
+
+    describe "#codigo" do
+      it "extrai o código do corpo estruturado" do
+        error = described_class.new(body: { "codigo" => "nao_encontrado", "mensagem" => "..." })
+
+        expect(error.codigo).to eq("nao_encontrado")
+      end
+
+      it "é nil quando o corpo não traz codigo, é String ou é nil", :aggregate_failures do
+        expect(described_class.new(body: { "mensagem" => "..." }).codigo).to be_nil
+        expect(described_class.new(body: "<html>500</html>").codigo).to be_nil
+        expect(described_class.new(body: nil).codigo).to be_nil
+      end
+    end
+
+    describe "#erros" do
+      it "devolve a lista de validação como está" do
+        lista = [{ "campo" => "natureza_operacao", "mensagem" => "não pode ficar em branco" }]
+        error = described_class.new(body: { "erros" => lista })
+
+        expect(error.erros).to eq(lista)
+      end
+
+      it "embrulha o erro único no formato { campo, mensagem }" do
+        error = described_class.new(body: { "codigo" => "x", "mensagem" => "A NFe não está autorizada" })
+
+        expect(error.erros).to eq([{ "campo" => nil, "mensagem" => "A NFe não está autorizada" }])
+      end
+
+      it "é vazio sem erros nem mensagem, ou com corpo não-Hash", :aggregate_failures do
+        expect(described_class.new(body: { "codigo" => "x" }).erros).to eq([])
+        expect(described_class.new(body: "<html>500</html>").erros).to eq([])
+        expect(described_class.new(body: nil).erros).to eq([])
+      end
+    end
+  end
+
+  describe "subclasses tipadas de HttpError" do
+    %i[
+      BadRequest Unauthorized Forbidden NotFound Conflict
+      ValidationError RateLimited ServerError UnexpectedResponse
+    ].each do |name|
+      it "#{name} descende de HttpError, Error e StandardError", :aggregate_failures do
+        klass = described_class.const_get(name)
+
+        expect(klass.ancestors).to include(FocusNfe::Errors::HttpError)
+        expect(klass.ancestors).to include(FocusNfe::Error)
+        expect(klass.ancestors).to include(StandardError)
+      end
+    end
+
+    it "reúnem exatamente 9 classes distintas, sem aliasing" do
+      todas = described_class.constants.map { |name| described_class.const_get(name) }
+      subclasses = todas.select { |const| const.is_a?(Class) && const < described_class::HttpError }
+
+      expect(subclasses.uniq.size).to eq(9)
+    end
+  end
+
+  describe "erros não-HTTP (client-side e transporte)" do
+    it "ConfigurationError descende de Error, mas não de HttpError", :aggregate_failures do
+      ancestrais = FocusNfe::Errors::ConfigurationError.ancestors
+
+      expect(ancestrais).to include(FocusNfe::Error)
+      expect(ancestrais).not_to include(FocusNfe::Errors::HttpError)
+    end
+
+    it "ConnectionError descende de Error, mas não de HttpError", :aggregate_failures do
+      ancestrais = FocusNfe::Errors::ConnectionError.ancestors
+
+      expect(ancestrais).to include(FocusNfe::Error)
+      expect(ancestrais).not_to include(FocusNfe::Errors::HttpError)
+    end
+  end
+end

data/spec/focus_nfe/esquemas/campo_spec.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Esquemas::Campo do
+  def campo(atributos)
+    described_class.new(atributos)
+  end
+
+  describe "#nome e #obrigatorio?" do
+    it "lê o nome e a obrigatoriedade da definição", :aggregate_failures do
+      c = campo("name" => "natureza_operacao", "type" => "String[1-60]", "required" => true)
+
+      expect(c.nome).to eq("natureza_operacao")
+      expect(c).to be_obrigatorio
+    end
+
+    it "não é obrigatório quando required é false" do
+      expect(campo("name" => "x", "type" => "String[1-60]", "required" => false)).not_to be_obrigatorio
+    end
+  end
+
+  describe "parsing do tipo" do
+    it "interpreta String[1-60] como string com mínimo e máximo", :aggregate_failures do
+      c = campo("name" => "x", "type" => "String[1-60]")
+
+      expect(c.tipo).to eq(:string)
+      expect(c.tamanho_minimo).to eq(1)
+      expect(c.tamanho_maximo).to eq(60)
+    end
+
+    it "interpreta String[14] como tamanho fixo", :aggregate_failures do
+      c = campo("name" => "x", "type" => "String[14]")
+
+      expect(c.tipo).to eq(:string)
+      expect(c.tamanho_minimo).to eq(14)
+      expect(c.tamanho_maximo).to eq(14)
+    end
+
+    it "interpreta Integer[1-9] como inteiro com faixa de dígitos", :aggregate_failures do
+      c = campo("name" => "x", "type" => "Integer[1-9]")
+
+      expect(c.tipo).to eq(:integer)
+      expect(c.tamanho_minimo).to eq(1)
+      expect(c.tamanho_maximo).to eq(9)
+    end
+
+    it "interpreta Decimal[13.2] como inteiros e casas fixas", :aggregate_failures do
+      c = campo("name" => "x", "type" => "Decimal[13.2]")
+
+      expect(c.tipo).to eq(:decimal)
+      expect(c.decimal.inteiros).to eq(13)
+      expect(c.decimal.casas_minimas).to eq(2)
+      expect(c.decimal.casas_maximas).to eq(2)
+    end
+
+    it "interpreta Decimal[13.2-4] como faixa de casas", :aggregate_failures do
+      c = campo("name" => "x", "type" => "Decimal[13.2-4]")
+
+      expect(c.decimal.casas_minimas).to eq(2)
+      expect(c.decimal.casas_maximas).to eq(4)
+    end
+
+    it "interpreta Decimal[13.] como zero casas", :aggregate_failures do
+      c = campo("name" => "x", "type" => "Decimal[13.]")
+
+      expect(c.decimal.inteiros).to eq(13)
+      expect(c.decimal.casas_minimas).to eq(0)
+      expect(c.decimal.casas_maximas).to eq(0)
+    end
+
+    it "interpreta Decimal[2] sem ponto como zero casas", :aggregate_failures do
+      c = campo("name" => "x", "type" => "Decimal[2]")
+
+      expect(c.decimal.inteiros).to eq(2)
+      expect(c.decimal.casas_maximas).to eq(0)
+    end
+
+    it "interpreta Decimal[11.0-10] com casas a partir de zero", :aggregate_failures do
+      c = campo("name" => "x", "type" => "Decimal[11.0-10]")
+
+      expect(c.decimal.inteiros).to eq(11)
+      expect(c.decimal.casas_minimas).to eq(0)
+      expect(c.decimal.casas_maximas).to eq(10)
+    end
+
+    it "interpreta DateTime" do
+      expect(campo("name" => "x", "type" => "DateTime").tipo).to eq(:datetime)
+    end
+
+    it "interpreta Date" do
+      expect(campo("name" => "x", "type" => "Date").tipo).to eq(:date)
+    end
+
+    it "interpreta type nulo como enum quando há enum" do
+      c = campo("name" => "x", "type" => nil, "enum" => "* +1+: Sim")
+
+      expect(c.tipo).to eq(:enum)
+    end
+
+    it "marca coleções", :aggregate_failures do
+      c = campo("name" => "items", "type" => "Coleção[1-990]", "collection" => { "object_attributes" => [] })
+
+      expect(c).to be_colecao
+      expect(c.tipo).to eq(:colecao)
+    end
+  end
+
+  describe "#esquema_colecao" do
+    let(:atributos) do
+      [
+        { "name" => "numero", "type" => "Integer[1-3]", "required" => true },
+        { "name" => "descricao", "type" => "String[1-120]", "required" => true }
+      ]
+    end
+
+    it "devolve nil para campo escalar" do
+      expect(campo("name" => "x", "type" => "String[1-60]").esquema_colecao).to be_nil
+    end
+
+    it "devolve nil para coleção sem object_attributes" do
+      expect(campo("name" => "x", "type" => "Coleção[0-5]", "collection" => {}).esquema_colecao).to be_nil
+    end
+
+    it "constrói um Esquema com os subcampos da coleção" do
+      c = campo("name" => "items", "type" => "Coleção[1-990]", "collection" => { "object_attributes" => atributos })
+
+      expect(c.esquema_colecao.campos.map(&:nome)).to eq(%w[numero descricao])
+    end
+  end
+
+  describe "#to_h" do
+    it "descreve um campo escalar com tipo, tamanho e metadados", :aggregate_failures do
+      h = campo(
+        "name" => "natureza_operacao", "description" => "Descrição da natureza de operação.",
+        "type" => "String[1-60]", "required" => true, "tag" => "natOp"
+      ).to_h
+
+      expect(h).to include(
+        nome: "natureza_operacao", descricao: "Descrição da natureza de operação.",
+        tipo: :string, tipo_bruto: "String[1-60]", obrigatorio: true,
+        tamanho_minimo: 1, tamanho_maximo: 60, enum: nil, tag: "natOp", colecao: nil
+      )
+    end
+
+    it "expõe o enum e marca o tipo :enum", :aggregate_failures do
+      h = campo("name" => "tipo_documento", "type" => nil, "enum" => "* +1+: Sim").to_h
+
+      expect(h[:tipo]).to eq(:enum)
+      expect(h[:enum]).to eq("* +1+: Sim")
+    end
+
+    it "aninha os subcampos de uma coleção em :colecao", :aggregate_failures do
+      atributos = [{ "name" => "numero", "type" => "Integer[1-3]", "required" => true }]
+      colecao = { "object_attributes" => atributos }
+      h = campo("name" => "items", "type" => "Coleção[1-990]", "collection" => colecao).to_h
+
+      expect(h[:tipo]).to eq(:colecao)
+      expect(h[:colecao]).to eq([campo(atributos.first).to_h])
+    end
+
+    it "deixa :colecao nil para coleção sem object_attributes" do
+      h = campo("name" => "x", "type" => "Coleção[0-5]", "collection" => {}).to_h
+
+      expect(h[:colecao]).to be_nil
+    end
+  end
+
+  describe "#validar_valor" do
+    it "aceita string dentro do tamanho" do
+      expect(campo("name" => "x", "type" => "String[1-60]").validar_valor("ok")).to be_nil
+    end
+
+    it "rejeita string acima do máximo" do
+      mensagem = campo("name" => "natureza_operacao", "type" => "String[1-3]").validar_valor("abcd")
+
+      expect(mensagem).to include("natureza_operacao")
+    end
+
+    it "rejeita inteiro com não-dígitos" do
+      expect(campo("name" => "numero", "type" => "Integer[1-9]").validar_valor("12a")).to include("numero")
+    end
+
+    it "aceita inteiro válido na faixa de dígitos" do
+      expect(campo("name" => "numero", "type" => "Integer[1-9]").validar_valor(12_345)).to be_nil
+    end
+
+    it "rejeita inteiro com quantidade de dígitos fora da faixa", :aggregate_failures do
+      mensagem = campo("name" => "numero", "type" => "Integer[1-3]").validar_valor(12_345)
+
+      expect(mensagem).to include("numero")
+      expect(mensagem).to include("5 dígitos")
+    end
+
+    it "não restringe coleções nem tipos desconhecidos", :aggregate_failures do
+      expect(campo("name" => "x", "type" => "Coleção[0-5]", "collection" => {}).validar_valor([])).to be_nil
+      expect(campo("name" => "x", "type" => "Algo[1-2]").validar_valor("qualquer")).to be_nil
+    end
+
+    context "com decimais" do
+      it "aceita decimal dentro de inteiros e casas" do
+        expect(campo("name" => "valor", "type" => "Decimal[13.2]").validar_valor("10.50")).to be_nil
+      end
+
+      it "aceita menos casas que o mínimo" do
+        expect(campo("name" => "valor", "type" => "Decimal[13.2]").validar_valor("10")).to be_nil
+      end
+
+      it "aceita Numeric além de String" do
+        expect(campo("name" => "valor", "type" => "Decimal[13.2]").validar_valor(10.5)).to be_nil
+      end
+
+      it "rejeita inteiros demais", :aggregate_failures do
+        mensagem = campo("name" => "valor", "type" => "Decimal[2.2]").validar_valor("1234.5")
+
+        expect(mensagem).to include("valor")
+      end
+
+      it "rejeita casas decimais além do máximo" do
+        expect(campo("name" => "valor", "type" => "Decimal[13.2]").validar_valor("10.123")).to include("valor")
+      end
+
+      it "rejeita valor não numérico" do
+        expect(campo("name" => "valor", "type" => "Decimal[13.2]").validar_valor("abc")).to include("valor")
+      end
+    end
+
+    context "com enums" do
+      it "aceita valor dentro do conjunto declarado" do
+        expect(campo("name" => "modalidade", "type" => nil, "enum" => "* +1+: Sim").validar_valor("1")).to be_nil
+      end
+
+      it "aceita Integer correspondente ao código String" do
+        expect(campo("name" => "modalidade", "type" => nil, "enum" => "* +1+: Sim").validar_valor(1)).to be_nil
+      end
+
+      it "rejeita valor fora do conjunto" do
+        c = campo("name" => "modalidade", "type" => nil, "enum" => "* +0+: Não\\n* +1+: Sim")
+
+        expect(c.validar_valor("9")).to include("modalidade")
+      end
+
+      it "valida o conjunto mesmo quando o campo também tem tipo escalar" do
+        c = campo("name" => "indicador", "type" => "Integer[1-1]", "enum" => "* +0+: Não\\n* +1+: Sim")
+
+        expect(c.validar_valor(9)).to include("indicador")
+      end
+
+      it "rejeita o tipo escalar antes do enum" do
+        c = campo("name" => "indicador", "type" => "Integer[1-1]", "enum" => "* +1+: Sim")
+
+        expect(c.validar_valor("x")).to include("indicador")
+      end
+    end
+
+    context "com datas" do
+      it "aceita Date em ISO 8601" do
+        expect(campo("name" => "data", "type" => "Date").validar_valor("2026-06-14")).to be_nil
+      end
+
+      it "rejeita Date inválida" do
+        expect(campo("name" => "data", "type" => "Date").validar_valor("14/06/2026")).to include("data")
+      end
+
+      it "aceita DateTime com offset" do
+        expect(campo("name" => "emissao", "type" => "DateTime").validar_valor("2026-06-14T10:00:00-03:00")).to be_nil
+      end
+
+      it "rejeita DateTime inválido" do
+        expect(campo("name" => "emissao", "type" => "DateTime").validar_valor("qualquer")).to include("emissao")
+      end
+    end
+  end
+
+  describe "#valores_enum" do
+    it "extrai códigos do formato com espaço" do
+      c = campo("name" => "x", "type" => nil, "enum" => "* +0+: Correios\\n* +1+: Conta própria")
+
+      expect(c.valores_enum).to eq(%w[0 1])
+    end
+
+    it "extrai códigos do formato sem espaço e multi-caractere" do
+      c = campo("name" => "x", "type" => nil, "enum" => "*+01+: Repasse\\n*+99+: Outros")
+
+      expect(c.valores_enum).to eq(%w[01 99])
+    end
+
+    it "devolve vazio para enum em branco", :aggregate_failures do
+      expect(campo("name" => "x", "type" => "String[1-2]", "enum" => "").valores_enum).to eq([])
+      expect(campo("name" => "x", "type" => "String[1-2]").enum?).to be(false)
+    end
+  end
+end

data/spec/focus_nfe/esquemas/decimal_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+RSpec.describe FocusNfe::Esquemas::Decimal do
+  describe ".parsear" do
+    it "devolve nil para tipo que não é decimal", :aggregate_failures do
+      expect(described_class.parsear(nil)).to be_nil
+      expect(described_class.parsear("String[1-60]")).to be_nil
+    end
+
+    it "parseia inteiros e a faixa de casas", :aggregate_failures do
+      d = described_class.parsear("Decimal[13.2-4]")
+
+      expect(d.inteiros).to eq(13)
+      expect(d.casas_minimas).to eq(2)
+      expect(d.casas_maximas).to eq(4)
+    end
+
+    it "trata ponto sem casas como zero casas" do
+      expect(described_class.parsear("Decimal[13.]").casas_maximas).to eq(0)
+    end
+  end
+
+  describe "#validar" do
+    subject(:decimal) { described_class.parsear("Decimal[13.2]") }
+
+    it "aceita valor dentro de inteiros e casas" do
+      expect(decimal.validar("10.50")).to be_nil
+    end
+
+    it "aceita menos casas que o mínimo" do
+      expect(decimal.validar("10")).to be_nil
+    end
+
+    it "rejeita inteiros demais" do
+      expect(described_class.parsear("Decimal[2.2]").validar("1234.5")).to include("inteiros")
+    end
+
+    it "rejeita casas decimais além do máximo" do
+      expect(decimal.validar("10.123")).to include("casas")
+    end
+
+    it "rejeita valor não numérico" do
+      expect(decimal.validar("abc")).to include("inválido")
+    end
+  end
+
+  describe "#to_h" do
+    it "descreve a especificação" do
+      expect(described_class.parsear("Decimal[13.2-4]").to_h).to eq(
+        inteiros: 13, casas_minimas: 2, casas_maximas: 4
+      )
+    end
+  end
+end