kono_epp_client 0.0.3 → 0.1.1

data/lib/epp/server.rb

@@ -5,7 +5,9 @@ module KonoEppClient #:nodoc:
 
     require 'nokogiri'
 
-    attr_accessor :tag, :password, :server, :port, :old_server, :services, :lang, :extensions, :version, :credit, :timeout
+    attr_accessor :tag, :password, :server, :port, :ssl_version, :old_server,
+                  :services, :lang, :extensions, :version, :credit, :timeout,
+                  :transport, :transport_options
 
     # ==== Required Attrbiutes
     #
@@ -22,22 +24,30 @@ module KonoEppClient #:nodoc:
     # * <tt>:services</tt> - Use custom EPP services in the <login> frame. The defaults use the EPP standard domain, contact and host 1.0 services.
     # * <tt>:extensions</tt> - URLs to custom extensions to standard EPP. Use these to extend the standard EPP (e.g., Nominet uses extensions). Defaults to none.
     # * <tt>:version</tt> - Set the EPP version. Defaults to "1.0".
+    # * <tt>:transport</tt> - Type of connection (http or tcp). Default to "tcp"
+    # * <tt>:transport_options</tt> - Overrides for transport configurations. Default to {}
+    # * <tt>:timeout</tt> - Timeou for connections in seconds. Default to "30"
+    # * <tt>:ssl_version</tt> - Version of the ssl protocol versione. Default to TLSv1
+    # * <tt>:ssl_version</tt> - Version of the ssl protocol versione. Default to TLSv1
+    #
     def initialize(attributes = {})
       requires!(attributes, :tag, :password, :server)
 
-      @tag        = attributes[:tag]
-      @password   = attributes[:password]
-      @server     = attributes[:server]
-      @port       = attributes[:port]       || 700
+      @tag = attributes[:tag]
+      @password = attributes[:password]
+      @server = attributes[:server]
+      @port = attributes[:port] || 700
       @old_server = attributes[:old_server] || false
-      @lang       = attributes[:lang]       || "en"
-      @services   = attributes[:services]   || ["urn:ietf:params:xml:ns:domain-1.0", "urn:ietf:params:xml:ns:contact-1.0", "urn:ietf:params:xml:ns:host-1.0"]
+      @lang = attributes[:lang] || "en"
+      @services = attributes[:services] || ["urn:ietf:params:xml:ns:domain-1.0", "urn:ietf:params:xml:ns:contact-1.0", "urn:ietf:params:xml:ns:host-1.0"]
       @extensions = attributes[:extensions] || []
-      @version    = attributes[:version]    || "1.0"
-      @transport  = attributes[:transport]  || :tcp
-      @timeout    = attributes[:timeout]    || 30
+      @version = attributes[:version] || "1.0"
+      @transport = attributes[:transport] || :tcp
+      @transport_options = attributes[:transport_options] || {}
+      @timeout = attributes[:timeout] || 30
+      @ssl_version = attributes[:ssl_version] || :TLSv1
 
-      @logged_in  = false
+      @logged_in = false
     end
 
     def connect_and_hello
@@ -55,13 +65,13 @@ module KonoEppClient #:nodoc:
     # <tt><login></tt> and <tt><logout></tt> requests are also wrapped
     # around the request, so we can close the socket immediately after
     # the request is made.
-    def request( xml )
+    def request(xml)
       # open_connection
 
       # @logged_in = true if login
 
       begin
-        @response = send_request( xml )
+        @response = send_request(xml)
       ensure
         if @logged_in && !old_server
           @logged_in = false if logout
@@ -73,7 +83,7 @@ module KonoEppClient #:nodoc:
 
     # Sends a standard login request to the EPP server.
     def login
-      login = KonoEppLogin.new( tag, password )
+      login = KonoEppLogin.new(tag, password)
 
       # FIXME: Order matters
       login.version = version
@@ -82,11 +92,11 @@ module KonoEppClient #:nodoc:
       login.services = services
       login.extensions = extensions
 
