arca.rb 1.0.0

data/lib/arca/wsrgiva.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# WSRGIVA: Web Service del Régimen de Percepción de I.V.A. (ARCA).
+# Consulta de situación fiscal por lote (hasta 100 contribuyentes).
+# Documentación: Régimen de Percepción de I.V.A. v1.0 (03-04-2023).
+module Arca
+  class WSRGIVA
+    WSDL = {
+      development: "https://fwshomo.afip.gov.ar/wsrgiva/services/RegimenPercepcionIVAService?wsdl",
+      production: "https://serviciosjava.afip.gov.ar/wsrgiva/services/RegimenPercepcionIVAService?wdsl",
+      test: "#{Root}/test/fixtures/wsrgiva/wsrgiva.wsdl"
+    }.freeze
+
+    attr_reader :wsaa, :cuit
+
+    def initialize(options = {})
+      @cuit = normalize_cuit(options[:cuit])
+      @wsaa = WSAA.new options.merge(service: "wsrgiva")
+      @client = Client.new Hash(options[:savon]).reverse_merge(
+        wsdl: WSDL[@wsaa.env],
+        soap_version: 1
+      )
+    end
+
+    def dummy
+      r = request(:dummy)[:return]
+      {
+        app_server: r[:appserver] || r[:app_server],
+        auth_server: r[:authserver] || r[:auth_server],
+        db_server: r[:dbserver] || r[:db_server]
+      }
+    end
+
+    # Consulta la situación fiscal de hasta 100 contribuyentes.
+    # cuits: array of 11-digit CUIT strings/integers (max 100).
+    # tipo_bienes_involucrados: 1 (único valor admitido; nuevo/usado).
+    # Returns array of constancia hashes (one per CUIT): success with
+    # fecha_consulta, id_contribuyente, descripcion_contribuyente, vigencia,
+    # codigo_leyenda, descripcion_leyenda, codigo_seguridad; or error with
+    # codigo_error, descripcion_error.
+    def consultar_constancia_por_lote(cuits, tipo_bienes_involucrados: 1)
+      cuits = Array(cuits).map { |c| c.to_s.gsub(/\D/, "") }
+      raise ArgumentError, "Maximum 100 CUITs per request" if cuits.size > 100
+      raise ArgumentError, "tipo_bienes_involucrados must be 1" if tipo_bienes_involucrados != 1
+
+      datos_transaccion = cuits.map do |cuit|
+        { cuit_contribuyente: cuit.to_i, tipo_bienes_involucrados: 1 }
+      end
+      message = {
+        auth_request: @wsaa.auth.merge(cuit_representada: cuit),
+        datos_transaccion_array: { datos_transaccion: datos_transaccion }
+      }
+      result = request(:consultar_constancia_por_lote_v2, message)[:return]
+      constancias = result[:constancia]
+      Array.wrap(constancias)
+    end
+
+    private
+
+    def request(action, body = nil)
+      @client.request(action, body).to_hash[:"#{action}_response"]
+    end
+
+    def normalize_cuit(value)
+      if value.nil? || value == ""
+        0
+      else
+        value.to_s.gsub(/\D/, "").to_i
+      end
+    end
+  end
+end

data/lib/arca.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arca
+  Root = File.expand_path("..", __dir__)
+end
+
+require "forwardable"
+require "builder"
+require "base64"
+require "httpclient"
+require "savon"
+require "nokogiri"
+require "active_support"
+require "active_support/core_ext"
+require "arca/core_ext/hash"
+require "arca/errors/error"
+require "arca/errors/response_error"
+require "arca/errors/server_error"
+require "arca/errors/network_error"
+require "arca/type_conversions"
+require "arca/client"
+require "arca/wsaa"
+require "arca/wsfe"
+require "arca/ws_constancia_inscripcion"
+require "arca/persona_service_a4"
+require "arca/persona_service_a5"
+require "arca/persona_service_a100"
+require "arca/w_cons_declaracion"
+require "arca/wsrgiva"
+require "arca/wscdc"
+require "arca/wsfecred"

