kono_epp_client 0.1.1 → 2.0.0

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'

data/spec/support/snapshot.rb

@@ -1,5 +1,14 @@
 require "rspec/snapshot"
 require "active_support/core_ext/string"
+
+
+def first_parent_example_group(metadata)
+  parent = metadata[:parent_example_group] || metadata[:example_group]
+  return metadata if parent.nil?
+  first_parent_example_group(parent)
+end
+
+
 RSpec.configure do |config|
 
   config.snapshot_dir = "spec/fixtures/snapshots"
@@ -7,8 +16,9 @@ RSpec.configure do |config|
   config.after(:each, snapshot: true) do |example|
     extension=nil
     extension = ".#{example.metadata[:snapshot]}" unless example.metadata[:snapshot] === true
-    class_name = example.metadata[:described_class].name.underscore
-    test_name = example.metadata[:full_description].gsub(example.metadata[:described_class].name, "").tr(" ", "_")
+    described_class = first_parent_example_group(example.metadata)[:described_class]
+    class_name = described_class.name.underscore
+    test_name = example.metadata[:full_description].gsub(described_class.name, "").tr(" ", "_")
     raise "component snapshot has no content" if raw_rendered_content.nil? or raw_rendered_content.empty?
     str_content = raw_rendered_content
     if extension == ".xml"