-      send_command( login )
+      send_command(login)
     end
 
-    def change_password( new_password )
-      login = KonoEppLogin.new( tag, password )
+    def change_password(new_password)
+      login = KonoEppLogin.new(tag, password)
 
       # FIXME: Order matters
       login.new_password = new_password
@@ -97,7 +107,7 @@ module KonoEppClient #:nodoc:
       login.services = services
       login.extensions = extensions
 
-      send_command( login )
+      send_command(login)
     end
 
     def logged_in?
@@ -112,144 +122,166 @@ module KonoEppClient #:nodoc:
 
     # FIXME: Remove command wrappers?
     def hello
-      response = Hpricot.XML( send_request( KonoEppHello.new.to_s ) )
+      send_request(KonoEppHello.new.to_s)
     end
 
-    def poll( id = nil )
-      poll = KonoEppPoll.new( id ? :ack : :req )
+    def poll(id = nil)
+      poll = KonoEppPoll.new(id ? :ack : :req)
 
       poll.ack_id = id if id
 
-      send_command( poll )
+      send_command(poll)
     end
 
-    def create_contact( options )
+    def create_contact(options)
       contact = KonoEppCreateContact.new options
-      send_command( contact )
+      send_command(contact)
+    end
+
+    def check_contacts(ids)
+      send_command(KonoEppCheckContacts.new(ids))
     end
 
-    def delete_contact( id )
+    def delete_contact(id)
       contact = KonoEppDeleteContact.new id
-      send_command( contact )
+      send_command(contact)
     end
 
-    def update_contact( options )
+    def update_contact(options)
       contact = KonoEppUpdateContact.new options
-      send_command( contact )
+      send_command(contact)
     end
 
-    def create_domain( options )
+    def create_domain(options)
       domain = KonoEppCreateDomain.new options
-      send_command( domain )
+      send_command(domain)
     end
 
-    def update_domain( options )
+    def check_domains(*domains)
+      send_command(KonoEppCheckDomains.new *domains)
+    end
+
+    def update_domain(options)
       domain = KonoEppUpdateDomain.new options
-      send_command( domain )
+      send_command(domain)
     end
 
-    def delete_domain( name )
+    def delete_domain(name)
       domain = KonoEppDeleteDomain.new name
-      send_command( domain )
+      send_command(domain)
     end
 
-    def info_contact( id )
+    def info_contact(id)
       contact = KonoEppInfoContact.new id
-      send_command( contact )
+      send_command(contact)
     end
 
-    def info_domain( name )
+    def info_domain(name)
       info = KonoEppInfoDomain.new name
-      send_command( info )
+      send_command(info)
     end
 
-    def transfer_domain( name, authinfo, op )
-      transfer = KonoEppTransferDomain.new name, authinfo, op
-      send_command( transfer )
+    def transfer_domain(name, authinfo, op, extension: nil)
+      send_command(KonoEppTransferDomain.new(name, authinfo, op, extension: extension))
     end
 
     # Sends a standard logout request to the EPP server.
     def logout
-      send_command( KonoEppLogout.new, 1500 )
+      send_command(KonoEppLogout.new, 1500)
     end
 
-# private
+    # private
     # Wrapper which sends XML to the server, and receives
     # the response in return.
-    def send_request( xml )
-      write( xml )
+    def send_request(xml)
+      write(xml)
       read
     end
 
-    def send_command( command, expected_result = 1000..1999 )
-      namespaces = { 'extepp' => 'http://www.nic.it/ITNIC-EPP/extepp-2.0',
-                     'xmlns' => "urn:ietf:params:xml:ns:epp-1.0" }
+    def send_command(command, expected_result = 1000..1999)
+      namespaces = {'extepp' => 'http://www.nic.it/ITNIC-EPP/extepp-2.0',
+                    'xmlns' => "urn:ietf:params:xml:ns:epp-1.0"}
 