data/test/arca/client_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class ClientTest < TestCase
+    def subject
+      @subject ||= Client.new(wsdl: Arca::WSFE::WSDL[:test])
+    end
+
+    def test_savon_soap_fault_se_encapsulan_en_server_error
+      savon.expects(:fe_dummy).returns(fixture("wsaa/login_cms/fault"))
+      error = assert_raises(ServerError) { subject.request :fe_dummy }
+      assert_match(/CMS no es valido/, error.message)
+    end
+
+    def test_savon_http_error_se_encapsulan_en_server_error
+      expect_savon_to_raise Savon::HTTPError, stub(code: 503, body: "Service Unavailable")
+      error = assert_raises(ServerError) { subject.request :fe_dummy }
+      assert_match(/Service Unavailable/, error.message)
+    end
+
+    def test_httpclient_timeout_error_se_encapsulan_en_network_error_y_no_es_retriable
+      expect_savon_to_raise HTTPClient::ReceiveTimeoutError, "execution expired"
+      error = assert_raises(NetworkError) { subject.request :fe_dummy }
+      assert_match(/execution expired/, error.message)
+      assert_equal false, error.retriable?
+    end
+
+    def test_httpclient_connect_timeout_error_se_encapsulan_en_network_error_y_es_retriable
+      expect_savon_to_raise HTTPClient::ConnectTimeoutError, "execution expired"
+      error = assert_raises(NetworkError) { subject.request :fe_dummy }
+      assert_match(/execution expired/, error.message)
+      assert_equal true, error.retriable?
+    end
+
+    private
+
+    def expect_savon_to_raise(error_class, message)
+      subject.instance_eval("@savon", __FILE__, __LINE__).expects(:call).raises(error_class, message)
+    end
+  end
+end

data/test/arca/core_ext/hash_test.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HashCoreExtTest < Minitest::Test
+  using Arca::CoreExt::Hash
+
+  def test_select_keys_toma_los_values_de_las_keys_indicadas
+    hash = { 1 => 2, 3 => 4 }
+    assert_equal({ 1 => 2 }, hash.select_keys(1))
+    assert_equal({ 1 => 2, 3 => 4 }, hash.select_keys(1, 3))
+    assert_equal({}, hash.select_keys(5))
+    assert_equal({ 3 => 4 }, hash.select_keys(5, 3))
+  end
+end

data/test/arca/persona_service_a100_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class PersonaServiceA100Test < TestCase
+    def ta
+      @ta ||= { token: "t", sign: "s" }
+    end
+
+    def ws
+      @ws ||= PersonaServiceA100.new(cuit: "12345678912").tap { |w| w.wsaa.stubs auth: ta }
+    end
+
+    def auth_message
+      ta.merge(cuitRepresentada: "12345678912")
+    end
+
+    def test_dummy
+      savon.expects(:dummy).returns(fixture("ws_sr_padron_a100/dummy/success"))
+      assert_equal({ appserver: "OK", authserver: "OK", dbserver: "OK" }, ws.dummy)
+    end
+
+    def test_jurisdictions
+      savon.expects(:get_parameter_collection_by_name)
+        .with(message: auth_message.merge(collectionName: "SUPA.E_PROVINCIA"))
+        .returns(fixture("ws_sr_padron_a100/jurisdictions/success"))
+      assert_hash_includes ws.jurisdictions, name: "SUPA.E_PROVINCIA"
+    end
+
+    def test_company_types
+      savon.expects(:get_parameter_collection_by_name)
+        .with(message: auth_message.merge(collectionName: "SUPA.TIPO_EMPRESA_JURIDICA"))
+        .returns(fixture("ws_sr_padron_a100/company_types/success"))
+      assert_hash_includes ws.company_types, name: "SUPA.TIPO_EMPRESA_JURIDICA"
+    end
+
+    def test_public_organisms
+      savon.expects(:get_parameter_collection_by_name)
+        .with(message: auth_message.merge(collectionName: "SUPA.E_ORGANISMO_INFORMANTE"))
+        .returns(fixture("ws_sr_padron_a100/public_organisms/success"))
+      assert_hash_includes ws.public_organisms, name: "SUPA.E_ORGANISMO_INFORMANTE"
+    end
+  end
+end

