smart_proxy_dns_powerdns 0.2.1 → 0.3.0

data/test/unit/dns_powerdns_record_test.rb

@@ -1,115 +1,185 @@
 require 'test_helper'
 
-require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
 require 'smart_proxy_dns_powerdns/dns_powerdns_main'
 
 class DnsPowerdnsRecordTest < Test::Unit::TestCase
-  # Test that correct initialization works
-  def test_initialize_dummy_with_settings
-    Proxy::Dns::Powerdns::Plugin.load_test_settings(:powerdns_pdnssec => 'sudo pdnssec')
-    provider = klass.new
-    assert_equal 'sudo pdnssec', provider.pdnssec
+  def setup
+    @provider = Proxy::Dns::Powerdns::Record.new('localhost', 86400, 'sudo pdnssec')
+  end
+
+  def test_initialize
+    assert_equal 86400, @provider.ttl
+    assert_equal 'sudo pdnssec', @provider.pdnssec
   end
 
   # Test A record creation
   def test_create_a
-    instance = klass.new
+    @provider.expects(:a_record_conflicts).with('test.example.com', '10.1.1.1').returns(-1)
+    @provider.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    @provider.expects(:create_record).with(1, 'test.example.com', 'A', '10.1.1.1').returns(true)
+    @provider.expects(:rectify_zone).with('example.com').returns(true)
 
-    instance.expects(:dns_find).with('test.example.com').returns(false)
-    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
-    instance.expects(:create_record).with(1, 'test.example.com', 'A', '10.1.1.1').returns(true)
-    instance.expects(:rectify_zone).with('example.com').returns(true)
+    assert @provider.create_a_record(fqdn, ipv4)
+  end
 
-    assert instance.create_a_record(fqdn, ip)
+  # Test A record creation does nothing if the same record exists
+  def test_create_a_duplicate
+    @provider.expects(:a_record_conflicts).with('test.example.com', '10.1.1.1').returns(0)
+
+    assert_equal nil, @provider.create_a_record(fqdn, ipv4)
   end
 
   # Test A record creation fails if the record exists
   def test_create_a_conflict
-    instance = klass.new
+    @provider.expects(:a_record_conflicts).with('test.example.com', '10.1.1.1').returns(1)
+
+    assert_raise(Proxy::Dns::Collision) { @provider.create_a_record(fqdn, ipv4) }
+  end
+
+  # Test AAAA record creation
+  def test_create_aaaa
+    @provider.expects(:aaaa_record_conflicts).with('test.example.com', '2001:db8:1234:abcd::1').returns(-1)
+    @provider.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    @provider.expects(:create_record).with(1, 'test.example.com', 'AAAA', '2001:db8:1234:abcd::1').returns(true)
+    @provider.expects(:rectify_zone).with('example.com').returns(true)
+
+    assert @provider.create_aaaa_record(fqdn, ipv6)
+  end
+
+  # Test AAAA record creation does nothing if the same record exists
+  def test_create_aaaa_duplicate
+    @provider.expects(:aaaa_record_conflicts).with('test.example.com', '2001:db8:1234:abcd::1').returns(0)
+
+    assert_equal nil, @provider.create_aaaa_record(fqdn, ipv6)
+  end
+
+  # Test AAAA record creation fails if the record exists
+  def test_create_aaaa_conflict
+    @provider.expects(:aaaa_record_conflicts).with('test.example.com', '2001:db8:1234:abcd::1').returns(1)
+
+    assert_raise(Proxy::Dns::Collision) { @provider.create_aaaa_record(fqdn, ipv6) }
+  end
+
+  # Test CNAME record creation
+  def test_create_cname
+    @provider.expects(:cname_record_conflicts).with('test.example.com', 'something.example.com').returns(-1)
+    @provider.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    @provider.expects(:create_record).with(1, 'test.example.com', 'CNAME', 'something.example.com').returns(true)
+    @provider.expects(:rectify_zone).with('example.com').returns(true)
+
+    assert @provider.create_cname_record(fqdn, 'something.example.com')
+  end
+
+  # Test CNAME record creation does nothing if the same record exists
+  def test_create_cname_duplicate
+    @provider.expects(:cname_record_conflicts).with('test.example.com', 'something.example.com').returns(0)
 
