afipws 1.0.3 → 1.0.4

data/lib/afipws/wsfe.rb

@@ -1,68 +1,69 @@
 module Afipws
-  class WSFE
-    extend Forwardable
+  class WSFE < WSBase
     include TypeConversions
-    attr_reader :wsaa, :client, :env
-    def_delegators :wsaa, :ta, :auth, :cuit
 
     WSDL = {
-      development: "https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL",
-      # production: "https://servicios1.afip.gov.ar/wsfev1/service.asmx?WSDL",
-      production: Root + "/lib/afipws/wsfev1.wsdl",
-      test: Root + "/spec/fixtures/wsfe.wsdl"
-    }
+      development: 'https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL',
+      # production: 'https://servicios1.afip.gov.ar/wsfev1/service.asmx?WSDL',
+      production: Root + '/lib/afipws/wsdl/wsfev1.wsdl',
+      test: Root + '/spec/fixtures/wsfe.wsdl'
+    }.freeze
 
     def initialize options = {}
-      @env = (options[:env] || :test).to_sym
-      @wsaa = options[:wsaa] || WSAA.new(options.merge(service: 'wsfe'))
-      @client = Client.new Hash(options[:savon]).reverse_merge(wsdl: WSDL[@env], ssl_version: :TLSv1, convert_request_keys_to: :camelcase)
+      super
+      @wsaa = WSAA.new options.merge(service: 'wsfe')
+      @client = Client.new Hash(options[:savon]).reverse_merge(wsdl: WSDL[env], convert_request_keys_to: :camelcase)
     end
 
     def dummy
-      @client.fe_dummy
+      request :fe_dummy
     end
 
     def tipos_comprobantes
-      r = @client.fe_param_get_tipos_cbte auth
+      r = request :fe_param_get_tipos_cbte, auth
       x2r get_array(r, :cbte_tipo), id: :integer, fch_desde: :date, fch_hasta: :date
     end
 
     def tipos_documentos
-      r = @client.fe_param_get_tipos_doc auth
+      r = request :fe_param_get_tipos_doc, auth
       x2r get_array(r, :doc_tipo), id: :integer, fch_desde: :date, fch_hasta: :date
     end
 
     def tipos_monedas
-      r = @client.fe_param_get_tipos_monedas auth
+      r = request :fe_param_get_tipos_monedas, auth
       x2r get_array(r, :moneda), fch_desde: :date, fch_hasta: :date
     end
 
     def tipos_iva
-      r = @client.fe_param_get_tipos_iva auth
+      r = request :fe_param_get_tipos_iva, auth
       x2r get_array(r, :iva_tipo), id: :integer, fch_desde: :date, fch_hasta: :date
     end
 
     def tipos_tributos
-      r = @client.fe_param_get_tipos_tributos auth
+      r = request :fe_param_get_tipos_tributos, auth
       x2r get_array(r, :tributo_tipo), id: :integer, fch_desde: :date, fch_hasta: :date
     end
 
     def puntos_venta
-      r = @client.fe_param_get_ptos_venta auth
+      r = request :fe_param_get_ptos_venta, auth
       x2r get_array(r, :pto_venta), nro: :integer, fch_baja: :date, bloqueado: :boolean
     end
 
     def cotizacion moneda_id
-      @client.fe_param_get_cotizacion(auth.merge(mon_id: moneda_id))[:result_get][:mon_cotiz].to_f
+      request(:fe_param_get_cotizacion, auth.merge(mon_id: moneda_id))[:result_get][:mon_cotiz].to_f
     end
 
     def autorizar_comprobantes opciones
       comprobantes = opciones[:comprobantes]
-      request = { 'FeCAEReq' => {
-        'FeCabReq' => opciones.select_keys(:cbte_tipo, :pto_vta).merge(cant_reg: comprobantes.size),
-        'FeDetReq' => { 'FECAEDetRequest' => comprobantes.map { |comprobante|  comprobante_to_request comprobante }
-      }}}
-      r = @client.fecae_solicitar auth.merge r2x(request, cbte_fch: :date)
+      mensaje = {
+        'FeCAEReq' => {
+          'FeCabReq' => opciones.select_keys(:cbte_tipo, :pto_vta).merge(cant_reg: comprobantes.size),
+          'FeDetReq' => {
+            'FECAEDetRequest' => comprobantes.map { |comprobante| comprobante_to_request comprobante }
+          }
+        }
+      }
+      r = request :fecae_solicitar, auth.merge(r2x(mensaje, cbte_fch: :date))
       r = Array.wrap(r[:fe_det_resp][:fecae_det_response]).map do |h|
         obs = Array.wrap(h[:observaciones] ? h[:observaciones][:obs] : nil)
         h.select_keys(:cae, :cae_fch_vto, :resultado).merge(cbte_nro: h[:cbte_desde], observaciones: obs)