data/test/arca/persona_service_a4_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class PersonaServiceA4Test < TestCase
+    def ta
+      @ta ||= { token: "t", sign: "s" }
+    end
+
+    def ws
+      @ws ||= PersonaServiceA4.new(cuit: "12345678912").tap { |w| w.wsaa.stubs auth: ta }
+    end
+
+    def auth_message
+      ta.merge(cuitRepresentada: "12345678912")
+    end
+
+    def test_dummy
+      savon.expects(:dummy).returns(fixture("ws_sr_padron_a4/dummy/success"))
+      assert_equal({ appserver: "OK", authserver: "OK", dbserver: "OK" }, ws.dummy)
+    end
+
+    def test_get_persona
+      savon.expects(:get_persona)
+        .with(message: auth_message.merge(idPersona: "98765432198"))
+        .returns(fixture("ws_sr_padron_a4/get_persona/success"))
+      assert_hash_includes ws.get_persona("98765432198"), apellido: "ERNESTO DANIEL"
+    end
+  end
+end

data/test/arca/persona_service_a5_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class PersonaServiceA5Test < TestCase
+    def ta
+      @ta ||= { token: "t", sign: "s" }
+    end
+
+    def ws
+      @ws ||= PersonaServiceA5.new(cuit: "12345678912").tap { |w| w.wsaa.stubs auth: ta }
+    end
+
+    def auth_message
+      ta.merge(cuitRepresentada: "12345678912")
+    end
+
+    def test_dummy
+      savon.expects(:dummy).returns(fixture("ws_sr_padron_a5/dummy/success"))
+      assert_equal({ appserver: "OK", authserver: "OK", dbserver: "OK" }, ws.dummy)
+    end
+
+    def test_get_persona
+      savon.expects(:get_persona)
+        .with(message: auth_message.merge(idPersona: "98765432198"))
+        .returns(fixture("ws_sr_padron_a5/get_persona/success"))
+      assert ws.get_persona("98765432198").key?(:datos_generales)
+    end
+  end
+end

data/test/arca/test.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDDzCCAfegAwIBAgIUdt0TOIYoh1GRdF20ue4cL9lnlmYwDQYJKoZIhvcNAQEL
+BQAwFzEVMBMGA1UEAwwMYXJjYXNkay10ZXN0MB4XDTI2MDEzMTEzNTAwM1oXDTI3
+MDEzMTEzNTAwM1owFzEVMBMGA1UEAwwMYXJjYXNkay10ZXN0MIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuznTwETEgl17pfqJOVAAQFDPHCFlXZF0+hlA
+b49Qs7wZA6nCE7JYadyT2m5sis3TnyEzilFQRKh/ogbXCmAFPVR7SyGPpUn2R+o7
+jI4dkkIRi/awr02mC7YhZcTtYmRfr5SEOrqQGDy3Y8+u2NMw4wrLsY+M6vjG+XCd
+z4z4szpJuI61R5IhlL0hEItTi0DnZluh86jgmDT5rZ/PF+HpnM1Gw3O415jmWR3n
+wgrdlEZWPvC/GFZnImMKJZcIOEJRJNWa2dxqiQNnJggwdJE9eAaSDNS8S31fmchK
+KRKOCfSRseW6m5TzwkA46Y2bgBmTiYeXs9+brKIYYrN54V6JUwIDAQABo1MwUTAd
+BgNVHQ4EFgQUB1hDQYM66Xdd8Kuz4RZ2FOjn4acwHwYDVR0jBBgwFoAUB1hDQYM6
+6Xdd8Kuz4RZ2FOjn4acwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOC
+AQEAKkOfdp74GQgynVacmzBfBZanYZZwmyJgozEFwNk90sE/4ul3uzy9kaDw9m6Z
+dUB2ZfwQSkkGcKN/D67PVpAOtUCjow3qEyPkr8Lu6YJR275J1L0sNfeffUFPslZy
+yOdRXHB08ixl8h1tj46R4JinL92JljlJz8v2U5YxPgJNbmgEpiKFYeI2lL+jAbqO
+PJowIhkC2rruFmGOhheLziCI035AJRK+Xq0Kof0pLPEzpM/We2TSGftZxOm0Da9z
+rGvlEWCuGDw1LehbIOPFXMx/xwkbg9hZiO80AjstqVX/yBWfG7r4KN4W/DxFYt1y
+bgmc8mIlyTHDlLMy8ngCYDNC3Q==
+-----END CERTIFICATE-----

