kono_epp_client 0.1.0 → 2.0.0

data/spec/lib/commands/create_domain_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppClient::Commands::CreateDomain do
+  include_context "like epp command"
+
+  let(:opts) {
+    {
+      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"
+    }
+  }
+
+  let(:instance) { KonoEppClient::Commands::CreateDomain.new(opts) }
+
+  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
+
+  context "create with ds_data" do
+
+    let(:opts) {
+      super().merge(dns_sec_data: [create(:ds_data, key_tag: 9657)])
+    }
+
+    it "build extensions", snapshot: "xml" do
+      expect(rendered.to_s).to have_tag("extension>create>dsdata>keytag", text: 9657)
+    end
+
+  end
+
+end

data/spec/lib/commands/login_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RSpec.describe KonoEppClient::Commands::Login do
+  include_context "like epp command"
+
+  let(:args) { [] }
+
+  let(:instance) {
+    KonoEppClient::Commands::Login.new(*args)
+  }
+  subject(:xml) { rendered.to_s }
+
+  it "login", snapshot: "xml" do
+    is_expected.to have_tag("command") do
+      with_tag(:login)
+      with_tag("cltrid", text: "ABC-12345")
+    end
+  end
+
+  context "with id and password" do
+    let(:args) { ["12", "password"] }
+    it "login", snapshot: "xml" do
+      is_expected.to have_tag("command") do
+        with_tag(:login) do
+          with_tag("clid", text: "12")
+          with_tag("pw", text: "password")
+        end
+      end
+    end
+  end
+
+  describe "tags" do
+    where(:case_name, :method, :tag_matcher, :value, :no_value, :getter) do
+      [
+        [:lang, :lang, have_tag("command>login>options>lang", text: "en"), "en", nil, true],
+        [:version, :version, have_tag("command>login>options>version", text: "1.0"), "1.0", nil, true],
+        [:new_password, :new_password, have_tag("command>login>newpw", text: "password"), "password", nil, false],
+
+        [:services, :services,
+         lazy {
+           have_tag("command>login>svcs") do
+             with_tag("objuri", count: 2)
+             with_tag("objuri", text: "valore1")
+           end
+         }, ["valore1", "valore2"], [], true],
+
+        [
+          :extensions, :extensions,
+          lazy {
+            have_tag("command>login>svcs>svcextension") do
+              with_tag("exturi", count: 2)
+              with_tag("exturi", text: "http://uri1.com/valore1")
+            end
+          }, ["http://uri1.com/valore1", "http://uri2.com/valore2"],
+          [],
+          true
+        ]
+
+      ]
+    end
+
+    with_them do
+
+      subject { instance.send(method) }
+      it "getter" do
+        if getter
+          is_expected.to eq no_value
+        end
+      end
+
+      context "with value" do
+        let(:instance) {
+          super().tap { |e| e.send("#{method}=", value) }
+        }
+        it "getter" do
+          if getter
+            is_expected.to be == value
+          end
+        end
+        it "xml", snapshot: "xml" do
+          expect(xml).to tag_matcher
+        end
+      end
+    end
+  end
+
+end

data/spec/{epp/epp_command/kono_epp_transfer_domain_spec.rb → lib/commands/transfer_domain_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe KonoEppTransferDomain do
+RSpec.describe KonoEppClient::Commands::TransferDomain do
 
   include_context "like epp command"
 

data/spec/{epp/epp_command/kono_epp_update_domain_spec.rb → lib/commands/update_domain_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe KonoEppUpdateDomain do
+RSpec.describe KonoEppClient::Commands::UpdateDomain do
 
   let(:options) do
     {
@@ -19,7 +19,7 @@ RSpec.describe KonoEppUpdateDomain do
   include_context "like epp command"
 
   let(:instance) {
-    KonoEppUpdateDomain.new(options)
+    KonoEppClient::Commands::UpdateDomain.new(options)
   }
 
   it "contiene il nome del dominio" do
@@ -46,7 +46,7 @@ RSpec.describe KonoEppUpdateDomain do
       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:"")
+          without_tag("hostaddr", text: "")
         end
       end
       expect(rendered.to_s.downcase).to have_tag("update>rem>ns") do
@@ -92,7 +92,7 @@ RSpec.describe KonoEppUpdateDomain do
                       restore: true
                     })
     }
