epp-nokogiri 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in epp.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) 2009 Josh Delsman (Ultraspeed)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,70 @@
+= EPP v1.3.1 (by {Ultraspeed}[http://ultraspeed.co.uk])
+
+The EPP gem provides basic functionality for connecting and making requests on EPP (Extensible Provisioning Protocol) servers. It has been fully tested against the RFC 5730 & 5734 specification.
+
+Currently, major providers Centralnic and Nominet have been integrated using this gem. CoCCA is currently in testing.
+
+* {Nominet Standard EPP Documentation}[http://www.nominet.org.uk/registrars/systems/standardepp/]
+* {Centralnic Labs EPP Documentation}[http://labs.centralnic.com/epp/]
+
+== Installation
+
+You can install this gem with:
+
+    $ gem install epp
+    
+Then, you can require it in your Ruby/Rails app:
+
+    require "epp"
+    
+If you're using Rails, configure your gem in the following file:
+
+    # Rails 2.x - config/environment.rb
+    config.gem "epp"
+    
+    # Rails 3 - Gemfile
+    gem "epp"
+
+== Example Usage
+
+First, you must initialize an Epp::Server object to use. This requires the EPP server address, tag/username and password:
+
+    server = Epp::Server.new(
+      :server => "testbed-epp.nominet.org.uk",
+      :tag => "TESTING",
+      :password => "testing"
+    )
+    
+If no port is specified, it will be assumed that you will be using port 700.
+
+You would then make an XML request to the server. 
+
+    xml       = "<?xml ... </epp>"
+    response  = server.request(xml)
+  
+You can build this however you'd like, although Nokogiri is already present. The process is as follows:
+
+* Connect to EPP server and receive the <greeting> frame
+* Send a standard <login> request
+* Send your request
+* Send a standard <logout> request
+* Disconnect the socket from the server
+
+The EPP module would then return the XML response as a string. In this example, the response XML would be set equal to <tt>response</tt> for your usage.
+
+Once the request is complete, it will automatically close the connection. For simplicity purposes, this plug-in will *not* use a persistent connection to the EPP server. This may change in future releases, as some registries require that persistent connections be supported. Please feel free to email me to collaborate on making this possible.
+
+== Bugs/Issues
+
+Please report all issues using the GitHub issue tracker at:
+
+http://github.com/ultraspeed/epp/issues
+
+== Credit
+
+Author: Josh Delsman (http://twitter.com/voxxit)
+Inspired from: http://labs.centralnic.com/Net_EPP_Client.php
+
+== License
+
+See the LICENSE file.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+1.4.0

data/epp.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "epp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "epp-nokogiri"
+  s.version     = Epp::VERSION
+  s.authors     = ["Josh Delsman", "Delwyn de Villiers", "Priit Haamer"]
+  s.email       = ["jdelsman@ultraspeed.com", "delwyn.d@gmail.com", "priit@edicy.com"]
+  s.homepage    = "http://github.com/delwyn/epp"
+  s.summary     = %q{EPP (Extensible Provisioning Protocol) for Ruby}
+  s.description = %q{Basic functionality for connecting and making requests on EPP (Extensible Provisioning Protocol) servers}
+
+  s.rubyforge_project = "epp"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency("nokogiri", [">= 1.4.1"])
+  s.add_runtime_dependency("uuidtools", [">= 0"])
+
+  s.add_development_dependency("shoulda", [">= 0"])
+  s.add_development_dependency("mocha", [">= 0"])
+end

data/lib/epp/exceptions.rb

@@ -0,0 +1,18 @@
+class EppErrorResponse < StandardError #:nodoc:
+  include RequiresParameters
+
+  attr_accessor :response_xml, :response_code, :message
+
+  # Generic EPP exception. Accepts a response code and a message
+  def initialize(attributes = {})
+    requires!(attributes, :xml, :code, :message)
+
+    @response_xml   = attributes[:xml]
+    @response_code  = attributes[:code]
+    @message        = attributes[:message]
+  end
+
+  def to_s
+    "#{@message} (code #{@response_code})"
+  end
+end

data/lib/epp/server.rb

@@ -0,0 +1,207 @@
+module Epp #:nodoc:
+  class Server
+    include RequiresParameters
+
+    attr_accessor :tag, :password, :server, :port, :lang, :services, :extensions, :version, :key, :cert
+
+    # ==== Required Attrbiutes
+    #
+    # * <tt>:server</tt> - The EPP server to connect to
+    # * <tt>:tag</tt> - The tag or username used with <tt><login></tt> requests.
+    # * <tt>:password</tt> - The password used with <tt><login></tt> requests.
+    #
+    # ==== Optional Attributes
+    #
+    # * <tt>:port</tt> - The EPP standard port is 700. However, you can choose a different port to use.
+    # * <tt>:lang</tt> - Set custom language attribute. Default is 'en'.
+    # * <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>:cert</tt> - SSL Certificate.
+    # * <tt>:key</tt> - SSL Key.
+    def initialize(attributes = {})
+      requires!(attributes, :tag, :password, :server)
+
+      @tag        = attributes[:tag]
+      @password   = attributes[:password]
+      @server     = attributes[:server]
+      @port       = attributes[:port]       || 700
+      @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"
+      @cert       = attributes[:cert]       || nil
+      @key        = attributes[:key]        || nil
+
+      @logged_in  = false
+    end
+
+    def build_epp_request(&block)
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.epp(
+          'xmlns' => 'urn:ietf:params:xml:ns:epp-1.0',
+          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+          'xsi:schemaLocation' => 'urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd'
+        ) do
+          yield xml if block_given?
+        end
+      end
+    end
+
+    # Sends an XML request to the EPP server, and receives an XML response.
+    # <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)
+      open_connection
+
+      @logged_in = true if login
+
+      begin
+        @response = send_request(xml)
+      ensure
+        @logged_in = false if @logged_in && logout
+
+        close_connection
+      end
+
+      return @response
+    end
+
+    # Wrapper which sends an XML frame to the server, and receives
+    # the response frame in return.
+    def send_request(xml)
+      send_frame(xml)
+      get_frame
+    end
+    
+    # Establishes the connection to the server. If the connection is
+    # established, then this method will call get_frame and return
+    # the EPP <tt><greeting></tt> frame which is sent by the
+    # server upon connection.
+    def open_connection
+      @connection = TCPSocket.new(server, port)
+      @context = OpenSSL::SSL::SSLContext.new
+      @context.cert = @cert
+      @context.key = @key
+
+      @socket = OpenSSL::SSL::SSLSocket.new(@connection, @context) if @connection
+
+      @socket.sync_close = true
+      @socket.connect
+
+      get_frame
+    end
+
+    # Closes the connection to the EPP server.
+    def close_connection
+      @socket.close     if @socket and not @socket.closed?
+      @connection.close if @connection and not @connection.closed?
+
+      @socket = @connection = nil
+
+      return true
+    end
+
+    # Receive an EPP frame 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,
+    # it will return a string containing the XML from the server.
+    def get_frame
+      raise SocketError.new("Connection closed by remote server") if !@socket or @socket.eof?
+
+      header = @socket.read(4)
+
+      raise SocketError.new("Error reading frame from remote server") if header.nil?
+
+      length = header_size(header)
+
+      raise SocketError.new("Got bad frame header length of #{length} bytes from the server") if length < 5
+
+      return @socket.read(length - 4)
+    end
+
+    # Send an XML frame to the server. Should return the total byte
+    # size of the frame sent to the server. If the socket returns EOF,
+    # the connection has closed and a SocketError is raised.
+    def send_frame(xml)
+      @socket.write(packed(xml) + xml)
+    end
+
+    # Pack the XML as a header for the EPP server.
+    def packed(xml)
+      [xml.size + 4].pack("N")
+    end
+
+    # Returns size of header of response from the EPP server.
+    def header_size(header)
+      header.unpack("N").first
+    end
+
+    private
+
+    # Sends a standard login request to the EPP server.
+    def login
+      raise SocketError, "Socket must be opened before logging in" if !@socket or @socket.closed?
+
+      builder = build_epp_request do |xml|
+        xml.command {
+          xml.login {
+            xml.clID tag
+            xml.pw password
+            xml.options {
+              xml.version version
+              xml.lang lang
+            }
+            xml.svcs {
+              xml.objURI "urn:ietf:params:xml:ns:domain-1.0"
+              xml.objURI "urn:ietf:params:xml:ns:contact-1.0"
+              xml.objURI "urn:ietf:params:xml:ns:host-1.0"
+              
+              unless extensions.empty?
+                xml.svcExtension {
+                  for uri in extensions
+                    xml.extURI uri
+                  end
+                }
+              end
+            }
+          }
+          xml.clTRID UUIDTools::UUID.timestamp_create.to_s
+        }
+      end
+
+      response = Nokogiri::XML(send_request(builder.to_xml))
+
+      handle_response(response)
+    end
+
+    # Sends a standard logout request to the EPP server.
+    def logout
+      raise SocketError, "Socket must be opened before logging out" if !@socket or @socket.closed?
+
+      builder = build_epp_request do |xml|
+        xml.command {
+          xml.logout
+          xml.clTRID UUIDTools::UUID.timestamp_create.to_s
+        }
+      end
+
+      response = Nokogiri::XML(send_request(builder.to_xml))
+
+      handle_response(response, 1500)
+    end
+
+    def handle_response(response, acceptable_response = 1000)
+      result_code = response.css('epp response result').first['code'].to_i
+
+      if result_code == acceptable_response
+        return true
+      else
+        result_message = doc.css('epp response result msg').first.text.strip
+
+        raise EppErrorResponse.new(:xml => response, :code => result_code, :message => result_message)
+      end
+    end
+  end
+end

data/lib/epp/version.rb

@@ -0,0 +1,3 @@
+module Epp
+  VERSION = "1.0.0"
+end

data/lib/epp.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/epp/version"
+# require 'rubygems'
+require 'openssl'
+require 'nokogiri'
+require 'uuidtools'
+require 'socket'
+
+# Package files
+require File.dirname(__FILE__) + '/require_parameters.rb'
+require File.dirname(__FILE__) + '/epp/server.rb'
+require File.dirname(__FILE__) + '/epp/exceptions.rb'
+
+module Epp #:nodoc:
+end

data/lib/require_parameters.rb

@@ -0,0 +1,14 @@
+module RequiresParameters #:nodoc:
+  def requires!(hash, *params)
+    params.each do |param|
+      if param.is_a?(Array)
+        raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first)
+
+        valid_options = param[1..-1]
+        raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:connector => 'or')}") unless valid_options.include?(hash[param.first])
+      else
+        raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param)
+      end
+    end
+  end
+end

data/test/test_epp.rb

@@ -0,0 +1,244 @@
+require 'test_helper'
+
+class EppTest < Test::Unit::TestCase
+  context "EPP" do
+    context "server" do
+      setup do
+        @epp = Epp::Server.new(
+          :server => "test-epp.nominet.org.uk",
+          :tag => "TEST",
+          :password => "test"
+        )
+
+        @tcp_sock = mock('TCPSocket')
+        @ssl_sock = mock('OpenSSL::SSL::SSLSocket')
+      end
+
+      should "verify class name is Epp::Server" do
+        assert @epp.is_a?(Epp::Server)
+      end
+
+      should "require server, tag and password attributes" do
+        assert_raises ArgumentError do
+          epp = Epp::Server.new(:tag => "a", :password => "a")
+        end
+
+        assert_raises ArgumentError do
+          epp = Epp::Server.new(:server => "a", :password => "a")
+        end
+
+        assert_raises ArgumentError do
+          epp = Epp::Server.new(:server => "a", :tag => "a")
+        end
+
+        assert_nothing_raised do
+          epp = Epp::Server.new(:server => "a", :tag => "a", :password => "a")
+        end
+      end
+
+      should "set instance variables for attributes" do
+        epp = Epp::Server.new(
+          :tag => "TAG",
+          :password => "f00bar",
+          :server => "nominet-epp.server.org.uk",
+          :port => 8700,
+          :lang => "es",
+          :services => ["urn:ietf:params:xml:ns:domain-nom-ext-1.1.xsd"],
+          :extensions => ["domain-nom-ext-1.1.xsd"],
+          :version => "90.0",
+          :key => "ssl_key",
+          :cert => "ssl_cert"
+        )
+
+        assert_equal "TAG", epp.tag
+        assert_equal "f00bar", epp.password
+        assert_equal "nominet-epp.server.org.uk", epp.server
+        assert_equal 8700, epp.port
+        assert_equal "es", epp.lang
+        assert_equal ["urn:ietf:params:xml:ns:domain-nom-ext-1.1.xsd"], epp.services
+        assert_equal ["domain-nom-ext-1.1.xsd"], epp.extensions
+        assert_equal "90.0", epp.version
+        assert_equal "ssl_key", epp.key
+        assert_equal "ssl_cert", epp.cert
+      end
+
+      should "build a new XML request" do
+        xml = xml_file("new_request.xml")
+
+        assert @epp.build_epp_request.is_a?(Nokogiri::XML::Builder)
+        assert_equal xml, @epp.build_epp_request.to_xml
+      end
+
+      should "open connection and receive a greeting" do
+        prepare_socket!
+
+        assert @epp.open_connection
+      end
+
+      should "return true if connection closed" do
+        prepare_socket!
+
+        @epp.open_connection
+
+        @tcp_sock.stubs(:close).returns(nil)
+        @ssl_sock.stubs(:close).returns(nil)
+        @tcp_sock.stubs(:closed?).returns(true)
+        @ssl_sock.stubs(:closed?).returns(true)
+
+        assert @epp.close_connection
+      end
+
+      should "get frame from new EPP servers with a header of four bytes" do
+        prepare_socket!
+
+        @epp.open_connection
+
+        response = xml_file("test_response.xml")
+
+        @ssl_sock.expects(:read).with(4).returns("\000\000\003\"")
+        @ssl_sock.expects(:read).with(798).returns(response)
+
+        assert response, @epp.get_frame
+      end
+
+      should "raise exception if socket closed unexpectedly while getting frame" do
+        prepare_socket!
+        simulate_close!
+
+        @epp.open_connection
+        @epp.close_connection
+
+        assert_raises SocketError do
+          @epp.get_frame
+        end
+      end
+
+      should "raise exception if header cannot be read when getting frame" do
+        prepare_socket!
+
+        @epp.open_connection
+
+        @ssl_sock.expects(:read).with(4).returns(nil)
+        @ssl_sock.stubs(:eof?).returns(false)
+
+        assert_raises SocketError do
+          @epp.get_frame
+        end
+      end
+
+      should "send frame to an EPP server" do
+        prepare_socket!
+
+        @epp.open_connection
+
+        send = xml_file("test_request.xml")
+
+        @ssl_sock.expects(:write).with(@epp.packed(send) + send).returns(121)
+
+        assert_equal 121, @epp.send_frame(send)
+      end
+
+      should "create a packed header for EPP request" do
+        xml_to_send = "<xml><test/></xml>"
+        assert_equal "\000\000\000\026", @epp.packed(xml_to_send)
+      end
+
+      should "return size of header from EPP response" do
+        assert_equal [22], "\000\000\000\026".unpack("N")
+        assert_equal 22, @epp.header_size("\000\000\000\026")
+      end
+
+      should "send frame, and get response from server" do
+        prepare_socket!
+
+        @epp.open_connection
+
+        send = xml_file("test_request.xml")
+        receive = xml_file("test_response.xml")
+
+        @ssl_sock.expects(:write).with(@epp.packed(send) + send).returns(121)
+        @ssl_sock.expects(:read).with(4).returns("\000\000\003\"")
+        @ssl_sock.expects(:read).with(798).returns(receive)
+
+        assert receive, @epp.send_request(send)
+      end
+
+      should "wrap a request around a logging in and logging out request" do
+        prepare_socket!
+        simulate_close!
+        check_socket!
+
+        test_request = xml_file("test_request.xml")
+        test_response = xml_file("test_response.xml")
+
+        @epp.expects(:login).returns(true)
+        @epp.expects(:logout).returns(true)
+        @epp.expects(:send_request).with(test_request).returns(test_response)
+
+        @response = @epp.request(test_request)
+
+        assert_equal test_response, @response
+      end
+    end
+
+    context "exceptions" do
+      should "require XML, code and message attributes" do
+        assert_raises ArgumentError do
+          e = EppErrorResponse.new(:code => "a", :message => "a")
+        end
+
+        assert_raises ArgumentError do
+          e = EppErrorResponse.new(:xml => "a", :message => "a")
+        end
+
+        assert_raises ArgumentError do
+          e = EppErrorResponse.new(:xml => "a", :code => "a")
+        end
+
+        assert_nothing_raised do
+          e = EppErrorResponse.new(:xml => "a", :code => "a", :message => "a")
+        end
+      end
+
+      should "print error message to string" do
+        e = EppErrorResponse.new(
+          :xml => "<xml></xml>",
+          :code => 400,
+          :message => "Test error message"
+        )
+
+        assert_equal "Test error message (code 400)", e.to_s
+      end
+    end
+  end
+
+  private
+
+  def prepare_socket!
+    @response = xml_file("test_response.xml")
+
+    TCPSocket.expects(:new).returns(@tcp_sock)
+    OpenSSL::SSL::SSLSocket.expects(:new).returns(@ssl_sock)
+
+    @ssl_sock.expects(:sync_close=).with(true)
+    @ssl_sock.expects(:connect).returns(@ssl_sock)
+    @ssl_sock.expects(:read).with(4).returns("\000\000\003\r")
+    @ssl_sock.expects(:read).with(777).returns(@response)
+    @ssl_sock.stubs(:eof?)
+  end
+
+  def check_socket!
+    @ssl_sock.stubs(:closed?)
+  end
+
+  def simulate_close!
+    @ssl_sock.stubs(:close).returns(nil)
+    @tcp_sock.stubs(:close).returns(nil)
+    @ssl_sock.stubs(:closed?).returns(true)
+    @tcp_sock.stubs(:closed?).returns(true)
+  end
+
+  def xml_file(name)
+    File.read(File.dirname(__FILE__) + "/xml/#{name}")
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'epp'
+
+class Test::Unit::TestCase
+end

data/test/xml/error.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd">
+  <response>
+    <result code="2200">
+      <msg>Authentication error</msg>
+    </result>
+    <trID>
+      <clTRID>ABC-12345</clTRID>
+      <svTRID>54321-XYZ</svTRID>
+    </trID>
+  </response>
+</epp>

data/test/xml/login_request.xml

@@ -0,0 +1 @@
+<?xml version='1.0' encoding='UTF-8' standalone='no'?><epp xsi:schemaLocation='urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='urn:ietf:params:xml:ns:epp-1.0'><command><login><clID>TEST</clID><pw>test</pw><options><version>1.0</version><lang>en</lang></options><svcs><objURI>urn:ietf:params:xml:ns:domain-1.0</objURI><objURI>urn:ietf:params:xml:ns:contact-1.0</objURI><objURI>urn:ietf:params:xml:ns:host-1.0</objURI></svcs></login><clTRID>ABC-12345</clTRID></command></epp>

data/test/xml/login_response.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0">
+  <response>
+    <result code="1000">
+      <msg>Command completed successfully</msg>
+    </result>
+    <trID>
+      <clTRID>ABC-12345</clTRID>
+      <svTRID>54321-XYZ</svTRID>
+    </trID>
+  </response>
+</epp>

data/test/xml/login_with_extensions_request.xml

@@ -0,0 +1 @@
+<?xml version='1.0' encoding='UTF-8' standalone='no'?><epp xsi:schemaLocation='urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='urn:ietf:params:xml:ns:epp-1.0'><command><login><clID>TEST</clID><pw>test</pw><options><version>1.0</version><lang>en</lang></options><svcs><objURI>urn:ietf:params:xml:ns:domain-1.0</objURI><objURI>urn:ietf:params:xml:ns:contact-1.0</objURI><objURI>urn:ietf:params:xml:ns:host-1.0</objURI><svcExtension><extURI>urn:ietf:params:xml:ns:rgp-1.0</extURI></svcExtension></svcs></login><clTRID>ABC-12345</clTRID></command></epp>

data/test/xml/logout_request.xml

@@ -0,0 +1 @@
+<?xml version='1.0' encoding='UTF-8' standalone='no'?><epp xsi:schemaLocation='urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='urn:ietf:params:xml:ns:epp-1.0'><command><logout/></command></epp>

data/test/xml/logout_response.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0">
+  <response>
+    <result code="1500">
+      <msg>Command completed successfully; ending session</msg>
+    </result>
+    <trID>
+      <clTRID>ABC-12345</clTRID>
+      <svTRID>54321-XYZ</svTRID>
+    </trID>
+  </response>
+</epp>

data/test/xml/new_request.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<epp xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:ietf:params:xml:ns:epp-1.0" xsi:schemaLocation="urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd"/>

data/test/xml/socket_preparation.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0" 
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+  xsi:schemaLocation="urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd">
+  <greeting>
+    <svID>CoCCA EPP Server - epp.cocca.iors.cx</svID>
+    <svDate>2010-07-07T12:46:33.0536Z</svDate>
+    <svcMenu>
+      <version>1.0</version>
+      <lang>en</lang>
+      <objURI>urn:ietf:params:xml:ns:contact-1.0</objURI>
+      <objURI>urn:ietf:params:xml:ns:domain-1.0</objURI>
+      <objURI>urn:ietf:params:xml:ns:host-1.0</objURI>
+      <svcExtension>
+        <extURI>urn:ietf:params:xml:ns:rgp-1.0</extURI>
+      </svcExtension>
+    </svcMenu>
+    <dcp>
+      <access><all/></access>
+      <statement>
+        <purpose><admin/><prov/></purpose>
+        <recipient><ours/><public/></recipient>
+        <retention><stated/></retention>
+      </statement>
+    </dcp>
+  </greeting>
+</epp>

data/test/xml/test_request.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0">
+  <hello/>
+</epp>

data/test/xml/test_response.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0">
+  <greeting>
+    <svID>Example EPP server epp.example.com</svID>
+    <svDate>2000-06-08T22:00:00.0Z</svDate>
+    <svcMenu>
+      <version>1.0</version>
+      <lang>en</lang>
+      <lang>fr</lang>
+      <objURI>urn:ietf:params:xml:ns:obj1</objURI>
+      <objURI>urn:ietf:params:xml:ns:obj2</objURI>
+      <objURI>urn:ietf:params:xml:ns:obj3</objURI>
+      <svcExtension>
+        <extURI>http://custom/obj1ext-1.0</extURI>
+      </svcExtension>
+    </svcMenu>
+    <dcp>
+      <access><all/></access>
+      <statement>
+        <purpose><admin/><prov/></purpose>
+        <recipient><ours/><public/></recipient>
+        <retention><stated/></retention>
+      </statement>
+    </dcp>
+  </greeting>
+</epp>

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification 
+name: epp-nokogiri
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Josh Delsman
+- Delwyn de Villiers
+- Priit Haamer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-04-09 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Basic functionality for connecting and making requests on EPP (Extensible Provisioning Protocol) servers
+email: 
+- jdelsman@ultraspeed.com
+- delwyn.d@gmail.com
+- priit@edicy.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- epp.gemspec
+- lib/epp.rb
+- lib/epp/exceptions.rb
+- lib/epp/server.rb
+- lib/epp/version.rb
+- lib/require_parameters.rb
+- test/test_epp.rb
+- test/test_helper.rb
+- test/xml/error.xml
+- test/xml/login_request.xml
+- test/xml/login_response.xml
+- test/xml/login_with_extensions_request.xml
+- test/xml/logout_request.xml
+- test/xml/logout_response.xml
+- test/xml/new_request.xml
+- test/xml/socket_preparation.xml
+- test/xml/test_request.xml
+- test/xml/test_response.xml
+has_rdoc: true
+homepage: http://github.com/delwyn/epp
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: epp
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: EPP (Extensible Provisioning Protocol) for Ruby
+test_files: 
+- test/test_epp.rb
+- test/test_helper.rb
+- test/xml/error.xml
+- test/xml/login_request.xml
+- test/xml/login_response.xml
+- test/xml/login_with_extensions_request.xml
+- test/xml/logout_request.xml
+- test/xml/logout_response.xml
+- test/xml/new_request.xml
+- test/xml/socket_preparation.xml
+- test/xml/test_request.xml
+- test/xml/test_response.xml