-      xml = Nokogiri.XML( send_request( command.to_s ) )
+      xml = Nokogiri.XML(send_request(command.to_s))
 
       # TODO: multiple <response> RFC 3730 §2.6
-      result = xml.at_xpath( "/xmlns:epp/xmlns:response[1]/xmlns:result",
-                             namespaces )
-      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if result.nil?
+      result = xml.at_xpath("/xmlns:epp/xmlns:response[1]/xmlns:result",
+                            namespaces)
+      raise KonoEppErrorResponse.new(:message => 'Malformed response') if result.nil?
 
-      xmlns_code = result.at_xpath( "@code" )
-      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if xmlns_code.nil?
+      xmlns_code = result.at_xpath("@code")
+      raise KonoEppErrorResponse.new(:message => 'Malformed response') if xmlns_code.nil?
 
       response_code = xmlns_code.value.to_i
 
-      xmlns_msg = result.xpath( "xmlns:msg/text ()",
-                                namespaces )
-      raise KonoEppErrorResponse.new( :message => 'Malformed response' ) if xmlns_msg.empty?
+      xmlns_msg = result.xpath("xmlns:msg/text ()",
+                               namespaces)
+      raise KonoEppErrorResponse.new(:message => 'Malformed response') if xmlns_msg.empty?
 
       result_message = xmlns_msg.text.strip
 
       # TODO: value
 
-      xmlns_ext_reason = result.xpath( "xmlns:extValue/xmlns:reason",
-                                       namespaces)
+      xmlns_ext_reason = result.xpath("xmlns:extValue/xmlns:reason",
+                                      namespaces)
       result_message += ": #{xmlns_ext_reason.text.strip}" unless xmlns_ext_reason.empty?
 
-      xmlns_reason_code = result.xpath( "xmlns:extValue/xmlns:value/extepp:reasonCode",
-                                        namespaces )
+      xmlns_reason_code = result.xpath("xmlns:extValue/xmlns:value/extepp:reasonCode",
+                                       namespaces)
       reason_code = xmlns_reason_code.text.strip.to_i unless xmlns_reason_code.empty?
 
-      credit_msg = xml.xpath( "//extepp:credit/text ()",
-                              namespaces )
+      credit_msg = xml.xpath("//extepp:credit/text ()",
+                             namespaces)
       @credit = credit_msg.text.to_f unless credit_msg.empty?
 
       if expected_result === response_code
         return xml
       end
 
-      args = { :xml           => xml,
-               :response_code => response_code,
-               :reason_code   => reason_code,
-               :message       => result_message }
-
-      case [ response_code, reason_code ]
-        when [2200, 6004]
-          raise KonoEppAuthenticationPasswordExpired.new( args )
-        when [2002, 4015]
-          raise KonoEppLoginNeeded.new( args )
-        else
-          raise KonoEppErrorResponse.new( args )
+      args = {:xml => xml,
+              :response_code => response_code,
+              :reason_code => reason_code,
+              :message => result_message}
+
+      case [response_code, reason_code]
+      when [2200, 6004]
+        raise KonoEppAuthenticationPasswordExpired.new(args)
+      when [2002, 4015]
+        raise KonoEppLoginNeeded.new(args)
+      when [2304, 9022]
+        raise KonoEppDomainHasStatusCliTransProhibited.new(args)
+      when [2304, 9026]
+        raise KonoEppDomainHasStatusClientUpdateProhibited.new(args)
+      else
+        raise KonoEppErrorResponse.new(args)
       end
     end
 
     # Establishes the connection to the server. If the connection is
-		# established, then this method will call read and return
-		# the EPP <tt><greeting></tt> which is sent by the
-		# server upon connection.
+    # established, then this method will call read and return
+    # the EPP <tt><greeting></tt> which is sent by the
+    # server upon connection.
     def open_connection
+      # FIXME il timeout serve solamente nella versione tcp
+      # FIXME perchè utilizzare un'istanza di classe? non sarebbe meglio avere un metodo che genera il transport
+      #       e successivamente viene utilizzato sempre quello?
       Timeout.timeout @timeout do