@@ -78,7 +79,7 @@ module Afipws
     end
 
     def solicitar_caea
-      convertir_rta_caea @client.fecaea_solicitar auth.merge(periodo_para_solicitud_caea)
+      convertir_rta_caea request(:fecaea_solicitar, auth.merge(periodo_para_solicitud_caea))
     rescue Afipws::WSError => e
       if e.errors.any? { |e| e[:code] == '15008' }
         consultar_caea fecha_inicio_quincena_siguiente
@@ -88,18 +89,22 @@ module Afipws
     end
 
     def consultar_caea fecha
-      convertir_rta_caea @client.fecaea_consultar auth.merge(periodo_para_consulta_caea(fecha))
+      convertir_rta_caea request(:fecaea_consultar, auth.merge(periodo_para_consulta_caea(fecha)))
     end
 
     def informar_comprobantes_caea opciones
       comprobantes = opciones[:comprobantes]
-      request = { 'FeCAEARegInfReq' => {
-        'FeCabReq' => opciones.select_keys(:cbte_tipo, :pto_vta).merge(cant_reg: comprobantes.size),
-        'FeDetReq' => { 'FECAEADetRequest' => comprobantes.map do |comprobante|
-            comprobante_to_request comprobante.merge('CAEA' => comprobante.delete(:caea))
-          end
-      }}}
-      r = @client.fecaea_reg_informativo auth.merge r2x(request, cbte_fch: :date)
+      mensaje = {
+        'FeCAEARegInfReq' => {
+          'FeCabReq' => opciones.select_keys(:cbte_tipo, :pto_vta).merge(cant_reg: comprobantes.size),
+          'FeDetReq' => {
+            'FECAEADetRequest' => comprobantes.map do |comprobante|
+              comprobante_to_request comprobante.merge('CAEA' => comprobante.delete(:caea))
+            end
+          }
+        }
+      }
+      r = request :fecaea_reg_informativo, auth.merge(r2x(mensaje, cbte_fch: :date))
       r = Array.wrap(r[:fe_det_resp][:fecaea_det_response]).map do |h|
         obs = Array.wrap(h[:observaciones] ? h[:observaciones][:obs] : nil)
         h.select_keys(:caea, :resultado).merge(cbte_nro: h[:cbte_desde], observaciones: obs)
@@ -108,19 +113,19 @@ module Afipws
     end
 
     def informar_caea_sin_movimientos caea, pto_vta
-      @client.fecaea_sin_movimiento_informar(auth.merge('CAEA' => caea, 'PtoVta' => pto_vta))
+      request :fecaea_sin_movimiento_informar, auth.merge('CAEA' => caea, 'PtoVta' => pto_vta)
     end
 
     def ultimo_comprobante_autorizado opciones
-      @client.fe_comp_ultimo_autorizado(auth.merge(opciones))[:cbte_nro].to_i
+      request(:fe_comp_ultimo_autorizado, auth.merge(opciones))[:cbte_nro].to_i
     end
 
     def consultar_comprobante opciones
-      @client.fe_comp_consultar(auth.merge(fe_comp_cons_req: opciones))[:result_get]
+      request(:fe_comp_consultar, auth.merge(fe_comp_cons_req: opciones))[:result_get]
     end
 
     def cant_max_registros_x_lote
-      @client.fe_comp_tot_x_request(auth)[:reg_x_req].to_i
+      request(:fe_comp_tot_x_request, auth)[:reg_x_req].to_i
     end
 
     def periodo_para_solicitud_caea
@@ -137,7 +142,21 @@ module Afipws
       hoy.day <= 15 ? hoy.change(day: 16) : hoy.next_month.change(day: 1)
     end
 
+    def auth
+      {auth: wsaa.auth.merge(cuit: cuit)}
+    end
+
     private
+
+    def request action, body = nil
+      response = @client.request(action, body).to_hash[:"#{action}_response"][:"#{action}_result"]
+      if response[:errors]
+        raise WSError, Array.wrap(response[:errors][:err])
+      else
+        response
+      end
+    end
+
     def get_array response, array_element
       Array.wrap response[:result_get][array_element]
     end

