smart_proxy_dns_powerdns 0.2.1 → 0.3.0

data/lib/smart_proxy_dns_powerdns/dns_powerdns_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module Dns
     module Powerdns
-      VERSION = '0.2.1'
+      VERSION = '0.3.0'
     end
   end
 end

data/test/config/smart-proxy-settings.d/dns.yml

@@ -0,0 +1,3 @@
+---
+:enabled: true
+:use_provider: dns_powerdns

data/test/config/smart-proxy-settings.d/dns_powerdns.yml

@@ -0,0 +1,4 @@
+---
+:powerdns_backend: rest
+:powerdns_rest_url: http://localhost:8081/api/v1/servers/localhost
+:powerdns_rest_api_key: apikey

data/test/config/smart-proxy-settings.yml

@@ -0,0 +1,4 @@
+:settings_directory: /home/ekohl/dev/smart_proxy_dns_powerdns/test/config/smart-proxy-settings.d
+:http_port: 8000
+:log_file: STDOUT
+:log_level: DEBUG

data/test/integration/integration_test.rb

@@ -5,7 +5,7 @@ require 'net/http'
 
 class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
 
-  def test_forward_dns
+  def test_forward_dns_v4
     data = {'fqdn' => fqdn, 'value' => ip, 'type' => 'A'}
     type = Resolv::DNS::Resource::IN::A
     expected = type.new(Resolv::IPv4.create(data['value']))
@@ -13,6 +13,14 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
     test_scenario(data, data['fqdn'], type, expected)
   end
 
+  def test_forward_dns_v6
+    data = {'fqdn' => fqdn, 'value' => ipv6, 'type' => 'AAAA'}
+    type = Resolv::DNS::Resource::IN::AAAA
+    expected = type.new(Resolv::IPv6.create(data['value']))
+
+    test_scenario(data, data['fqdn'], type, expected)
+  end
+
   def test_reverse_dns_v4
     data = {'fqdn' => fqdn, 'value' => IPAddr.new(ip).reverse, 'type' => 'PTR'}
     type = Resolv::DNS::Resource::IN::PTR
@@ -29,6 +37,14 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
     test_scenario(data, data['value'], type, expected)
   end
 
+  def test_cname
+    data = {'fqdn' => fqdn, 'value' => 'something.example.com', 'type' => 'CNAME'}
+    type = Resolv::DNS::Resource::IN::CNAME
+    expected = type.new(Resolv::DNS::Name.create(data['value'] + '.'))
+
+    test_scenario(data, data['fqdn'], type, expected)
+  end
+
   private
 
   def test_scenario(data, name, type, expected)
@@ -40,9 +56,11 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
       response = http.request request
       assert_equal(200, response.code.to_i)
 
+      assert(purge_cache name)
+
       assert_equal([expected], resolver.getresources(name, type))
 
-      request = Net::HTTP::Delete.new(smart_proxy_url + 'dns/' + name)
+      request = Net::HTTP::Delete.new("#{smart_proxy_url}dns/#{name}/#{type.to_s.split("::").last}")
       response = http.request request
       assert_equal(200, response.code.to_i)
 
@@ -53,7 +71,7 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
   end
 
   def resolver
-    Resolv::DNS.new(:nameserver_port => [['127.0.0.1', 5300]])
+    Resolv::DNS.new(:nameserver_port => [['127.0.0.1', 53]])
   end
 
   def smart_proxy_url