-        @connection = case @transport
-          when :tcp then KonoEppClient::Transport::TcpTransport.new( server, port )
-          when :http then KonoEppClient::Transport::HttpTransport.new( server, port )
+        case @transport
+        when :tcp
+          @connection = KonoEppClient::Transport::TcpTransport.new(server, port)
+        when :http
+
+          options = {
+            ssl_version: ssl_version,
+            cookie_file: "#{@tag.downcase}.cookies.pstore"
+          }.merge(@transport_options)
+
+          @connection = KonoEppClient::Transport::HttpTransport.new(server, port, **options)
+
         end
       end
     end
 
-
     # Receive an EPP response from the server. Since the connection is blocking,
     # this method will wait until the connection becomes available for use. If
     # the connection is broken, a SocketError will be raised. Otherwise,
@@ -262,9 +294,9 @@ module KonoEppClient #:nodoc:
 
     # Send XML to the server. If the socket returns EOF,
     # the connection has closed and a SocketError is raised.
-    def write( xml )
+    def write(xml)
       Timeout.timeout @timeout do
-        @connection.write( xml )
+        @connection.write(xml)
       end
     end
   end

data/lib/epp/transport/http.rb

@@ -6,20 +6,24 @@ module KonoEppClient::Transport
 
     require 'pstore'
 
-    def initialize( server, port )
+    # @param [String] server
+    # @param [Integer] port
+    # @param [Symbol] ssl_version -> Versione ssl
+    # @param [String] cookie_file -> identifica il nome del file del cookie-store
+    def initialize(server, port, ssl_version: :TLSv1, cookie_file: "cookies.pstore")
       @net_http = Net::HTTP.new( server, port )
 
       @net_http.use_ssl = true
-      @net_http.ssl_version = :TLSv1
+      @net_http.ssl_version = ssl_version
       @net_http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      
+
       #FIXME: Commented because not work on MacOS (dev machine), is necessary for Linux machine?
       #@net_http.ca_path = '/etc/ssl/certs' 
-      
+
       # @net_http.set_debug_output $stderr
        #@net_http.set_debug_output File.open( "/tmp/net.log", "a")
 
-      @store = PStore.new( "cookies.pstore" )
+      @store = PStore.new( cookie_file )
     end
 
     def read
@@ -43,6 +47,7 @@ module KonoEppClient::Transport
     end
 
     def close
+      FileUtils.rm_rf(@store.path)
     end
 
   private

data/lib/kono_epp_client/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/kono_epp_client/version.rb

@@ -0,0 +1,3 @@
+module KonoEppClient
+  VERSION = File.read(File.join(File.dirname(__FILE__), "./VERSION")).strip
+end

data/lib/kono_epp_client.rb

@@ -4,7 +4,6 @@ require 'openssl'
 require 'socket'
 require 'active_support'
 require 'rexml/document'
-require 'hpricot'
 
 # Package files
 require File.dirname(__FILE__) + '/require_parameters.rb'
@@ -16,19 +15,11 @@ require File.dirname(__FILE__) + '/epp/transport/tcp.rb'
 require File.dirname(__FILE__) + '/epp/transport/http.rb'
 
 require File.dirname(__FILE__) + '/epp/epp_command.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/hello.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/login.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/logout.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/poll.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/create_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/create_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/info_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/info_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/delete_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/delete_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/transfer_domain.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/update_contact.rb'
-require File.dirname(__FILE__) + '/epp/epp_command/update_domain.rb'
+
+# load di tutti i comandi presenti in epp_command
+Dir.glob(File.dirname(__FILE__) + '/epp/epp_command/*.rb').each do |f|
+  require f
+end
 
 module KonoEppClient #:nodoc:
 end