data/spec/afipws/core_ext/hash_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Hash do
-  context "select_keys" do
-    it "debería tomar los values de las keys indicadas" do
+  context 'select_keys' do
+    it 'debería tomar los values de las keys indicadas' do
       hash = Hash[1, 2, 3, 4]
       hash.select_keys(1).should == {1 => 2}
       hash.select_keys(1, 3).should == {1 => 2, 3 => 4}
@@ -10,11 +10,11 @@ describe Hash do
       hash.select_keys(5, 3).should == {3 => 4}
     end
   end
-  
-  context "has_entries?" do
+
+  context 'has_entries?' do
     subject { Hash[1, 2, 3, 4] }
-    
-    it "debería devolver true cuando self incluye todas las entries del hash parametro" do
+
+    it 'debería devolver true cuando self incluye todas las entries del hash parametro' do
       should have_entries 1 => 2
       should have_entries 3 => 4, 1 => 2
       should_not have_entries 1 => 3

data/spec/afipws/type_conversions_spec.rb

@@ -1,29 +1,28 @@
-# coding: utf-8
 require 'spec_helper'
 
 describe Afipws::TypeConversions do
   include Afipws::TypeConversions
-  
-  context "r2x" do
-    it "debería convertir values de hashes a xml types" do
-      r2x({fecha: Date.new(2011, 1, 2), :id => 1}, fecha: :date).should == {fecha: '20110102', id: 1}
+
+  context 'r2x' do
+    it 'debería convertir values de hashes a xml types' do
+      r2x({fecha: Date.new(2011, 1, 2), id: 1}, fecha: :date).should == {fecha: '20110102', id: 1}
       r2x({container: {fecha: Date.new(2011, 1, 2)}}, fecha: :date).should == {container: {fecha: '20110102'}}
     end
 
-    it "debería convertir values de hashes aunque estén en arrays" do
+    it 'debería convertir values de hashes aunque estén en arrays' do
       r2x([{fecha: Date.new(2011, 1, 2)}], fecha: :date).should == [{fecha: '20110102'}]
       r2x({container: [{fecha: Date.new(2011, 1, 2)}, {fecha: Date.new(2011, 1, 3)}]}, fecha: :date).should == {container: [{fecha: '20110102'}, {fecha: '20110103'}]}
     end
   end
-  
-  context "x2r" do
-    it "deberia convertir values de hashes de xml types a ruby" do
+
+  context 'x2r' do
+    it 'deberia convertir values de hashes de xml types a ruby' do
       x2r({fecha: '20110102', id: '1', total: '1.23', obs: 'algo'}, fecha: :date, id: :integer, total: :float)
-        .should == {fecha: Date.new(2011,1,2), id: 1, total: 1.23, obs: 'algo'}
+        .should == {fecha: Date.new(2011, 1, 2), id: 1, total: 1.23, obs: 'algo'}
       x2r({container: {id: '1'}}, id: :integer).should == {container: {id: 1}}
     end
-    
-    it "debería hacer la conversión en arrays también" do
+
+    it 'debería hacer la conversión en arrays también' do
       x2r({container: [{id: '1'}, {id: '2'}]}, id: :integer).should == {container: [{id: 1}, {id: 2}]}
     end
   end