-    it "esiste l'estensione di restore",snapshot: 'xml' do
+    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
@@ -122,4 +122,20 @@ RSpec.describe KonoEppUpdateDomain do
     end
   end
 
+  describe "update DnsSec" do
+    let(:options) {
+      super().merge(dns_sec_data: [
+        KonoEppClient::DnsSec::Add.new(create(:ds_data, key_tag: 9657)),
+        KonoEppClient::DnsSec::Rem.new(create(:ds_data, key_tag: 1685))
+      ])
+    }
+
+    it "build extensions", snapshot: "xml" do
+      expect(rendered.to_s).to have_tag("extension>update>add>dsdata>keytag", text: 9657)
+      expect(rendered.to_s).to have_tag("extension>update>rem>dsdata>keytag", text: 1685)
+    end
+
+
+  end
+
 end

data/spec/lib/dns_sec/add_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe KonoEppClient::DnsSec::DsData do
+
+  let(:instance) {
+    KonoEppClient::DnsSec::Add.new(
+      create(:ds_data,key_tag:"1234"),
+      create(:ds_data,key_tag:"4321"),
+    )
+  }
+
+  it "#to_s" do
+    expect(instance.to_s).to match(xml_fixture("dns_sec/add.xml"))
+  end
+
+end

data/spec/lib/dns_sec/ds_data_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe KonoEppClient::DnsSec::DsData do
+
+  let(:instance) {
+    KonoEppClient::DnsSec::DsData.new(123, :dsa_sha_1, :sha_1, "digest")
+  }
+
+  it "valid instance" do
+    expect(instance).to have_attributes(key_tag: 123, alg: 3, digest_type: 1, digest: "digest")
+  end
+
+  describe "instantiate" do
+    where(:case_name, :values, :expectation) do
+      [
+        [
+          :key_tag_to_low,
+          [-1, :dsa_sha_1, :sha_1, "digest"],
+          "Invalid key tag -1, should be 0<=key_tag<=65535"
+        ], [
+          :key_tag_to_hight,
+          [1_000_000, :dsa_sha_1, :sha_1, "digest"],
+          "Invalid key tag 1000000, should be 0<=key_tag<=65535"
+        ], [
+          :digest_type,
+          [123, :dsa_sha_1, :non_presente, "digest"],
+          "Invalid digest type non_presente"
+        ], [
+          :alg,
+          [1_000_000, :non_presente, :sha_1, "digest"],
+          "Invalid alg non_presente"
+        ],
+      ]
+    end
+
+    with_them do
+      it { expect { KonoEppClient::DnsSec::DsData.new(*values) }.to raise_error(expectation) }
+    end
+  end
+
+  it "#to_s" do
+    expect(instance.to_s).to match(xml_fixture("dns_sec/ds_data.xml"))
+  end
+
+end

data/spec/lib/dns_sec/rem_all_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe KonoEppClient::DnsSec::DsData do
+
+  let(:instance) {
+    KonoEppClient::DnsSec::RemAll.new
+  }
+
+  it "#to_s" do
+    expect(instance.to_s).to match(file_fixture("dns_sec/rem_all.xml").read.gsub(/[[:space:]]/, ''))
+  end
+
+end

data/spec/lib/dns_sec/rem_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe KonoEppClient::DnsSec::DsData do
+
+  let(:instance) {
+    KonoEppClient::DnsSec::Rem.new(
+      create(:ds_data, key_tag: "1234"),
+      create(:ds_data, key_tag: "4321"),
+    )
+  }
+
+  it "#to_s" do
+    expect(instance.to_s).to match(xml_fixture("dns_sec/rem.xml"))
+  end
+
+end

data/spec/lib/server_spec.rb