@@ -75,6 +93,8 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
 
   def purge_cache name
     %x{#{ENV['PDNS_CONTROL'] || "pdns_control"} purge "#{name}"}
-    $? == 0
+    # Default pdns packet cache is 60 seconds, if purging failed we wait for it
+    sleep 60 unless $? == 0
+    true
   end
 end

data/test/test_helper.rb

@@ -1,3 +1,6 @@
+require 'coveralls'
+Coveralls.wear!
+
 require 'test/unit'
 require 'mocha/setup'
 require 'json'

data/test/unit/dns_powerdns_configuration_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+
+require 'smart_proxy_dns_powerdns/dns_powerdns_configuration'
+require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+
+
+class DnsPowerdnsProductionWiringTest < Test::Unit::TestCase
+  def setup
+    @container = ::Proxy::DependencyInjection::Container.new
+    @config = ::Proxy::Dns::Powerdns::PluginConfiguration.new
+  end
+
+  def test_dns_provider_initialization_mysql_backend_minimal_settings
+    @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                              :powerdns_backend => 'mysql')
+
+    provider = @container.get_dependency(:dns_provider)
+
+    assert_not_nil provider
+    assert_equal 999, provider.ttl
+    assert_equal 'localhost', provider.hostname
+    assert_equal 'powerdns', provider.username
+    assert_equal '', provider.password
+    assert_equal 'pdns', provider.database
+  end
+
+  def test_dns_provider_initialization_mysql_backend_full_settings
+    @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                              :powerdns_backend => 'mysql',
+                                              :powerdns_mysql_hostname => 'db.example.com',
+                                              :powerdns_mysql_username => 'user',
+                                              :powerdns_mysql_password => 'super secret',
+                                              :powerdns_mysql_database => 'the_db',
+                                             )
+
+    provider = @container.get_dependency(:dns_provider)
+
+    assert_not_nil provider
+    assert_equal 999, provider.ttl
+    assert_equal 'db.example.com', provider.hostname
+    assert_equal 'user', provider.username
+    assert_equal 'super secret', provider.password
+    assert_equal 'the_db', provider.database
+  end
+
+  def test_dns_provider_initialization_postgresql_backend_minimal_settings
+    @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                              :powerdns_backend => 'postgresql')
+
+    provider = @container.get_dependency(:dns_provider)
+
+    assert_not_nil provider
+    assert_equal 999, provider.ttl
+    assert_equal 'dbname=pdns', provider.connection_str
+  end
+
+  def test_dns_provider_initialization_postgresql_backend_full_settings
+    @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                              :powerdns_backend => 'postgresql',
+                                              :powerdns_postgresql_connection => 'dbname=powerdns')
+
+    provider = @container.get_dependency(:dns_provider)
+
+    assert_not_nil provider
+    assert_equal 999, provider.ttl
+    assert_equal 'dbname=powerdns', provider.connection_str
+  end
+
+  def test_dns_provider_initialization_rest_backend_invalid_settings
+    assert_raise Proxy::Error::ConfigurationError do
+      @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                                :powerdns_backend => 'rest')
+    end
+  end
+
+  def test_dns_provider_initialization_rest_backend_minimal_settings
+    @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                              :powerdns_backend => 'rest',
+                                              :powerdns_rest_api_key => 'apikey')
+
+    provider = @container.get_dependency(:dns_provider)
+
+    assert_not_nil provider
+    assert_equal 999, provider.ttl
+    assert_equal 'http://localhost:8081/api/v1/servers/localhost', provider.url
+    assert_equal 'apikey', provider.api_key
+  end
+
+  def test_dns_provider_initialization_rest_backend_full_settings
+    @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                              :powerdns_backend => 'rest',
+                                              :powerdns_rest_url => 'http://apiserver',
+                                              :powerdns_rest_api_key => 'apikey')
+
+    provider = @container.get_dependency(:dns_provider)
+
+    assert_not_nil provider
+    assert_equal 999, provider.ttl
+    assert_equal 'http://apiserver', provider.url
+    assert_equal 'apikey', provider.api_key
+  end
+
+  def test_dns_provider_initialization_dummy_backend
+    @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                              :powerdns_backend => 'dummy')
+
+    provider = @container.get_dependency(:dns_provider)
+
+    assert_not_nil provider
+    assert_equal 999, provider.ttl
+  end
+
+  def test_dns_provider_initialization_invalid_backend
+    assert_raise Proxy::Error::ConfigurationError do
+      @config.load_dependency_injection_wirings(@container, :dns_ttl => 999,
+                                                :powerdns_backend => 'invalid')
+    end
+  end
+end