data/spec/afipws/ws_constancia_inscripcion_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Afipws
+  describe WSConstanciaInscripcion do
+    let(:ta) { {token: 't', sign: 's'} }
+    let(:ws) { WSConstanciaInscripcion.new(cuit: '1').tap { |ws| ws.wsaa.stubs auth: ta } }
+    let(:auth) { ta.merge(cuit_representada: '1') }
+
+    context 'métodos API' do
+      it 'dummy' do
+        savon.expects(:dummy).returns(fixture('constancia_inscripcion_dummy/success'))
+        ws.dummy.should == { appserver: 'OK', dbserver: 'OK', authserver: 'OK' }
+      end
+
+      it 'debería devolver un hash con los datos generales y regímenes impositivos' do
+        savon.expects(:get_persona)
+          .with(message: auth.merge(id_persona: '20294834487'))
+          .returns(fixture('constancia_inscripcion_get_persona/success'))
+        r = ws.get_persona '20294834487'
+        r[:datos_generales].should have_entries(
+          estado_clave: 'ACTIVO', mes_cierre: '6', razon_social: 'LA REGALERIA S A',
+          tipo_clave: 'CUIT', tipo_persona: 'JURIDICA'
+        )
+        r[:datos_generales][:domicilio_fiscal].should have_entries(
+          cod_postal: '2300', descripcion_provincia: 'SANTA FE',
+          direccion: 'AV SIEMPRE VIVA 123', localidad: 'NUEVA YORK', tipo_domicilio: 'FISCAL'
+        )
+        r[:datos_regimen_general][:actividad].should have_entries(
+          id_actividad: '477330', nomenclador: '883', orden: '2', periodo: '201311'
+        )
+        r[:datos_regimen_general][:impuesto][1].should have_entries(
+          descripcion_impuesto: 'IVA', id_impuesto: '30', periodo: '198903'
+        )
+        r[:datos_regimen_general][:regimen].should have_entries(
+          id_impuesto: '208', id_regimen: '159', periodo: '199403'
+        )
+      end
+
+      it 'cuando hay errores en la constancia sigue la misma lógica' do
+        savon.expects(:get_persona).with(message: auth).returns(fixture('constancia_inscripcion_get_persona/failure'))
+        r = ws.get_persona '20294834487'
+        r[:error_regimen_general].should have_entries(
+          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
+    end
+
+    context 'entorno' do
+      it 'debería usar las url para development cuando el env es development' do
+        Client.expects(:new).with(wsdl: 'https://wsaahomo.afip.gov.ar/ws/services/LoginCms?wsdl')
+        Client.expects(:new).with(wsdl: 'https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL', soap_version: 1)
+        wsci = WSConstanciaInscripcion.new env: :development
+        wsci.env.should == :development
+      end
+
+      it 'debería usar las url para production cuando el env es production' do
+        Client.expects(:new).with(wsdl: 'https://wsaa.afip.gov.ar/ws/services/LoginCms?wsdl')
+        Client.expects(:new).with(wsdl: 'https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA5?WSDL', soap_version: 1)
+        wsci = WSConstanciaInscripcion.new env: 'production'
+        wsci.env.should == :production
+      end
+    end
+  end
+end

data/spec/afipws/wsaa_spec.rb

@@ -1,75 +1,83 @@
 require 'spec_helper'
 
-describe Afipws::WSAA do
-  context "generación documento tra" do
-    it "debería generar xml" do
-      Time.stubs(:now).returns Time.new(2001, 12, 31, 12, 0, 0, '-03:00')
-      xml = subject.generar_tra 'wsfe', 2400
-      xml.should match_xpath "/loginTicketRequest/header/uniqueId", Time.now.to_i.to_s
-      xml.should match_xpath "/loginTicketRequest/header/generationTime", "2001-12-31T11:20:00-03:00"
-      xml.should match_xpath "/loginTicketRequest/header/expirationTime", "2001-12-31T12:40:00-03:00"
-      xml.should match_xpath "/loginTicketRequest/service", "wsfe"
+module Afipws
+  describe WSAA do
+    context 'generación documento tra' do
+      it 'debería generar xml' do
+        Time.stubs(:now).returns Time.new(2001, 12, 31, 12, 0, 0, '-03:00')
+        xml = subject.generar_tra 'wsfe', 2400
+        xml.should match_xpath '/loginTicketRequest/header/uniqueId', Time.now.to_i.to_s
+        xml.should match_xpath '/loginTicketRequest/header/generationTime', '2001-12-31T11:20:00-03:00'
+        xml.should match_xpath '/loginTicketRequest/header/expirationTime', '2001-12-31T12:40:00-03:00'
+        xml.should match_xpath '/loginTicketRequest/service', 'wsfe'
+      end
     end
-  end
 
-  context "firmado del tra" do
-    it "debería firmar el tra usando el certificado y la clave privada" do
-      key = File.read(File.dirname(__FILE__) + '/test.key')
-      crt = File.read(File.dirname(__FILE__) + '/test.crt')
-      tra = subject.generar_tra 'wsfe', 2400
-      subject.firmar_tra(tra, key, crt).to_s.should =~ /BEGIN PKCS7/
+    context 'firmado del tra' do
+      it 'debería firmar el tra usando el certificado y la clave privada' do
+        key = File.read(File.dirname(__FILE__) + '/test.key')
+        crt = File.read(File.dirname(__FILE__) + '/test.crt')
+        tra = subject.generar_tra 'wsfe', 2400
+        subject.firmar_tra(tra, key, crt).to_s.should =~ /BEGIN PKCS7/
+      end
     end
-  end
 
-  context "codificación del tra" do
-    it "debería quitarle el header y footer" do
-      subject.codificar_tra(OpenSSL::PKCS7.new).should_not include 'BEGIN', 'END'
+    context 'codificación del tra' do
+      it 'debería quitarle el header y footer' do
+        subject.codificar_tra(OpenSSL::PKCS7.new).should_not include 'BEGIN', 'END'
+      end
     end
-  end
 
-  context "login" do
-    it "debería mandar el TRA al WS y obtener el TA" do
-      ws = Afipws::WSAA.new key: 'key', cert: 'cert'
-      ws.expects(:tra).with('key', 'cert', 'wsfe', 2400).returns('tra')
-      savon.expects(:login_cms).with(message: {in0: 'tra'}).returns(fixture('login_cms/success'))
-      ta = ws.login
-      ta[:token].should == 'PD94='
-      ta[:sign].should == 'i9xDN='
-      ta[:generation_time].should == Time.new(2011, 1, 12, 18, 57, 4, '-03:00')
-      ta[:expiration_time].should == Time.new(2011, 1, 13, 6, 57, 4, '-03:00')
-    end
+    context 'login' do
+      it 'debería mandar el TRA al WS y obtener el TA' do
+        ws = WSAA.new key: 'key', cert: 'cert'
+        ws.expects(:tra).with('key', 'cert', 'wsfe', 2400).returns('tra')
+        savon.expects(:login_cms).with(message: {in0: 'tra'}).returns(fixture('login_cms/success'))
+        ta = ws.login
+        ta[:token].should == 'PD94='
+        ta[:sign].should == 'i9xDN='
+        ta[:generation_time].should == Time.new(2011, 1, 12, 18, 57, 4, '-03:00')
+        ta[:expiration_time].should == Time.new(2011, 1, 13, 6, 57, 4, '-03:00')
+      end
 
-    it "debería encapsular SOAP Faults" do
-      subject.stubs(:tra).returns('')
-      savon.expects(:login_cms).with(message: :any).returns(fixture('login_cms/fault'))
-      lambda { subject.login }.should raise_error Afipws::WSError, /CMS no es valido/
+      it 'debería encapsular SOAP Faults' do
+        subject.stubs(:tra).returns('')
+        savon.expects(:login_cms).with(message: :any).returns(fixture('login_cms/fault'))
+        -> { subject.login }.should raise_error WSError, /CMS no es valido/
+      end
     end
-  end
 
-  context "auth" do
-    before do
-      FileUtils.rm_rf Dir.glob('tmp/*ta.dump')
-      Time.stubs(:now).returns(Time.local(2010, 1, 1))
-    end
+    context 'auth' do
+      before do
+        FileUtils.rm_rf Dir.glob('tmp/*ta.dump')
+        Time.stubs(:now).returns(Time.local(2010, 1, 1))
+      end
 
-    it "debería cachear TA en la instancia y disco" do
-      ws = Afipws::WSAA.new
-      ws.expects(:login).once.returns(ta = {token: 'token', sign: 'sign', expiration_time: Time.now + 60})
-      ws.auth
-      ws.auth
-      ws.ta.should equal ta
+      it 'debería devolver hash con token y sign' do
+        ws = WSAA.new
+        ws.expects(:login).once.returns(token: 'token', sign: 'sign', expiration_time: Time.now + 60)
+        ws.auth.should == {token: 'token', sign: 'sign'}
+      end
 
-      ws = Afipws::WSAA.new
-      ws.auth
-      ws.ta.should == ta
-    end
+      it 'debería cachear TA en la instancia y disco' do
+        ws = WSAA.new
+        ws.expects(:login).once.returns(ta = {token: 'token', sign: 'sign', expiration_time: Time.now + 60})
+        ws.auth
+        ws.auth
+        ws.ta.should equal ta
+
+        ws = WSAA.new
+        ws.auth
+        ws.ta.should == ta
+      end
 
-    it "si el TA expiró debería ejecutar solicitar uno nuevo" do
-      subject.expects(:login).twice.returns(token: 't1', expiration_time: Time.now - 2).then.returns(token: 't2')
-      subject.auth
-      subject.ta[:token].should == 't1'
-      subject.auth
-      subject.ta[:token].should == 't2'
+      it 'si el TA expiró debería ejecutar solicitar uno nuevo' do
+        subject.expects(:login).twice.returns(token: 't1', expiration_time: Time.now - 2).then.returns(token: 't2')
+        subject.auth
+        subject.ta[:token].should == 't1'
+        subject.auth
+        subject.ta[:token].should == 't2'
+      end
     end
   end
 end