@@ -0,0 +1,304 @@
+RSpec.describe KonoEppClient::Server do
+
+  let(:params) {
+    {
+      tag: "abc",
+      password: "123123",
+      server: "epp.pubtest.nic.it"
+    }
+  }
+
+  let(:instance) { described_class.new(params) }
+
+  ##
+  # Impostazione per eseguire inviare comandi di login con estensione DNSSEC
+  shared_context "dnssec activation" do
+    let(:params) {
+      super().merge(enable_dns_sec: true)
+    }
+  end
+
+  ##
+  # Forza l'istanza come se avessi avuto conferma di connessione tramite DNSSEC
+  shared_context "dnssec activated" do
+    let(:instance) {
+      super().tap { |c| c.instance_variable_set(:@dns_sec_enabled, true) }
+    }
+  end
+
+  describe "initialization" do
+
+    it "base" do
+      expect(instance).to have_attributes(
+                            **params,
+                            port: 700,
+                            lang: "en",
+                            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: [],
+                            version: "1.0",
+                            transport: :http,
+                            transport_options: {},
+                            timeout: 30,
+                            ssl_version: :TLSv1
+                          )
+    end
+
+    it_behaves_like "dnssec activation" do
+
+      it { expect(instance).to have_attributes(
+                                 extensions: include("urn:ietf:params:xml:ns:secDNS-1.1",
+                                                     "http://www.nic.it/ITNIC-EPP/extsecDNS-1.0"),
+                                 dns_sec_enabled: false # questo viene abilitato rispetto alla risposta del NIC
+                               )
+
+      }
+
+    end
+
+  end
+
+  describe "#open_connection" do
+
+    let(:params) {
+      super().merge(
+        transport: :http,
+      )
+    }
+
+    it "default transport" do
+
+      double = instance_double(KonoEppClient::Transport::HttpTransport)
+
+      expect(KonoEppClient::Transport::HttpTransport).to receive(:new).with(
+        params[:server],
+        700, ssl_version: :TLSv1, cookie_file: "abc.cookies.pstore").and_return(double)
+
+      expect { instance.open_connection }.to change { instance.instance_variable_get(:@connection) }.
+        to(double)
+    end
+
+    context "transport http" do
+
+      let(:params) {
+        super().merge(
+          transport_options: {cookie_file: "file_to_coockies"},
+        )
+      }
+
+      it "use http transport" do
+        double = instance_double(KonoEppClient::Transport::HttpTransport)
+
+        expect(KonoEppClient::Transport::HttpTransport).to receive(:new).with(
+          params[:server],
+          700, ssl_version: :TLSv1, cookie_file: "file_to_coockies").and_return(double)
+
+        expect { instance.open_connection }.to change { instance.instance_variable_get(:@connection) }.
+          to(double)
+
+      end
+
+    end
+
+  end
+
+  describe "#login" do
+
+    it {
+      expect(instance).to receive(:send_command) do |command|
+        expect(command.to_s).to have_tag("command>login") do
+          with_tag("options>version", text: "1.0")
+          with_tag("options>lang", text: "en")
+          instance.services.each do |srv|
+            with_tag("svcs>objuri", text: srv)
+          end
+          without_tag("svcs>svcextension")
+        end
+        Nokogiri::XML(file_fixture("login_response.xml").read) # Si aspetta un XML di risposta
+      end
+
+      instance.login
+    }
+
+    context "with extensions" do
+      let(:params) {
+        super().merge(extensions: ["https://nome.estensione", "altra:estensione"])
+      }
+
+      it {
+        expect(instance).to receive(:send_command) do |command|
+          expect(command.to_s).to have_tag("command>login>svcs>svcextension") do
+            with_tag("exturi", text: "https://nome.estensione")
+            with_tag("exturi", text: "altra:estensione")
+          end
+          Nokogiri::XML(file_fixture("login_response.xml").read) # Si aspetta un XML di risposta
+        end
+
+        instance.login
+
+      }
+
+    end
+
+    it_behaves_like "dnssec activation" do
+
+      it "requested" do
+        expect(instance).to receive(:send_command) do |command|
+          expect(command.to_s).to have_tag("command>login>svcs>svcextension") do
+            with_tag("exturi", text: "http://www.nic.it/ITNIC-EPP/extsecDNS-1.0")
+            with_tag("exturi", text: "urn:ietf:params:xml:ns:secDNS-1.1")
+          end
+          Nokogiri::XML(file_fixture("login_response_for_dnssec.xml").read) # Si aspetta un XML di risposta
+        end
+
+        instance.login
+
+      end
+
+      it "with response" do
+        allow(instance).to receive(:send_request)
+                             .and_return(file_fixture("login_response_for_dnssec.xml").read)
+
+        expect {
+          instance.login
+          expect(instance).to be_dns_sec_enabled
+        }.to change(instance, :dns_sec_enabled).to(true)
+
+      end
+
+      it "response for Registrar not accredited" do
+        allow(instance).to receive(:send_request)
+                             .and_return(file_fixture("login_response.xml").read)
+
+        expect {
+          instance.login
+          expect(instance).not_to be_dns_sec_enabled
+        }.not_to change(instance, :dns_sec_enabled)
+      end
+
+    end
+
+  end
+
+  describe "#create_domain" do
+
+    let(:ds_data) {
+      create(:ds_data)
+    }
+
+    it {
+      expect(instance).to receive(:send_command) do |command|
+        expect(command.to_s).to have_xpath("//domain:create//domain:name[text()='architest.it']", {"domain" => "urn:ietf:params:xml:ns:domain-1.0"})
+        expect(command.to_s).not_to have_xpath("//extension//secDNS:create", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+      end
+
+      instance.create_domain(name: 'architest.it', nameservers: [])
+
+    }
+
+    it "impostando i dati del dnssec ma senza aver avuto conferma da NIC di poterlo usare" do
+      expect(instance).to receive(:send_command) do |command|
+        expect(command.to_s).not_to have_xpath("//secDNS:create", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+      end
+
+      instance.create_domain(name: 'architest.it', nameservers: [], dns_sec_data: [ds_data])
+    end
+
+    it_behaves_like "dnssec activated" do
+
+      it "senza assegnare dnssec data non succede nulla" do
+        expect(instance).to receive(:send_command) do |command|
+          expect(command.to_s).not_to have_xpath("//secDNS:create", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+        end
+
+        instance.create_domain(name: 'architest.it', nameservers: [])
+      end
+
+      it "assegnando dei valori" do
+        expect(instance).to receive(:send_command) do |command|
+          expect(command.to_s).to have_xpath("//secDNS:create", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+          expect(command.to_s).to have_xpath(
+                                    "//secDNS:keyTag[text()='123']",
+                                    {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"}
+                                  )
+
+        end
+
+        instance.create_domain(name: 'architest.it', nameservers: [], dns_sec_data: [ds_data])
+      end
+
+    end
+
+  end
+
+  describe "#update_domain" do
+
+    let(:ds_data_a) { create(:ds_data) }
+    let(:ds_data_b) { create(:ds_data) }
+
+    it {
+      expect(instance).to receive(:send_command) do |command|
+        expect(command.to_s).to have_xpath("//domain:update//domain:name[text()='architest.it']", {"xmlns:domain" => "urn:ietf:params:xml:ns:domain-1.0"})
+        expect(command.to_s).not_to have_xpath("//extension//secDNS:update", {"xmlns:secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+      end
+
+      instance.update_domain(name: 'architest.it')
+    }
+
+    it "impostando i dati del dnssec ma senza aver avuto conferma da NIC di poterlo usare" do
+      expect(instance).to receive(:send_command) do |command|
+        expect(command.to_s).not_to have_xpath("//secDNS:update", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+      end
+
+      instance.update_domain(name: 'architest.it', dns_sec_data: [KonoEppClient::DnsSec::Add.new(ds_data_a)])
+    end
+
+    it_behaves_like "dnssec activated" do
+
+      it "senza assegnare dnssec data non succede nulla" do
+        expect(instance).to receive(:send_command) do |command|
+          expect(command.to_s).not_to have_xpath("//secDNS:update", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+        end
+
+        instance.update_domain(name: 'architest.it')
+      end
+
+      it "assegnando dei valori" do
+        expect(instance).to receive(:send_command) do |command|
+          expect(command.to_s).to have_xpath("//secDNS:update", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+
+          expect(command.to_s).to have_xpath(
+                                    "//secDNS:update//secDNS:add//secDNS:dsData//secDNS:keyTag[text()='#{ds_data_a.key_tag}']",
+                                    {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"}
+                                  )
+          expect(command.to_s).to have_xpath(
+                                    "//secDNS:update//secDNS:rem//secDNS:dsData//secDNS:keyTag[text()='#{ds_data_b.key_tag}']",
+                                    {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"}
+                                  )
+        end
+
+        instance.update_domain(name: 'architest.it', dns_sec_data: [
+          KonoEppClient::DnsSec::Add.new(ds_data_a),
+          KonoEppClient::DnsSec::Rem.new(ds_data_b)
+        ])
+      end
+
+      it "cancello tutti i ds_data" do
+        expect(instance).to receive(:send_command) do |command|
+          expect(command.to_s).to have_xpath("//secDNS:update", {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"})
+
+          expect(command.to_s).to have_xpath(
+                                    "//secDNS:update//secDNS:rem//secDNS:all[text()='true']",
+                                    {"secDNS" => "urn:ietf:params:xml:ns:secDNS-1.1"}
+                                  )
+        end
+
+        instance.update_domain(name: 'architest.it', dns_sec_data: [
+          KonoEppClient::DnsSec::RemAll.new
+        ])
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -3,9 +3,13 @@ Bundler.setup
 
 require 'simplecov'
 SimpleCov.start do
-  add_group "Commands","lib/epp/epp_command"
-end
+  enable_coverage :branch
+  enable_coverage_for_eval
+  add_group "Commands","lib/kono_epp_client/commands"
+  add_filter "spec"
 
+end
+require 'debug'
 require 'kono_epp_client' # and any other gems you need
 
 # This file was generated by the `rspec --init` command. Conventionally, all

data/spec/support/context.rb

@@ -9,7 +9,7 @@ RSpec.shared_context "like epp command" do
   }
   let(:rendered) {
     x = Nokogiri::XML(raw_rendered_content)
-    x.remove_namespaces! # FIXME non capisco come funzioni la ricerca con namespace
+    x.remove_namespaces! # La ricerca con namespace deve essere fatta con have_xpath e il passaggio di namespace
     x
   }
 end

data/spec/support/factory_bot.rb

@@ -0,0 +1,8 @@
+require "factory_bot"
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+end
+
+FactoryBot.definition_file_paths = %w{./spec/factories}
+FactoryBot.find_definitions
+

data/spec/support/fixtures.rb

@@ -0,0 +1,16 @@
+module FixturesReader
+  def file_fixture(filename)
+    fixuture_path =  File.expand_path('../fixtures', File.dirname(__FILE__))
+    File.open("#{fixuture_path}/#{filename}", 'r')
+  end
+
+  ##
+  # Stessa cosa del file_fixture ma elimina tutti gli spazi dal file xml
+  def xml_fixture(filename)
+    file_fixture(filename).read.gsub(/[[:space:]]/, '')
+  end
+end
+
+RSpec.configure do |config|
+  config.include FixturesReader
+end

data/spec/support/matchers.rb

@@ -3,4 +3,18 @@ require 'rspec-html-matchers'
 RSpec.configure do |config|
 
   config.include RSpecHtmlMatchers
+end
+
+RSpec::Matchers.define :have_xpath do |xpath, *opts|
+  match do |str|
+    Nokogiri::XML(str).xpath(xpath, *opts).any?
+  end
+
+  failure_message do |str|
+    "Expected xpath #{xpath.inspect} to match in:\n" + Nokogiri::XML(str).to_xml(indent: 2)
+  end
+
+  failure_message_when_negated do |str|
+    "Expected xpath #{xpath.inspect} not to match in:\n" + Nokogiri::XML(str).to_xml(indent: 2)
+  end
 end

data/spec/support/parametric.rb

@@ -0,0 +1 @@
+require 'rspec-parameterized'