data/spec/epp/epp_command/kono_epp_check_contacts_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+RSpec.describe KonoEppCheckContacts do
+
+  let(:ids){
+    ["mm001",
+     "mb001",
+     "cl001",
+     "bb001"]
+  }
+
+  include_context "like epp command"
+
+  let(:instance) {
+    described_class.new(ids)
+  }
+
+  it "construct", snapshot: 'xml' do
+    expect(rendered.to_s).to have_tag("epp>command>check>check") do
+      ids.each do |t|
+        with_tag("id", text: t)
+      end
+    end
+  end
+
+end

data/spec/epp/epp_command/kono_epp_check_domains_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppCheckDomains do
+  include_context "like epp command"
+
+  let(:instance) do
+    described_class.new("test.it","wow.it")
+  end
+
+  it "construct", snapshot: "xml" do
+    expect(rendered.to_s).to have_tag("epp>command>check>check") do
+        with_tag("name", text: "test.it")
+        with_tag("name", text: "wow.it")
+    end
+  end
+end

data/spec/epp/epp_command/kono_epp_create_domain_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppCreateDomain do
+  include_context "like epp command"
+
+  let(:instance) {
+    KonoEppCreateDomain.new(
+      {name: 'architest.it',
+       period: 1,
+       nameservers:
+         [["ns.test.it", "192.168.100.10"],
+          ["ns2.test.it", "192.168.100.20"],
+          ["ns3.foo.com"]],
+       # contacts
+       registrant: "RRR12",
+       admin: "AAAA12",
+       tech: "TTT12",
+       authinfo: "WWW-test-it"
+      }
+    )
+  }
+
+  it "create", snapshot: "xml" do
+    expect(rendered.to_s).to have_tag("ns")
+    expect(rendered.to_s.downcase).to have_tag("hostattr")
+    expect(rendered.to_s.downcase).to have_tag("ns hostattr" ) do
+      with_tag("hostname",text:"ns2.test.it")
+      with_tag("hostaddr",text:"192.168.100.20",with:{ip:"v4"})
+    end
+    expect(rendered.to_s.downcase).to have_tag("ns hostattr" ) do
+      with_tag("hostname",text:"ns.test.it")
+      with_tag("hostaddr",text:"192.168.100.10",with:{ip:"v4"})
+    end
+    expect(rendered.to_s.downcase).not_to have_tag("ns hostaddr", with: {ip: 'v4'},text:"" )
+  end
+
+end

data/spec/epp/epp_command/kono_epp_transfer_domain_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppTransferDomain do
+
+  include_context "like epp command"
+
+  let(:instance) do
+    described_class.new("test.it", "wee-12-sd", 'request')
+  end
+
+  it "construct", snapshot: 'xml' do
+    expect(rendered.to_s).to have_tag("epp>command>transfer", with: {op: "request"}, count: 1) do
+      with_tag("transfer>name", text: "test.it")
+      with_tag("transfer>authinfo>pw", text: "wee-12-sd")
+    end
+  end
+
+  context "con extension" do
+
+    let(:instance) do
+      described_class.new("test.it", "wee-12-sd", 'request',
+                          extension: {new_registrant: "xx123fd", new_auth_info: "abc-sd934-sd"})
+    end
+
+    it "construct", snapshot: 'xml' do
+      expect(rendered.to_s).to have_tag("epp>command>extension>trade>transfertrade") do
+        with_tag("newregistrant", text: "xx123fd")
+        with_tag("newauthinfo>pw", text: "abc-sd934-sd")
+      end
+    end
+  end
+
+end