data/test/arca/test.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC7OdPARMSCXXul
++ok5UABAUM8cIWVdkXT6GUBvj1CzvBkDqcITslhp3JPabmyKzdOfITOKUVBEqH+i
+BtcKYAU9VHtLIY+lSfZH6juMjh2SQhGL9rCvTaYLtiFlxO1iZF+vlIQ6upAYPLdj
+z67Y0zDjCsuxj4zq+Mb5cJ3PjPizOkm4jrVHkiGUvSEQi1OLQOdmW6HzqOCYNPmt
+n88X4emczUbDc7jXmOZZHefCCt2URlY+8L8YVmciYwollwg4QlEk1ZrZ3GqJA2cm
+CDB0kT14BpIM1LxLfV+ZyEopEo4J9JGx5bqblPPCQDjpjZuAGZOJh5ez35usohhi
+s3nhXolTAgMBAAECggEAXI5RWq8EUIhDXMHWvcEJZsIsKPVvhYqngA4ktyHr3PbD
+jPaKja8wmyDi7OyC9zmagQPqVVouasq70g88lpHydSfDDdjJCQbf3Bx1FN6aytej
+kgRBw2AJEqgWqZdpXSdO0F+E4P2ix4CYjpy4jNMWy17mZOCY4v5aayzbryO7POpe
+SGpr7+1uglqKMlrvFUrUEnxhvycYH3c7PWrFhhm2toQfYleyyWiJA8TsilR0jPhv
+/GePDu6uF/g0Qs7Fc1EFDMPvxW+D7820BMwgSuELLUg2XbvFkPH7junRzvvuW++n
+Vnlcl5GB9T1MszBVRdOplYtPFBVUPMtzm8n+ufUuSQKBgQDrbP2Y7UGaMYXMfSOQ
+jJdEWFM0xqPUzmFVGHVmJjyHic+dXMgwvgkQrjIOrepEMlw7wC7tcNG4bUkTE9YL
+HO6DJakybNQJ+jyerQrsXfCC75NlxZLPsjOG01gr+8SUCdJQCGu3Wi5mGkfhbgQV
+yXLQXeQxseh75PpnAB8pQp4YewKBgQDLln8AXtbaROa4x+D6CBYEL8v8O+tgIjAB
+zPZ1Fvah/guGn1f3nUJdL4O65oDnoPAOxTooHBvEzJMhYN1LTN/kqQbApvkPmW9F
+NAz4ParAWpoLMNn36IBqSrYzCetZm2NoL21KZei+bUNbJiTzeCqDrfHE/2PgEoBg
+FGRnSEP3CQKBgQDTGkI0NNsUdr+xY6zWWxrw7/p8YnpZwk3IzkvHMxYnu01tn9rq
+yhy61liQjSZ5zGakNWpfA0ErDOPvtWPDR0ggVU7opmlkIPzmk+gtlvapkkYrhgRl
+NTe6+BwiJHpa/IuXtFVSbg0ZBQvbepkzKBZJ/Uc3wH3lSqe2YIeQqem1rQKBgFj/
+/6E/1JkyydI5vwZPBqDp7DjmUO2DxIzk91EUqtkCYDOH8ULUQrDOFr5cCjo4RvmO
+CvCB6TnNXPyYheVnQ/GIWuVZmUPShawxJwJWoxDYCsOdpYwU3h6ZbrE9Qt+3aGuh
+YBvIFUk6JtnwAPNWsu9B2ZGPPDA2plxaTdJA60VRAoGACXSbVz7cECvkmuSCg03s
+a+FYZs/aeKifsOW5D/ikvmvUu2pMaWN1eL5s5atkUSkFJ0zdnCPjtkrccLcFKJFi
+7ZRRLu3bc+jYlq37nSYyUop7fpds0IT2ATYlEb956nrDbEipMuY2epGmVQGk/GUI
+PcCN51NZ5hfoG1eda5xlZmw=
+-----END PRIVATE KEY-----