data/test/unit/dns_powerdns_record_dummy_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+require 'smart_proxy_dns_powerdns/backend/dummy'
+
+class DnsPowerdnsBackendDummyTest < Test::Unit::TestCase
+  def setup
+    @provider = Proxy::Dns::Powerdns::Backend::Dummy.new('localhost', 86400)
+  end
+
+  def test_initialize
+    assert_equal 86400, @provider.ttl
+  end
+
+  def test_get_zone
+    assert_equal @provider.get_zone('test.example.com'), {'id' => 1, 'name' => 'example.com'}
+  end
+
+  def test_create_record
+    assert_false @provider.create_record(1, 'test.example.com', '10.1.2.3', 'A')
+  end
+
+  def test_delete_record
+    assert_false @provider.delete_record(1, 'test.example.com', 'A')
+  end
+end

data/test/unit/dns_powerdns_record_mysql_test.rb

@@ -1,77 +1,57 @@
 require 'test_helper'
 
-require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
 require 'smart_proxy_dns_powerdns/dns_powerdns_main'
 require 'smart_proxy_dns_powerdns/backend/mysql'
 
 class DnsPowerdnsBackendMysqlTest < Test::Unit::TestCase
-  # Test that correct initialization works
-  def test_initialize_dummy_with_settings
-    Proxy::Dns::Powerdns::Plugin.load_test_settings(
-      :powerdns_mysql_hostname => 'db.example.com',
-      :powerdns_mysql_username => 'the_user',
-      :powerdns_mysql_password => 'something_secure',
-      :powerdns_mysql_database => 'db_pdns'
-    )
-    provider = klass.new
-    assert_equal 'db.example.com', provider.hostname
-    assert_equal 'the_user', provider.username
-    assert_equal 'something_secure', provider.password
-    assert_equal 'db_pdns', provider.database
+  def setup
+    @provider = Proxy::Dns::Powerdns::Backend::Mysql.new('localhost', 86400, 'sudo pdnssec',
+                                                         'db.example.com', 'the_user',
+                                                         'something_secure', 'db_pdns')
+    @connection = mock()
+    @provider.stubs(:connection).returns(@connection)
   end
 
-  def test_get_zone_with_existing_zone
-    instance = klass.new
+  def test_initialize
+    assert_equal 86400, @provider.ttl
+    assert_equal 'sudo pdnssec', @provider.pdnssec
+    assert_equal 'db.example.com', @provider.hostname
+    assert_equal 'the_user', @provider.username
+    assert_equal 'something_secure', @provider.password
+    assert_equal 'db_pdns', @provider.database
+  end
 
-    connection = mock()
-    instance.stubs(:connection).returns(connection)
-    connection.expects(:escape).with('test.example.com').returns('test.example.com')
-    connection.expects(:query).with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE 'test.example.com' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").returns([{'id' => 1, 'name' => 'example.com'}])
+  def test_get_zone_with_existing_zone
+    @connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    @connection.expects(:query).with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE 'test.example.com' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").returns([{'id' => 1, 'name' => 'example.com'}])
 
-    assert_equal(instance.get_zone('test.example.com'), {'id' => 1, 'name' => 'example.com'})
+    assert_equal(@provider.get_zone('test.example.com'), {'id' => 1, 'name' => 'example.com'})
   end
 
   def test_get_zone_without_existing_zone
-    instance = klass.new
-
-    connection = mock()
-    instance.stubs(:connection).returns(connection)
-    connection.expects(:escape).with('test.example.com').returns('test.example.com')
-    connection.expects(:query).with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE 'test.example.com' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").returns([])
+    @connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    @connection.expects(:query).with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE 'test.example.com' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").returns([])
 
-    assert_raise(Proxy::Dns::Error) { instance.get_zone('test.example.com') }
+    assert_raise(Proxy::Dns::Error) { @provider.get_zone('test.example.com') }
   end
 
   def test_create_record
-    instance = klass.new
+    @connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    @connection.expects(:escape).with('A').returns('A')
+    @connection.expects(:escape).with('10.1.1.1').returns('10.1.1.1')
+    @connection.expects(:query).with("INSERT INTO records (domain_id, name, ttl, content, type) VALUES (1, 'test.example.com', 86400, '10.1.1.1', 'A')")
+    @connection.expects(:affected_rows).returns(1)
 