data/spec/epp/epp_command/kono_epp_update_domain_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppUpdateDomain do
+
+  let(:options) do
+    {
+      name: 'example.com',
+      # add_nameservers: [['ns1.example.com', '192.168.1.1']],
+      # add_admin: 'admin_contact',
+      # add_tech: 'tech_contact',
+      # remove_nameservers: ['ns2.example.com'],
+      # remove_admin: 'admin_contact_to_remove',
+      # remove_tech: 'tech_contact_to_remove',
+      # auth_info: 'my_auth_info',
+      # registrant: 'new_registrant'
+    }
+  end
+
+  include_context "like epp command"
+
+  let(:instance) {
+    KonoEppUpdateDomain.new(options)
+  }
+
+  it "contiene il nome del dominio" do
+    expect(rendered.to_s).to have_tag("update>name", text: options[:name])
+  end
+
+  context "update nameservers" do
+    let(:options) {
+      super().merge({
+                      add_nameservers: [
+                        ['ns1.example.com', '192.168.1.1'],
+                        ['ns3.example.com']
+                      ],
+                      remove_nameservers: ['ns2.example.com'],
+                    })
+    }
+    it "aggiunge e rimuove ns", snapshot: 'xml' do
+      expect(rendered.to_s.downcase).to have_tag("update>add>ns") do
+        with_tag("hostattr") do
+          with_tag("hostname", text: 'ns1.example.com')
+          with_tag("hostaddr", text: '192.168.1.1')
+        end
+      end
+      expect(rendered.to_s.downcase).to have_tag("update>add>ns") do
+        with_tag("hostattr") do
+          with_tag("hostname", text: 'ns3.example.com')
+          without_tag("hostaddr",text:"")
+        end
+      end
+      expect(rendered.to_s.downcase).to have_tag("update>rem>ns") do
+        with_tag("hostattr") do
+          with_tag("hostname", text: 'ns2.example.com')
+        end
+      end
+    end
+  end
+
+  context "update contacts", snapshot: 'xml' do
+    let(:options) {
+      super().merge({
+                      add_admin: "AAA1",
+                      add_tech: "TTT1",
+                      remove_admin: "AAA2",
+                      remove_tech: "TTT2"
+                    })
+    }
+    it "cambia ADMIN_TECH", snapshot: 'xml' do
+      expect(rendered.to_s.downcase).to have_tag("update>add>contact", with: {type: "admin"}, text: options[:add_admin].downcase)
+      expect(rendered.to_s.downcase).to have_tag("update>rem>contact", with: {type: "admin"}, text: options[:remove_admin].downcase)
+      expect(rendered.to_s.downcase).to have_tag("update>add>contact", with: {type: "tech"}, text: options[:add_tech].downcase)
+      expect(rendered.to_s.downcase).to have_tag("update>rem>contact", with: {type: "tech"}, text: options[:remove_tech].downcase)
+    end
+  end
+  context "update status" do
+    let(:options) {
+      super().merge({
+                      add_status: "clientTransferProhibited",
+                      remove_status: "clientHold",
+                    })
+    }
+    it "cambia status", snapshot: 'xml' do
+      expect(rendered.to_s.downcase).to have_tag("update>add>status", with: {s: options[:add_status].downcase})
+      expect(rendered.to_s.downcase).to have_tag("update>rem>status", with: {s: options[:remove_status].downcase})
+    end
+  end
+
+  context "restore" do
+    let(:options) {
+      super().merge({
+                      restore: true
+                    })
+    }
+    it "esiste l'estensione di restore",snapshot: 'xml' do
+      expect(rendered.to_s.downcase).to have_tag("extension>update>restore", with: {op: "request"})
+    end
+  end
+
+  context "update auth_info" do
+    let(:options) {
+      super().merge({
+                      auth_info: "AUTH12-!DSRTG"
+                    })
+    }
+    it "cambia AUTH_INFO", snapshot: "xml" do
+      expect(rendered.to_s.downcase).to have_tag("update>chg") do
+        with_tag("authinfo>pw", text: options[:auth_info].downcase)
+        without_tag("registrant")
+      end
+    end
+
+    context "con nuovo registrant" do
+      let(:options) {
+        super().merge({
+                        registrant: "R0001"
+                      })
+      }
+      it "cambia REGISTRANT", snapshot: "xml" do
+        expect(rendered.to_s.downcase).to have_tag("update>chg>registrant", text: options[:registrant].downcase)
+      end
+    end
+  end
+
+end