data/test/arca/type_conversions_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class TypeConversionsTest < TestCase
+    include Arca::TypeConversions
+
+    def test_r2x_convierte_values_de_hashes_a_xml_types
+      assert_equal(
+        { fecha: "20110102", id: 1 },
+        r2x({ fecha: Date.new(2011, 1, 2), id: 1 }, fecha: :date)
+      )
+      assert_equal(
+        { container: { fecha: "20110102" } },
+        r2x({ container: { fecha: Date.new(2011, 1, 2) } }, fecha: :date)
+      )
+    end
+
+    def test_r2x_convierte_values_aunque_esten_en_arrays
+      assert_equal [ { fecha: "20110102" } ], r2x([ { fecha: Date.new(2011, 1, 2) } ], fecha: :date)
+      assert_equal(
+        { container: [ { fecha: "20110102" }, { fecha: "20110103" } ] },
+        r2x({ container: [ { fecha: Date.new(2011, 1, 2) }, { fecha: Date.new(2011, 1, 3) } ] }, fecha: :date)
+      )
+    end
+
+    def test_x2r_convierte_xml_types_a_ruby
+      assert_equal(
+        { fecha: Date.new(2011, 1, 2), id: 1, total: 1.23, obs: "algo" },
+        x2r({ fecha: "20110102", id: "1", total: "1.23", obs: "algo" }, fecha: :date, id: :integer, total: :float)
+      )
+      assert_equal({ container: { id: 1 } }, x2r({ container: { id: "1" } }, id: :integer))
+    end
+
+    def test_x2r_hace_la_conversion_en_arrays
+      assert_equal(
+        { container: [ { id: 1 }, { id: 2 } ] },
+        x2r({ container: [ { id: "1" }, { id: "2" } ] }, id: :integer)
+      )
+    end
+  end
+end