-    connection = mock()
-    instance.stubs(:connection).returns(connection)
-    connection.expects(:escape).with('test.example.com').returns('test.example.com')
-    connection.expects(:escape).with('A').returns('A')
-    connection.expects(:escape).with('10.1.1.1').returns('10.1.1.1')
-    connection.expects(:query).with("INSERT INTO records (domain_id, name, ttl, content, type) VALUES (1, 'test.example.com', 86400, '10.1.1.1', 'A')")
-    connection.expects(:affected_rows).returns(1)
-
-    assert instance.create_record(1, 'test.example.com', 'A', '10.1.1.1')
+    assert @provider.create_record(1, 'test.example.com', 'A', '10.1.1.1')
   end
 
   def test_delete_record
-    instance = klass.new
-
-    connection = mock()
-    instance.stubs(:connection).returns(connection)
-    connection.expects(:escape).with('test.example.com').returns('test.example.com')
-    connection.expects(:escape).with('A').returns('A')
-    connection.expects(:query).with("DELETE FROM records WHERE domain_id=1 AND name='test.example.com' AND type='A'")
-    connection.expects(:affected_rows).returns(1)
+    @connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    @connection.expects(:escape).with('A').returns('A')
+    @connection.expects(:query).with("DELETE FROM records WHERE domain_id=1 AND name='test.example.com' AND type='A'")
+    @connection.expects(:affected_rows).returns(1)
 
-    assert instance.delete_record(1, 'test.example.com', 'A')
+    assert @provider.delete_record(1, 'test.example.com', 'A')
   end
 
-  private
-
-  def klass
-    Proxy::Dns::Powerdns::Backend::Mysql
-  end
 end

data/test/unit/dns_powerdns_record_postgresql_test.rb

@@ -1,20 +1,67 @@
 require 'test_helper'
 
-require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
 require 'smart_proxy_dns_powerdns/dns_powerdns_main'
 require 'smart_proxy_dns_powerdns/backend/postgresql'
 
 class DnsPowerdnsBackendPostgresqlTest < Test::Unit::TestCase
-  # Test that correct initialization works
-  def test_initialize_dummy_with_settings
-    Proxy::Dns::Powerdns::Plugin.load_test_settings(:powerdns_postgresql_connection => 'dbname=powerdns')
-    provider = klass.new
-    assert_equal 'dbname=powerdns', provider.connection_str
+  def setup
+    @provider = Proxy::Dns::Powerdns::Backend::Postgresql.new('localhost', 86400, 'sudo pdnssec',
+                                                              'dbname=powerdns')
+    @connection = mock()
+    @provider.stubs(:connection).returns(@connection)
   end
 
-  private
+  def test_initialize
+    assert_equal 86400, @provider.ttl
+    assert_equal 'sudo pdnssec', @provider.pdnssec
+    assert_equal 'dbname=powerdns', @provider.connection_str
+  end
+
+  def test_get_zone_with_existing_zone
+    @connection.expects(:exec_params).
+      with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE $1 LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1", ['test.example.com']).
+      yields([{'id' => 1, 'name' => 'example.com'}])
+
+    assert_equal(@provider.get_zone('test.example.com'), {'id' => 1, 'name' => 'example.com'})
+  end
+
+  def test_get_zone_without_existing_zone
+    @connection.expects(:exec_params).
+      with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE $1 LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1", ['test.example.com']).
+      yields([])
+
+    assert_raise(Proxy::Dns::Error) { @provider.get_zone('test.example.com') }
+  end
+
+  def test_create_record
+    @connection.expects(:exec_params).
+      with("INSERT INTO records (domain_id, name, ttl, content, type) VALUES ($1::int, $2, $3::int, $4, $5)", [1, 'test.example.com', 86400, '10.1.1.1', 'A']).
+      returns(mock(:cmdtuples => 1))
+
+    assert_true @provider.create_record(1, 'test.example.com', 'A', '10.1.1.1')
+  end
+
+  def test_delete_record_no_records
+    @connection.expects(:exec_params).
+      with("DELETE FROM records WHERE domain_id=$1::int AND name=$2 AND type=$3", [1, 'test.example.com', 'A']).
+      returns(mock(:cmdtuples => 0))
+
+    assert_false @provider.delete_record(1, 'test.example.com', 'A')
+  end
+
+  def test_delete_record_single_record
+    @connection.expects(:exec_params).
+      with("DELETE FROM records WHERE domain_id=$1::int AND name=$2 AND type=$3", [1, 'test.example.com', 'A']).
+      returns(mock(:cmdtuples => 1))
+
+    assert_true @provider.delete_record(1, 'test.example.com', 'A')
+  end
+
+  def test_delete_record_multiple_records
+    @connection.expects(:exec_params).
+      with("DELETE FROM records WHERE domain_id=$1::int AND name=$2 AND type=$3", [1, 'test.example.com', 'A']).
+      returns(mock(:cmdtuples => 2))
 