-    instance.expects(:dns_find).with('test.example.com').returns('192.168.1.1')
+    assert_equal nil, @provider.create_cname_record(fqdn, 'something.example.com')
+  end
+
+  # Test CNAME record creation fails if the record exists
+  def test_create_cname_conflict
+    @provider.expects(:cname_record_conflicts).with('test.example.com', 'something.example.com').returns(1)
 
-    assert_raise(Proxy::Dns::Collision) { instance.create_a_record(fqdn, ip) }
+    assert_raise(Proxy::Dns::Collision) { @provider.create_cname_record(fqdn, 'something.example.com') }
   end
 
   # Test PTR record creation
   def test_create_ptr
-    instance = klass.new
+    @provider.expects(:ptr_record_conflicts).with('test.example.com', '10.1.1.1').returns(-1)
+    @provider.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
+    @provider.expects(:create_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR', 'test.example.com').returns(true)
+    @provider.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
 
-    instance.expects(:dns_find).with('1.1.1.10.in-addr.arpa').returns(false)
-    instance.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
-    instance.expects(:create_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR', 'test.example.com').returns(true)
-    instance.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
+    assert @provider.create_ptr_record(fqdn, reverse_ipv4)
+  end
 
-    assert instance.create_ptr_record(fqdn, reverse_ip)
+  # Test PTR record creation does nothing if the same record exists
+  def test_create_ptr_duplicate
+    @provider.expects(:ptr_record_conflicts).with('test.example.com', '10.1.1.1').returns(0)
+
+    assert_equal nil, @provider.create_ptr_record(fqdn, reverse_ipv4)
   end
 
   # Test PTR record creation fails if the record exists
   def test_create_ptr_conflict
-    instance = klass.new
+    @provider.expects(:ptr_record_conflicts).with('test.example.com', '10.1.1.1').returns(1)
+
+    assert_raise(Proxy::Dns::Collision) { @provider.create_ptr_record(fqdn, reverse_ipv4) }
+  end
 
-    instance.expects(:dns_find).with('1.1.1.10.in-addr.arpa').returns('test2.example.com')
+  # Test PTR record creation
+  def test_create_ptr_ipv6
+    @provider.expects(:ptr_record_conflicts).with('test.example.com', '2001:0db8:1234:abcd:0000:0000:0000:0001').returns(-1)
+    @provider.expects(:get_zone).with('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa').returns({'id' => 1, 'name' => 'd.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa'})
+    @provider.expects(:create_record).with(1, '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa', 'PTR', 'test.example.com').returns(true)
+    @provider.expects(:rectify_zone).with('d.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa').returns(true)
 
-    assert_raise(Proxy::Dns::Collision) { instance.create_ptr_record(fqdn, reverse_ip) }
+    assert @provider.create_ptr_record(fqdn, reverse_ipv6)
   end
 
   # Test A record removal
   def test_remove_a
-    instance = klass.new
-
-    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
-    instance.expects(:delete_record).with(1, 'test.example.com', 'A').returns(true)
-    instance.expects(:rectify_zone).with('example.com').returns(true)
+    @provider.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    @provider.expects(:delete_record).with(1, 'test.example.com', 'A').returns(true)
+    @provider.expects(:rectify_zone).with('example.com').returns(true)
 
-    assert instance.remove_a_record(fqdn)
+    assert @provider.remove_a_record(fqdn)
   end
 
   # Test PTR record removal
-  def test_remove_ptr
-    instance = klass.new
+  def test_remove_ptr_ipv4
+    @provider.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
+    @provider.expects(:delete_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR').returns(true)
+    @provider.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
 
-    instance.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
-    instance.expects(:delete_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR').returns(true)
-    instance.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
+    assert @provider.remove_ptr_record(reverse_ipv4)
+  end
 
-    assert instance.remove_ptr_record(reverse_ip)
+  # Test PTR record removal
+  def test_remove_ptr_ipv6
+    @provider.expects(:get_zone).with('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa').returns({'id' => 1, 'name' => 'd.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa'})
+    @provider.expects(:delete_record).with(1, '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa', 'PTR').returns(true)
+    @provider.expects(:rectify_zone).with('d.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa').returns(true)
+
+    assert @provider.remove_ptr_record(reverse_ipv6)
   end
 
   def test_do_create
-    instance = klass.new
-
-    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
-    instance.expects(:create_record).with(1, 'test.example.com', 'A', '10.1.1.1').returns(true)
-    instance.expects(:rectify_zone).with('example.com').returns(true)
+    @provider.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    @provider.expects(:create_record).with(1, 'test.example.com', 'A', '10.1.1.1').returns(true)
+    @provider.expects(:rectify_zone).with('example.com').returns(true)
 
-    assert instance.do_create('test.example.com', '10.1.1.1', 'A')
+    assert @provider.do_create('test.example.com', '10.1.1.1', 'A')
   end
 
   def test_do_remove
-    instance = klass.new
-
-    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
-    instance.expects(:delete_record).with(1, 'test.example.com', 'A').returns(true)
-    instance.expects(:rectify_zone).with('example.com').returns(true)
+    @provider.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    @provider.expects(:delete_record).with(1, 'test.example.com', 'A').returns(true)
+    @provider.expects(:rectify_zone).with('example.com').returns(true)
 
-    assert instance.do_remove('test.example.com', 'A')
+    assert @provider.do_remove('test.example.com', 'A')
   end
 
   private
 
-  def klass
-    Proxy::Dns::Powerdns::Record
-  end
-
   def fqdn
     'test.example.com'
   end
 
-  def ip
+  def ipv4
     '10.1.1.1'
   end
 
-  def reverse_ip
+  def reverse_ipv4
     '1.1.1.10.in-addr.arpa'
   end
+
+  def ipv6
+    '2001:db8:1234:abcd::1'
+  end
+
+  def reverse_ipv6
+    '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.c.b.a.4.3.2.1.8.b.d.0.1.0.0.2.ip6.arpa'
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dns_powerdns
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ewoud Kohl van Wijngaarden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-27 00:00:00.000000000 Z
+date: 2017-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -81,20 +81,25 @@ files:
 - lib/smart_proxy_dns_powerdns/backend/dummy.rb
 - lib/smart_proxy_dns_powerdns/backend/mysql.rb
 - lib/smart_proxy_dns_powerdns/backend/postgresql.rb
-- lib/smart_proxy_dns_powerdns/dependencies.rb
-- lib/smart_proxy_dns_powerdns/dns_powerdns_configuration_validator.rb
+- lib/smart_proxy_dns_powerdns/backend/rest.rb
+- lib/smart_proxy_dns_powerdns/dns_powerdns_configuration.rb
 - lib/smart_proxy_dns_powerdns/dns_powerdns_main.rb
 - lib/smart_proxy_dns_powerdns/dns_powerdns_plugin.rb
 - lib/smart_proxy_dns_powerdns/dns_powerdns_version.rb
+- test/config/smart-proxy-settings.d/dns.yml
+- test/config/smart-proxy-settings.d/dns_powerdns.yml
+- test/config/smart-proxy-settings.yml
 - test/integration/integration_test.rb
 - test/test_helper.rb
-- test/unit/dns_powerdns_configuration_validator_test.rb
+- test/unit/dns_powerdns_configuration_test.rb
+- test/unit/dns_powerdns_record_dummy_test.rb
 - test/unit/dns_powerdns_record_mysql_test.rb
 - test/unit/dns_powerdns_record_postgresql_test.rb
+- test/unit/dns_powerdns_record_rest_test.rb
 - test/unit/dns_powerdns_record_test.rb
 homepage: https://github.com/theforeman/smart_proxy_dns_powerdns
 licenses:
-- GPLv3
+- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -112,14 +117,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.5
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: PowerDNS DNS provider plugin for Foreman's smart proxy
 test_files:
-- test/test_helper.rb
 - test/integration/integration_test.rb
-- test/unit/dns_powerdns_record_postgresql_test.rb
-- test/unit/dns_powerdns_configuration_validator_test.rb
+- test/unit/dns_powerdns_configuration_test.rb
 - test/unit/dns_powerdns_record_mysql_test.rb
+- test/unit/dns_powerdns_record_rest_test.rb
 - test/unit/dns_powerdns_record_test.rb
+- test/unit/dns_powerdns_record_dummy_test.rb
+- test/unit/dns_powerdns_record_postgresql_test.rb
+- test/config/smart-proxy-settings.d/dns.yml
+- test/config/smart-proxy-settings.d/dns_powerdns.yml
+- test/config/smart-proxy-settings.yml
+- test/test_helper.rb

data/lib/smart_proxy_dns_powerdns/dependencies.rb

@@ -1,15 +0,0 @@
-require 'dns_common/dependency_injection/dependencies'
-
-class Proxy::Dns::DependencyInjection::Dependencies
-  case Proxy::Dns::Powerdns::Plugin.settings.powerdns_backend
-  when 'mysql'
-    require 'smart_proxy_dns_powerdns/backend/mysql'
-    dependency :dns_provider, Proxy::Dns::Powerdns::Backend::Mysql
-  when 'postgresql'
-    require 'smart_proxy_dns_powerdns/backend/postgresql'
-    dependency :dns_provider, Proxy::Dns::Powerdns::Backend::Postgresql
-  when 'dummy'
-    require 'smart_proxy_dns_powerdns/backend/dummy'
-    dependency :dns_provider, Proxy::Dns::Powerdns::Backend::Dummy
-  end
-end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_configuration_validator.rb

@@ -1,32 +0,0 @@
-require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
-
-module Proxy::Dns::Powerdns
-  class ConfigurationValidator
-    def validate_settings!(settings)
-      validate_choice(settings, :powerdns_backend, ['mysql', 'postgresql', 'dummy'])
-
-      case settings.powerdns_backend
-      when 'mysql'
-        validate_presence(settings, [:powerdns_mysql_username, :powerdns_mysql_password, :powerdns_mysql_database])
-      when 'postgresql'
-        validate_presence(settings, [:powerdns_postgresql_connection])
-      end
-    end
-
-    def validate_choice(settings, setting, choices)
-      value = settings.send(setting)
-      unless choices.include?(value)
-        raise ::Proxy::Error::ConfigurationError, "Parameter '#{setting}' is expected to be one of #{choices.join(",")}"
-      end
-      true
-    end
-
-    def validate_presence(settings, names)
-      names.each do |name|
-        value = settings.send(name)
-        raise ::Proxy::Error::ConfigurationError, "Parameter '#{name}' is expected to have a non-empty value" if value.nil? || value.to_s.empty?
-      end
-      true
-    end
-  end
-end

data/test/unit/dns_powerdns_configuration_validator_test.rb

@@ -1,78 +0,0 @@
-require 'test_helper'
-require 'ostruct'
-
-require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
-require 'smart_proxy_dns_powerdns/dns_powerdns_configuration_validator'
-
-class DnsPowerdnsConfigurationValidatorTest < Test::Unit::TestCase
-  def setup
-    @config_validator = Proxy::Dns::Powerdns::ConfigurationValidator.new
-  end
-
-  def test_initialize_missing_backend
-    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => nil)
-
-    assert_raise Proxy::Error::ConfigurationError do
-      @config_validator.validate_settings!(settings)
-    end
-  end
-
-  def test_initialize_invalid_backend
-    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'invalid')
-
-    assert_raise Proxy::Error::ConfigurationError do
-      @config_validator.validate_settings!(settings)
-    end
-  end
-
-  def test_initialize_dummy_with_settings
-    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'dummy')
-
-    assert_nothing_raised do
-      @config_validator.validate_settings!(settings)
-    end
-  end
-
-  def test_initialize_mysql_without_settings
-    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'mysql')
-
-    assert_raise Proxy::Error::ConfigurationError do
-      @config_validator.validate_settings!(settings)
-    end
-  end
-
-  def test_initialize_mysql_with_settings
-    settings = OpenStruct.new(
-      :dns_provider => 'powerdns',
-      :powerdns_backend => 'mysql',
-      :powerdns_mysql_hostname => 'localhost',
-      :powerdns_mysql_username => 'username',
-      :powerdns_mysql_password => 'password',
-      :powerdns_mysql_database => 'powerdns'
-    )
-
-    assert_nothing_raised do
-      @config_validator.validate_settings!(settings)
-    end
-  end
-
-  def test_initialize_postgresql_without_settings
-    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'postgresql')
-
-    assert_raise Proxy::Error::ConfigurationError do
-      @config_validator.validate_settings!(settings)
-    end
-  end
-
-  def test_initialize_postgresql_with_settings
-    settings = OpenStruct.new(
-      :dns_provider => 'powerdns',
-      :powerdns_backend => 'postgresql',
-      :powerdns_postgresql_connection => 'dbname=powerdns'
-    )
-
-    assert_nothing_raised do
-      @config_validator.validate_settings!(settings)
-    end
-  end
-end