data/test/arca/w_cons_declaracion_test.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class WConsDeclaracionTest < TestCase
+    def ta
+      @ta ||= { token: "t", sign: "s" }
+    end
+
+    def ws
+      @ws ||= WConsDeclaracion.new(env: :test, cuit: "23076925089").tap { |w| w.wsaa.stubs auth: ta }
+    end
+
+    def test_utiliza_los_parametros_correctos_en_el_wsaa
+      assert_equal "wconsdeclaracion", ws.wsaa.service
+      assert_equal "23076925089", ws.wsaa.cuit
+      assert_equal :test, ws.wsaa.env
+    end
+
+    def test_dummy
+      savon.expects(:dummy).returns(fixture("wconsdeclaracion/dummy/success"))
+      assert_equal({ app_server: "OK", db_server: "OK", auth_server: "OK" }, ws.dummy)
+    end
+
+    def test_detallada_lista_declaraciones_por_id
+      message = with_auth_section(
+        "argDetalladasListaParams" => {
+          "CuitImportadorExportador" => "23076925089",
+          "IdentificadorDeclaracion" => "19093SIMI000434X"
+        }
+      )
+      savon.expects(:detallada_lista_declaraciones).with(message: message)
+        .returns(fixture("wconsdeclaracion/detallada_lista_declaraciones/por_id_success"))
+      declaracion = ws.detallada_lista_declaraciones identificador_declaracion: "19093SIMI000434X"
+      assert_hash_includes declaracion, identificador_declaracion: "19093SIMI000434X",
+                                        cuit_importador_exportador: "23076925089"
+    end
+
+    def test_detallada_lista_declaraciones_por_fecha
+      message = with_auth_section(
+        "argDetalladasListaParams" => {
+          "CuitImportadorExportador" => "23076925089",
+          "FechaOficializacionDesde" => "2019-04-01T00:00:00-03:00",
+          "FechaOficializacionHasta" => "2019-04-30T00:00:00-03:00"
+        }
+      )
+      savon.expects(:detallada_lista_declaraciones).with(message: message)
+        .returns(fixture("wconsdeclaracion/detallada_lista_declaraciones/por_fecha_success"))
+      declaraciones = ws.detallada_lista_declaraciones(
+        fecha_oficializacion_desde: Time.parse("2019-04-01T00:00:00-03:00"),
+        fecha_oficializacion_hasta: Time.parse("2019-04-30T00:00:00-03:00")
+      )
+      assert_equal 2, declaraciones.size
+      assert declaraciones.any? { |d| d[:identificador_declaracion] == "19092SIMI000313M" }
+      assert declaraciones.any? { |d| d[:identificador_declaracion] == "19092SIMI000314N" }
+    end
+
+    def test_detallada_lista_declaraciones_id_inexistente
+      savon.expects(:detallada_lista_declaraciones).with(message: :any)
+        .returns(fixture("wconsdeclaracion/detallada_lista_declaraciones/por_id_inexistente"))
+      error = assert_raises(ResponseError) { ws.detallada_lista_declaraciones identificador_declaracion: "..." }
+      assert_equal "21248: Declaracion 19093SIMI000434. inexistente o invalida", error.message
+    end
+
+    def test_detallada_estado
+      message = with_auth_section("argIdentificadorDestinacion" => "19093SIMI000434X")
+      savon.expects(:detallada_estado).with(message: message)
+        .returns(fixture("wconsdeclaracion/detallada_estado/success"))
+      r = ws.detallada_estado("19093SIMI000434X")
+      assert_hash_includes r, fecha_salida: DateTime.parse("2019-04-25T18:48:12"),
+                              fecha_cancelacion: DateTime.parse("2019-07-04T02:29:34")
+    end
+
+    private
+
+    def with_auth_section(msg)
+      {
+        "argWSAutenticacionEmpresa" => {
+          "Token" => "t", "Sign" => "s", "CuitEmpresaConectada" => "23076925089",
+          "TipoAgente" => "IMEX", "Rol" => "IMEX"
+        }
+      }.merge(msg)
+    end
+  end
+end