-  def klass
-    Proxy::Dns::Powerdns::Backend::Postgresql
+    assert_true @provider.delete_record(1, 'test.example.com', 'A')
   end
 end

data/test/unit/dns_powerdns_record_rest_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'webmock/test_unit'
+
+require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+require 'smart_proxy_dns_powerdns/backend/rest'
+
+class DnsPowerdnsBackendRestTest < Test::Unit::TestCase
+  def setup
+    @provider = Proxy::Dns::Powerdns::Backend::Rest.new('localhost', 86400,
+                                                        'http://localhost:8081/api/v1/servers/localhost',
+                                                        'apikey')
+  end
+
+  def test_initialize
+    assert_equal 86400, @provider.ttl
+    assert_equal 'http://localhost:8081/api/v1/servers/localhost', @provider.url
+    assert_equal 'apikey', @provider.api_key
+  end
+
+  def test_get_zone_with_existing_zone
+    stub_request(:get, "http://localhost:8081/api/v1/servers/localhost/zones").
+      with(:headers => {'X-Api-Key' => 'apikey'}).
+      to_return(:body => '[{"id": "example.com.", "name": "example.com."}]')
+    assert_equal @provider.get_zone('test.example.com'), {'id' => 'example.com.', 'name' => 'example.com.'}
+  end
+
+  def test_get_zone_with_existing_zone_absolute_record
+    stub_request(:get, "http://localhost:8081/api/v1/servers/localhost/zones").
+      with(:headers => {'X-Api-Key' => 'apikey'}).
+      to_return(:body => '[{"id": "example.com.", "name": "example.com."}]')
+    assert_equal @provider.get_zone('test.example.com.'), {'id' => 'example.com.', 'name' => 'example.com.'}
+  end
+
+  def test_get_zone_without_existing_zone
+    stub_request(:get, "http://localhost:8081/api/v1/servers/localhost/zones").
+      with(:headers => {'X-Api-Key' => 'apikey'}).
+      to_return(:body => '[]')
+    assert_raise(Proxy::Dns::Error) { @provider.get_zone('test.example.com') }
+  end
+
+  def test_create_a_record
+    stub_request(:patch, "http://localhost:8081/api/v1/servers/localhost/zones/example.com.").
+      with(
+        :headers => {'X-Api-Key' => 'apikey', 'Content-Type' => 'application/json'},
+        :body => '{"rrsets":[{"name":"test.example.com.","type":"A","ttl":86400,"changetype":"REPLACE","records":[{"content":"10.1.1.1","disabled":false}]}]}'
+      )
+    assert @provider.create_record('example.com.', 'test.example.com', 'A', '10.1.1.1')
+  end
+
+  def test_create_ptr_record
+    stub_request(:patch, "http://localhost:8081/api/v1/servers/localhost/zones/example.com.").
+      with(
+        :headers => {'X-Api-Key' => 'apikey', 'Content-Type' => 'application/json'},
+        :body => '{"rrsets":[{"name":"1.1.1.10.in-addr.arpa.","type":"PTR","ttl":86400,"changetype":"REPLACE","records":[{"content":"test.example.com.","disabled":false}]}]}'
+      )
+    assert @provider.create_record('example.com.', '1.1.1.10.in-addr.arpa', 'PTR', 'test.example.com')
+  end
+
+  def test_delete_record
+    stub_request(:patch, "http://localhost:8081/api/v1/servers/localhost/zones/example.com.").
+      with(
+        :headers => {'X-Api-Key' => 'apikey', 'Content-Type' => 'application/json'},
+        :body => '{"rrsets":[{"name":"test.example.com.","type":"A","changetype":"DELETE","records":[]}]}'
+      )
+    assert @provider.delete_record('example.com.', 'test.example.com', 'A')
+  end
+end