data/test/arca/ws_constancia_inscripcion_test.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class WSConstanciaInscripcionTest < TestCase
+    def ta
+      @ta ||= { token: "t", sign: "s" }
+    end
+
+    def ws
+      @ws ||= WSConstanciaInscripcion.new(cuit: "1").tap { |w| w.wsaa.stubs auth: ta }
+    end
+
+    def auth_message
+      ta.merge(cuit_representada: "1")
+    end
+
+    def test_dummy
+      savon.expects(:dummy).returns(fixture("ws_sr_constancia_inscripcion/dummy/success"))
+      assert_equal({ appserver: "OK", dbserver: "OK", authserver: "OK" }, ws.dummy)
+    end
+
+    def test_deberia_devolver_hash_con_datos_generales_y_regimenes_impositivos
+      savon.expects(:get_persona)
+        .with(message: auth_message.merge(id_persona: "20294834487"))
+        .returns(fixture("ws_sr_constancia_inscripcion/get_persona/success"))
+      r = ws.get_persona "20294834487"
+      assert_hash_includes r[:datos_generales], estado_clave: "ACTIVO", mes_cierre: "6",
+                                                razon_social: "LA REGALERIA S A", tipo_clave: "CUIT", tipo_persona: "JURIDICA"
+      assert_hash_includes r[:datos_generales][:domicilio_fiscal], cod_postal: "2300",
+                                                                   descripcion_provincia: "SANTA FE", direccion: "AV SIEMPRE VIVA 123", localidad: "NUEVA YORK", tipo_domicilio: "FISCAL"
+      assert_hash_includes r[:datos_regimen_general][:actividad], id_actividad: "477330", nomenclador: "883",
+                                                                  orden: "2", periodo: "201311"
+      assert_hash_includes r[:datos_regimen_general][:impuesto][1], descripcion_impuesto: "IVA", id_impuesto: "30",
+                                                                    periodo: "198903"
+      assert_hash_includes r[:datos_regimen_general][:regimen], id_impuesto: "208", id_regimen: "159", periodo: "199403"
+    end
+
+    def test_cuando_hay_errores_en_la_constancia_sigue_la_misma_logica
+      savon.expects(:get_persona)
+        .with(message: auth_message.merge(id_persona: "20294834489"))
+        .returns(fixture("ws_sr_constancia_inscripcion/get_persona/failure"))
+      r = ws.get_persona "20294834489"
+      assert_hash_includes r[:error_regimen_general],
+                           error: "El contribuyente cuenta con impuestos con baja de oficio por Decreto 1299/98",
+                           mensaje: "No cumple con las condiciones para enviar datos del regimen general"
+    end
+
+    def test_cuando_no_existe_la_persona
+      savon.expects(:get_persona)
+        .with(message: auth_message.merge(id_persona: "123"))
+        .returns(fixture("ws_sr_constancia_inscripcion/get_persona/fault"))
+      error = assert_raises(ServerError) { ws.get_persona "123" }
+      assert_match(/No existe persona con ese Id/, error.message)
+    end
+
+    def test_autenticacion_deberia_autenticarse_usando_el_wsaa
+      FileUtils.rm_rf Dir.glob("tmp/*-test-*-ta.dump")
+      wss = WSConstanciaInscripcion.new(cuit: "1", cert: "cert", key: "key")
+      assert_equal "cert", wss.wsaa.cert
+      assert_equal "key", wss.wsaa.key
+      assert_equal "ws_sr_constancia_inscripcion", wss.wsaa.service
+      wss.wsaa.expects(:login).returns(token: "t", sign: "s")
+      savon.expects(:get_persona).with(message: has_path(
+        "//token" => "t", "//sign" => "s", "//cuitRepresentada" => "1"
+      )).returns(fixture("ws_sr_constancia_inscripcion/get_persona/success"))
+      wss.get_persona "20294834487"
+    end
+
+    def test_entorno_development
+      Client.expects(:new).with { |opts| opts[:wsdl] == WSAA::WSDL[:development] }.returns(stub(operations: []))
+      Client.expects(:new).with do |opts|
+        opts[:wsdl] == WSConstanciaInscripcion::WSDL[:development] && opts[:soap_version] == 1
+      end.returns(stub(operations: []))
+      WSConstanciaInscripcion.new(cuit: "1", env: :development)
+    end
+
+    def test_entorno_production
+      Client.expects(:new).with { |opts| opts[:wsdl] == WSAA::WSDL[:production] }.returns(stub(operations: []))
+      Client.expects(:new).with do |opts|
+        opts[:wsdl] == WSConstanciaInscripcion::WSDL[:production] && opts[:soap_version] == 1
+      end.returns(stub(operations: []))
+      WSConstanciaInscripcion.new(cuit: "1", env: :production)
+    end
+  end
+end

data/test/arca/wsaa_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Arca
+  class WSAATest < TestCase
+    def subject
+      @subject ||= WSAA.new(wsdl: Arca::WSFE::WSDL[:test])
+    end
+
+    def test_generar_tra_genera_xml
+      Time.stubs(:now).returns Time.new(2001, 12, 31, 12, 0, 0, "-03:00")
+      xml = subject.generar_tra "wsfe", 2400
+      assert_xpath xml, "/loginTicketRequest/header/uniqueId", Time.now.to_i.to_s
+      assert_xpath xml, "/loginTicketRequest/header/generationTime", "2001-12-31T11:20:00-03:00"
+      assert_xpath xml, "/loginTicketRequest/header/expirationTime", "2001-12-31T12:40:00-03:00"
+      assert_xpath xml, "/loginTicketRequest/service", "wsfe"
+    end
+
+    def test_firmar_tra_firma_con_certificado_y_clave
+      key = File.read(File.join(__dir__, "test.key"))
+      crt = File.read(File.join(__dir__, "test.crt"))
+      tra = subject.generar_tra "wsfe", 2400
+      assert_match(/BEGIN PKCS7/, subject.firmar_tra(tra, key, crt).to_s)
+    end
+
+    def test_login_manda_tra_al_ws_y_obtiene_ta
+      ws = WSAA.new key: "key", cert: "cert", wsdl: Arca::WSFE::WSDL[:test]
+      ws.expects(:tra).with("key", "cert", "wsfe", 2400).returns("tra")
+      savon.expects(:login_cms).with(message: { in0: "tra" }).returns(fixture("wsaa/login_cms/success"))
+      ta = ws.login
+      assert_equal "PD94=", ta[:token]
+      assert_equal "i9xDN=", ta[:sign]
+      assert_equal Time.new(2011, 1, 12, 18, 57, 4, "-03:00"), ta[:generation_time]
+      assert_equal Time.new(2011, 1, 13, 6, 57, 4, "-03:00"), ta[:expiration_time]
+    end
+
+    def test_auth_devuelve_hash_con_token_y_sign
+      FileUtils.rm_rf Dir.glob("tmp/*-test-*-ta.dump")
+      FileUtils.rm_rf Dir.glob("tmp/*-test-*-ta.json")
+      Time.stubs(:now).returns(Time.local(2010, 1, 1))
+
+      ws = WSAA.new(wsdl: Arca::WSFE::WSDL[:test])
+      ws.expects(:login).once.returns(token: "token", sign: "sign", expiration_time: Time.now + 60)
+      assert_equal({ token: "token", sign: "sign" }, ws.auth)
+    end
+
+    def test_auth_cachea_ta_en_instancia_y_disco
+      FileUtils.rm_rf Dir.glob("tmp/*-test-*-ta.dump")
+      FileUtils.rm_rf Dir.glob("tmp/*-test-*-ta.json")
+      Time.stubs(:now).returns(Time.local(2010, 1, 1))
+
+      ws = WSAA.new(wsdl: Arca::WSFE::WSDL[:test])
+      ta = { token: "token", sign: "sign", generation_time: Time.now, expiration_time: Time.now + 60 }
+      ws.expects(:login).once.returns(ta)
+      ws.auth
+      ws.auth
+      assert_same ta, ws.ta
+
+      ws2 = WSAA.new(wsdl: Arca::WSFE::WSDL[:test])
+      ws2.auth
+      assert_equal ta[:token], ws2.ta[:token]
+      assert_equal ta[:sign], ws2.ta[:sign]
+    end
+
+    def test_si_ta_expiro_ejecuta_solicitar_nuevo
+      FileUtils.rm_rf Dir.glob("tmp/*-test-*-ta.dump")
+      FileUtils.rm_rf Dir.glob("tmp/*-test-*-ta.json")
+      Time.stubs(:now).returns(Time.local(2010, 1, 1))
+
+      subject.expects(:login).twice
+        .returns(token: "t1", expiration_time: Time.now - 2)
+        .then.returns(token: "t2")
+      subject.auth
+      assert_equal "t1", subject.ta[:token]
+      subject.auth
+      assert_equal "t2", subject.ta[:token]
+    end
+  end
+end