smart_proxy_dns_powerdns 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91fabd73d9aa9962f5117f82375dbf50ebd42f1535ab1162b18f5af6eccb20a1
-  data.tar.gz: ebcaed367e7e65a911d8711e881ff9471e7ef731015cf4c7935ba330b8f464ea
+  metadata.gz: cc2eb76a5e55de4041e57fd29bd4172673c8a643d89a56a0b264c31e4e245662
+  data.tar.gz: '08bcd7294a28f78ad53ff55f58dd4ab86556073125a5bbe7c9178680084a9393'
 SHA512:
-  metadata.gz: 49e9f311cc142d0daf1ff414d715c52950e4ff3d599c267fae33932648aa8578fbd2b1ce8e298c4d4425e7d60e6dcc69b9c63a98d3fff2c3107558914af87c53
-  data.tar.gz: d21fc640d1f82569fa90718912ebca748c17a66caef9ba8966cb1c1e65a01179a0eea692e9f4f727e215577bb1143b58ad32a49f82b6cb2086b2573a9571fbee
+  metadata.gz: 6c8184da940ba90aed1a4d0c5680fdcc87a8daef6647b961f4c9f87540a95e5d3e66095534b8bcf96fc7cffae2099ce69106e781961de5a60b5a85d1f0741dda
+  data.tar.gz: 3ab24a84d7a51006275d8425609b0cb0c4ba82f011b54ad3c18f768e8b0425b01fce0afcf605f91d6cc206f5bdbbe2170ae4017ebd1815bc5538a8a741c06db0

data/README.md

@@ -19,6 +19,10 @@ When installing using "gem", make sure to install the bundle file:
 
 ## Upgrading
 
+### 0.5.0
+
+* The multiple backends have been dropped and only REST is still supported.
+
 ### 0.4.0
 
 * The minimum Smart Proxy version is now 1.15
@@ -51,56 +55,11 @@ To use the REST backend, set the following parameters:
 
 **Note** only API v1 from PowerDNS 4.x is supported. The v0 API from 3.x is unsupported.
 
-### DNSSEC with REST
-
-Domains in PowerDNS need a rectify action after modification. In the past this was done using pdnsutil (which can still be set) but since PowerDNS 4.1.0 the API can do this automatically. The [domain metadata API-RECTIFY](https://doc.powerdns.com/authoritative/domainmetadata.html#metadata-api-rectify) needs to be set to `1`. When it's unset, the config variable [default-api-rectify](https://doc.powerdns.com/authoritative/settings.html#setting-default-api-rectify) will be used. PowerDNS 4.2.0 started to default to true. When this is used, the value for `:powerdns_pdnssec` in this plugin should be empty (default).
-
-### MySQL
-
-To use MySQL, set the following parameters:
-
-    :powerdns_backend: 'mysql'
-    :powerdns_mysql_hostname: 'localhost'
-    :powerdns_mysql_username: 'powerdns'
-    :powerdns_mysql_password: ''
-    :powerdns_mysql_database: 'powerdns'
-
-**Note** use of this backend is deprecated. REST should be used.
-
-### PostgreSQL
-
-To use PostgreSQL, set the following parameters:
-
-    :powerdns_backend: 'postgresql'
-    :powerdns_postgresql_connection: 'host=localhost user=powerdns password=mypassword dbname=powerdns'
-
-**Note** use of this backend is deprecated. REST should be used.
-
-### DNSSEC with MySQL and PostgreSQL
-
-In case you've enabled DNSSEC (as you should), all database backends require a rectify-zone after every zone change. The REST backend ignores this setting. The pdnssec command is configurable:
-
-    :powerdns_pdnssec: 'pdnsutil'
-
-Or a more complex example:
-
-    :powerdns_pdnssec: 'sudo pdnsutil --config-name=myconfig'
-
-Note that PowerDNS 3.x used `pdnssec` rather than `pdnsutil` which explains the naming of the option.
-
-### SOA autoserial with MySQL and PostgreSQL
-
-PowerDNS (>= 3.3) provides a feature called `autoserial` that takes care of managing the serial of `SOA` records.
-
-There are many options available regarding how PowerDNS generates the serial and details can be found looking for the `SOA-EDIT` option in PowerDNS.
-
-One option is to let the PowerDNS backend determine the `SOA` serial using the biggest `change_date` of the records associated with the DNS domain.
-`smart_proxy_dns_powerdns` uses this approach and updates the `change_date` field of changed records, setting them to the current timestamp of the database server, represented as **the number of seconds since EPOCH**.
+### Domain rectification
 
-* when a new record is created, its `change_date` is set accordingly
-* when a record is deleted, the `change_date` of the `SOA` record for the domain is updated
+Domains in PowerDNS need a rectify action after modification. In the past this was done using pdnsutil but since PowerDNS 4.1.0 the API can do this automatically. The [domain metadata API-RECTIFY](https://doc.powerdns.com/authoritative/domainmetadata.html#metadata-api-rectify) needs to be set to `1`. When it's unset, the config variable [default-api-rectify](https://doc.powerdns.com/authoritative/settings.html#setting-default-api-rectify) will be used. PowerDNS 4.2.0 started to default to true.
 
-### Updating the SOA serial when using the REST backend
+### Updating the SOA serial
 
 When using the REST backend, the `change_date` of records isn't modified by this plugin.  To automatically increment the serial number of a zone, you can configure the [SOA-EDIT-API](https://doc.powerdns.com/authoritative/domainmetadata.html#soa-edit-api) zone metadata.  For example:
 

data/config/dns_powerdns.yml

@@ -3,8 +3,5 @@
 # Configuration file for 'dns_powerdns' dns provider
 #
 
-# use these settings for powerdns
-#:powerdns_mysql_hostname:
-#:powerdns_mysql_username:
-#:powerdns_mysql_password:
-#:powerdns_mysql_database:
+#:powerdns_rest_url: "http://localhost:8081/api/v1/servers/localhost"
+#:powerdns_rest_api_key: ""

data/lib/smart_proxy_dns_powerdns/dns_powerdns_configuration.rb

@@ -6,59 +6,14 @@ module ::Proxy::Dns::Powerdns
     end
 
     def load_dependency_injection_wirings(container_instance, settings)
-      valid_backends = ['mysql', 'postgresql', 'rest', 'dummy']
-      backend = settings[:powerdns_backend]
-      unless valid_backends.include?(backend)
-        raise ::Proxy::Error::ConfigurationError.new("Invalid backend, is expected to be mysql, postgresql, rest or dummy")
-      end
-
-      begin
-        require "smart_proxy_dns_powerdns/backend/#{backend}"
-      rescue LoadError, e
-        raise ::Proxy::Error::ConfigurationError.new("Failed to load backend #{backend}: #{e}")
-      end
-
-      case backend
-      when 'mysql'
-        container_instance.dependency :dns_provider, (lambda do
-          Proxy::Dns::Powerdns::Backend::Mysql.new(
-              settings[:dns_server],
-              settings[:dns_ttl],
-              settings[:powerdns_pdnssec],
-              settings[:powerdns_mysql_hostname] || 'localhost',
-              settings[:powerdns_mysql_username] || 'powerdns',
-              settings[:powerdns_mysql_password] || '',
-              settings[:powerdns_mysql_database] || 'pdns',
-          )
-        end)
-      when 'postgresql'
-        container_instance.dependency :dns_provider, (lambda do
-          Proxy::Dns::Powerdns::Backend::Postgresql.new(
-            settings[:dns_server],
-            settings[:dns_ttl],
-            settings[:powerdns_pdnssec],
-            settings[:powerdns_postgresql_connection] || 'dbname=pdns',
+      container_instance.dependency :dns_provider, (lambda do
+        Proxy::Dns::Powerdns::Record.new(
+          settings[:dns_server],
+          settings[:dns_ttl],
+          settings[:powerdns_rest_url],
+          settings[:powerdns_rest_api_key],
         )
-        end)
-      when 'rest'
-        raise ::Proxy::Error::ConfigurationError.new("Setting powerdns_rest_api_key must be non-empty") unless settings[:powerdns_rest_api_key]
-
-        container_instance.dependency :dns_provider, (lambda do
-          Proxy::Dns::Powerdns::Backend::Rest.new(
-            settings[:dns_server],
-            settings[:dns_ttl],
-            settings[:powerdns_rest_url] || 'http://localhost:8081/api/v1/servers/localhost',
-            settings[:powerdns_rest_api_key],
-          )
-        end)
-      when 'dummy'
-        container_instance.dependency :dns_provider, (lambda do
-          Proxy::Dns::Powerdns::Backend::Dummy.new(
-            settings[:dns_server],
-            settings[:dns_ttl],
-          )
-        end)
-      end
+      end)
     end
   end
 end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_main.rb

@@ -6,18 +6,18 @@ module Proxy::Dns::Powerdns
     include Proxy::Log
     include Proxy::Util
 
-    attr_reader :pdnssec
+    attr_reader :url, :api_key
+
+    def initialize(a_server, a_ttl, url, api_key)
+      @url = url
+      @api_key = api_key
 
-    def initialize(a_server, a_ttl, pdnssec = nil)
-      @pdnssec = pdnssec
       super(a_server, a_ttl)
     end
 
     def do_create(name, value, type)
       zone = get_zone(name)
-      if create_record(zone['id'], name, type, value)
-        raise Proxy::Dns::Error.new("Failed to rectify zone #{zone['name']}") unless rectify_zone(zone['name'])
-      else
+      unless create_record(zone['id'], name, type, value)
         raise Proxy::Dns::Error.new("Failed to insert record #{name} #{type} #{value}")
       end
       true
@@ -25,43 +25,85 @@ module Proxy::Dns::Powerdns
 
     def do_remove(name, type)
       zone = get_zone(name)
-      if delete_record(zone['id'], name, type)
-        raise Proxy::Dns::Error.new("Failed to rectify zone #{name}") unless rectify_zone(zone['name'])
-      end
-      true
+      delete_record(zone['id'], name, type)
     end
 
-    # :nocov:
-    def get_zone(name)
-      # TODO: backend specific
-      raise Proxy::Dns::Error, "Unable to determine zone for #{name}. Zone must exist in PowerDNS."
+    def get_zone name
+      fqdn = Resolv::DNS::Name.create(name)
+      fqdn = Resolv::DNS::Name.create(name + '.') unless fqdn.absolute?
+      uri = URI("#{@url}/zones")
+
+      result = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        request = Net::HTTP::Get.new uri
+        request['X-API-Key'] = @api_key
+        response = http.request request
+        zones = JSON.parse(response.body) rescue []
+
+        zones.select { |zone|
+          domain = Resolv::DNS::Name.create(zone['name'])
+          domain == fqdn or fqdn.subdomain_of?(domain)
+        }.max_by { |zone| zone['name'].length }
+      end
+
+      raise Proxy::Dns::Error, "Unable to determine zone for #{name}. Zone must exist in PowerDNS." unless result
+
+      result
     end
 
-    def create_record(domain_id, name, type, content)
-      # TODO: backend specific
-      false
+    def create_record domain_id, name, type, content
+      content += '.' if ['PTR', 'CNAME'].include?(type)
+      rrset = {
+        :name => name + '.',
+        :type => type,
+        :ttl => @ttl.to_i,
+        :changetype => :REPLACE,
+        :records => [
+          {
+            :content => content,
+            :disabled => false
+          }
+        ]
+      }
+
+      patch_records domain_id, rrset
     end
 
-    def delete_record(domain_id, name, type)
-      # TODO: backend specific
-      false
+    def delete_record domain_id, name, type
+      rrset = {
+        :name => name + '.',
+        :type => type,
+        :changetype => :DELETE,
+        :records => []
+      }
+
+      patch_records domain_id, rrset
     end
-    # :nocov:
-
-    def rectify_zone domain
-      if @pdnssec
-        logger.debug("running: #{@pdnssec} rectify-zone \"#{domain}\"")
-        pdnsout = %x(#{@pdnssec} rectify-zone "#{domain}" 2>&1)
-
-        if $?.exitstatus != 0
-          logger.debug("#{@pdnssec} (exit: #{$?.exitstatus}) says: #{pdnsout}")
-          false
-        else
-          true
+
+    private
+
+    def patch_records domain_id, rrset
+      uri = URI("#{@url}/zones/#{domain_id}")
+
+      data = { :rrsets => [rrset] }
+
+      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        request = Net::HTTP::Patch.new uri
+        request['X-API-Key'] = @api_key
+        request['Content-Type'] = 'application/json'
+        request.body = data.to_json
+        response = http.request request
+        unless response.is_a?(Net::HTTPSuccess)
+          begin
+            content = JSON.parse(response.body)
+          rescue
+            logger.debug "Failed to pach records for #{domain_id} with '#{rrset}': #{response.body}"
+            raise Proxy::Dns::Error.new("Failed to patch records")
+          end
+          raise Proxy::Dns::Error.new("Failed to patch records: #{content['error']}")
         end
-      else
-        true
       end
+
+      true
     end
   end
 end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_plugin.rb

@@ -7,7 +7,8 @@ module Proxy::Dns::Powerdns
 
     requires :dns, '>= 1.15'
 
-    validate_presence :powerdns_backend
+    validate_presence :powerdns_rest_api_key
+    default_settings :powerdns_rest_url => 'http://localhost:8081/api/v1/servers/localhost'
 
     load_classes ::Proxy::Dns::Powerdns::PluginConfiguration
     load_dependency_injection_wirings ::Proxy::Dns::Powerdns::PluginConfiguration

data/lib/smart_proxy_dns_powerdns/dns_powerdns_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module Dns
     module Powerdns
-      VERSION = '0.4.0'
+      VERSION = '1.0.0'
     end
   end
 end

data/test/unit/dns_powerdns_configuration_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'webmock/test_unit'
 
 require 'smart_proxy_dns_powerdns/dns_powerdns_configuration'
 require 'smart_proxy_dns_powerdns/dns_powerdns_main'
@@ -10,110 +11,16 @@ class DnsPowerdnsProductionWiringTest < Test::Unit::TestCase
     @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_url => 'http://apiserver.example.com',
                                               :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 'http://apiserver.example.com', 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_test.rb

@@ -4,18 +4,20 @@ require 'smart_proxy_dns_powerdns/dns_powerdns_main'
 
 class DnsPowerdnsRecordTest < Test::Unit::TestCase
   def setup
-    @provider = Proxy::Dns::Powerdns::Record.new('localhost', 86400, 'echo pdnssec')
+    @provider = Proxy::Dns::Powerdns::Record.new('localhost', 86400,
+                                                 'http://localhost:8081/api/v1/servers/localhost',
+                                                 'apikey')
   end
 
   def test_initialize
     assert_equal 86400, @provider.ttl
-    assert_equal 'echo pdnssec', @provider.pdnssec
+    assert_equal 'http://localhost:8081/api/v1/servers/localhost', @provider.url
+    assert_equal 'apikey', @provider.api_key
   end
 
   def test_do_create_success
     @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 @provider.do_create('test.example.com', '10.1.1.1', 'A')
   end
@@ -29,44 +31,58 @@ class DnsPowerdnsRecordTest < Test::Unit::TestCase
     end
   end
 
-  def test_do_create_failure_in_rectify
-    @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(false)
-
-    assert_raise(Proxy::Dns::Error) do
-      @provider.do_create('test.example.com', '10.1.1.1', 'A')
-    end
-  end
-
   def test_do_remove
     @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 @provider.do_remove('test.example.com', 'A')
   end
 
-  def test_rectify_zone_success
-    @provider.logger.expects(:debug).with('running: echo pdnssec rectify-zone "example.com"')
-
-    assert_true @provider.rectify_zone 'example.com'
+  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_rectify_zone_failure
-    @provider = Proxy::Dns::Powerdns::Record.new('localhost', 86400, 'false')
-
-    @provider.logger.expects(:debug).with('running: false rectify-zone "example.com"')
-    @provider.logger.expects(:debug).with('false (exit: 1) says: ')
+  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
 
-    assert_false @provider.rectify_zone 'example.com'
+  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_rectify_zone_no_pdnssec
-    @provider = Proxy::Dns::Powerdns::Record.new('localhost', 86400, nil)
+  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
 
-    @provider.logger.stubs(:debug).raises(Exception)
+  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
 
-    assert_true @provider.rectify_zone 'example.com'
+  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

data/test/unit/internal_api_test.rb

@@ -26,11 +26,11 @@ class InternalApiTest < Test::Unit::TestCase
   end
 
   def setup
-    @server = Proxy::Dns::Powerdns::Record.new('localhost', 3600)
+    @server = Proxy::Dns::Powerdns::Record.new('localhost', 3600, 'http://powerdns.example.com:8081/', 'apikey')
   end
 
   def test_create_a_record
-    name = "test.com"
+    name = "sub.example.com"
     value = "192.168.33.33"
     type = "A"
     @server.expects(:do_create).with(name, value, type)
@@ -39,7 +39,7 @@ class InternalApiTest < Test::Unit::TestCase
   end
 
   def test_create_ptr_record
-    name = "test.com"
+    name = "sub.example.com"
     value = "33.33.168.192.in-addr.arpa"
     type = "PTR"
     @server.expects(:do_create).with(value, name, type)
@@ -48,7 +48,7 @@ class InternalApiTest < Test::Unit::TestCase
   end
 
   def test_delete_a_record
-    name = "test.com"
+    name = "sub.example.com"
     @server.expects(:do_remove).with(name, "A")
     delete name
     assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dns_powerdns
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ewoud Kohl van Wijngaarden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-13 00:00:00.000000000 Z
+date: 2020-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,34 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: PowerDNS DNS provider plugin for Foreman's smart proxy
 email:
 - ewoud@kohlvanwijngaarden.nl
@@ -78,10 +50,6 @@ files:
 - bundler.d/dns_powerdns.rb
 - config/dns_powerdns.yml
 - lib/smart_proxy_dns_powerdns.rb
-- 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/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
@@ -89,10 +57,6 @@ files:
 - test/integration/integration_test.rb
 - test/test_helper.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
 - test/unit/internal_api_test.rb
 homepage: https://github.com/theforeman/smart_proxy_dns_powerdns
@@ -119,12 +83,8 @@ signing_key:
 specification_version: 4
 summary: PowerDNS DNS provider plugin for Foreman's smart proxy
 test_files:
-- test/unit/dns_powerdns_record_rest_test.rb
 - test/unit/dns_powerdns_record_test.rb
-- test/unit/dns_powerdns_record_mysql_test.rb
 - test/unit/dns_powerdns_configuration_test.rb
 - test/unit/internal_api_test.rb
-- test/unit/dns_powerdns_record_postgresql_test.rb
-- test/unit/dns_powerdns_record_dummy_test.rb
 - test/test_helper.rb
 - test/integration/integration_test.rb

data/lib/smart_proxy_dns_powerdns/backend/dummy.rb

@@ -1,24 +0,0 @@
-module Proxy::Dns::Powerdns::Backend
-  class Dummy < ::Proxy::Dns::Powerdns::Record
-
-    def initialize(a_server, a_ttl)
-      super(a_server, a_ttl)
-    end
-
-    def get_zone name
-      {
-        'id'   => 1,
-        'name' => name.partition('.')[2]
-      }
-    end
-
-    def create_record domain_id, name, content, type
-      false
-    end
-
-    def delete_record domain_id, name, type
-      false
-    end
-  end
-end
-

data/lib/smart_proxy_dns_powerdns/backend/mysql.rb

@@ -1,58 +0,0 @@
-require 'mysql2'
-
-module Proxy::Dns::Powerdns::Backend
-  class Mysql < ::Proxy::Dns::Powerdns::Record
-
-    attr_reader :hostname, :username, :password, :database
-
-    def initialize(a_server, a_ttl, pdnssec, hostname, username, password, database)
-      @hostname = hostname
-      @username = username
-      @password = password
-      @database = database
-
-      super(a_server, a_ttl, pdnssec)
-    end
-
-    def connection
-      @connection ||= Mysql2::Client.new(:host => hostname, :username => username, :password => password, :database => database)
-    end
-
-    def get_zone name
-      domain = nil
-
-      name = connection.escape(name)
-      connection.query("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE '#{name}' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").each do |row|
-        domain = row
-      end
-
-      raise Proxy::Dns::Error, "Unable to determine zone for #{name}. Zone must exist in PowerDNS." unless domain
-
-      domain
-    end
-
-    def create_record domain_id, name, type, content
-      name = connection.escape(name)
-      content = connection.escape(content)
-      type = connection.escape(type)
-      connection.query("INSERT INTO records (domain_id, name, ttl, content, type, change_date) VALUES (#{domain_id}, '#{name}', #{ttl.to_i}, '#{content}', '#{type}', UNIX_TIMESTAMP())")
-      connection.affected_rows == 1
-    end
-
-    def delete_record domain_id, name, type
-      name = connection.escape(name)
-      type = connection.escape(type)
-      connection.query("DELETE FROM records WHERE domain_id=#{domain_id} AND name='#{name}' AND type='#{type}'")
-      return false if connection.affected_rows == 0
-
-      connection.query("UPDATE records SET change_date=UNIX_TIMESTAMP() WHERE domain_id=#{domain_id} AND type='SOA'")
-      affected_rows = connection.affected_rows
-      if affected_rows > 1
-        logger.warning("Updated multiple SOA records (host=#{name}, domain_id=#{domain_id}). Check your zone records for duplicate SOA entries.")
-      elsif affected_rows == 0
-        logger.info("No SOA record updated (host=#{name}, domain_id=#{domain_id}). This can be caused by either a missing SOA record for the zone or consecutive updates of the same zone during the same second.")
-      end
-      true
-    end
-  end
-end

data/lib/smart_proxy_dns_powerdns/backend/postgresql.rb

@@ -1,51 +0,0 @@
-require 'pg'
-
-module Proxy::Dns::Powerdns::Backend
-  class Postgresql < ::Proxy::Dns::Powerdns::Record
-
-    attr_reader :connection_str
-
-    def initialize(a_server, a_ttl, pdnssec, connection)
-      @connection_str = connection
-
-      super(a_server, a_ttl, pdnssec)
-    end
-
-    def connection
-      @connection ||= PG.connect(connection_str)
-    end
-
-    def get_zone name
-      domain = nil
-
-      connection.exec_params("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE $1 LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1", [name]) do |result|
-        result.each do |row|
-          domain = row
-        end
-      end
-
-      raise Proxy::Dns::Error, "Unable to determine zone for #{name}. Zone must exist in PowerDNS." unless domain
-
-      domain
-    end
-
-    def create_record domain_id, name, type, content
-      result = connection.exec_params("INSERT INTO records (domain_id, name, ttl, content, type, change_date) VALUES ($1::int, $2, $3::int, $4, $5, extract(epoch from now()))", [domain_id, name, ttl, content, type])
-      result.cmdtuples == 1
-    end
-
-    def delete_record domain_id, name, type
-      result = connection.exec_params("DELETE FROM records WHERE domain_id=$1::int AND name=$2 AND type=$3", [domain_id, name, type])
-      return false if result.cmdtuples == 0
-
-      result = connection.exec_params("UPDATE records SET change_date=extract(epoch from now()) WHERE domain_id=$1::int AND type='SOA'", [domain_id])
-      affected_rows = result.cmdtuples
-      if affected_rows > 1
-        logger.warning("Updated multiple SOA records (host=#{name}, domain_id=#{domain_id}). Check your zone records for duplicate SOA entries.")
-      elsif affected_rows == 0
-        logger.info("No SOA record updated (host=#{name}, domain_id=#{domain_id}). This can be caused by either a missing SOA record for the zone or consecutive updates of the same zone during the same second.")
-      end
-      true
-    end
-  end
-end

data/lib/smart_proxy_dns_powerdns/backend/rest.rb

@@ -1,97 +0,0 @@
-require 'json'
-require 'net/http'
-require 'resolv'
-
-module Proxy::Dns::Powerdns::Backend
-  extend ::Proxy::Log
-
-  class Rest < ::Proxy::Dns::Powerdns::Record
-
-    attr_reader :url, :api_key
-
-    def initialize(a_server, a_ttl, url, api_key)
-      @url = url
-      @api_key = api_key
-
-      super(a_server, a_ttl)
-    end
-
-    def get_zone name
-      fqdn = Resolv::DNS::Name.create(name)
-      fqdn = Resolv::DNS::Name.create(name + '.') unless fqdn.absolute?
-      uri = URI("#{@url}/zones")
-
-      result = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
-        request = Net::HTTP::Get.new uri
-        request['X-API-Key'] = @api_key
-        response = http.request request
-        zones = JSON.parse(response.body) rescue []
-
-        zones.select { |zone|
-          domain = Resolv::DNS::Name.create(zone['name'])
-          domain == fqdn or fqdn.subdomain_of?(domain)
-        }.max_by { |zone| zone['name'].length }
-      end
-
-      raise Proxy::Dns::Error, "Unable to determine zone for #{name}. Zone must exist in PowerDNS." unless result
-
-      result
-    end
-
-    def create_record domain_id, name, type, content
-      content += '.' if ['PTR', 'CNAME'].include?(type)
-      rrset = {
-        :name => name + '.',
-        :type => type,
-        :ttl => @ttl.to_i,
-        :changetype => :REPLACE,
-        :records => [
-          {
-            :content => content,
-            :disabled => false
-          }
-        ]
-      }
-
-      patch_records domain_id, rrset
-    end
-
-    def delete_record domain_id, name, type
-      rrset = {
-        :name => name + '.',
-        :type => type,
-        :changetype => :DELETE,
-        :records => []
-      }
-
-      patch_records domain_id, rrset
-    end
-
-    private
-
-    def patch_records domain_id, rrset
-      uri = URI("#{@url}/zones/#{domain_id}")
-
-      data = { :rrsets => [rrset] }
-
-      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
-        request = Net::HTTP::Patch.new uri
-        request['X-API-Key'] = @api_key
-        request['Content-Type'] = 'application/json'
-        request.body = data.to_json
-        response = http.request request
-        unless response.is_a?(Net::HTTPSuccess)
-          begin
-            content = JSON.parse(response.body)
-          rescue
-            logger.debug "Failed to pach records for #{domain_id} with '#{rrset}': #{response.body}"
-            raise Proxy::Dns::Error.new("Failed to patch records")
-          end
-          raise Proxy::Dns::Error.new("Failed to patch records: #{content['error']}")
-        end
-      end
-
-      true
-    end
-  end
-end

data/test/unit/dns_powerdns_record_dummy_test.rb

@@ -1,26 +0,0 @@
-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,114 +0,0 @@
-require 'test_helper'
-
-require 'smart_proxy_dns_powerdns/dns_powerdns_main'
-require 'smart_proxy_dns_powerdns/backend/mysql'
-
-class DnsPowerdnsBackendMysqlTest < Test::Unit::TestCase
-  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_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
-
-  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(@provider.get_zone('test.example.com'), {'id' => 1, 'name' => 'example.com'})
-  end
-
-  def test_get_zone_without_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([])
-
-    assert_raise(Proxy::Dns::Error) { @provider.get_zone('test.example.com') }
-  end
-
-  def test_create_record
-    @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, change_date) VALUES (1, 'test.example.com', 86400, '10.1.1.1', 'A', UNIX_TIMESTAMP())")
-    @connection.expects(:affected_rows).returns(1)
-
-    assert @provider.create_record(1, 'test.example.com', 'A', '10.1.1.1')
-  end
-
-  def test_delete_record
-    mock_escapes(fqdn, 'A')
-    @connection.expects(:query).with(query_delete)
-    @connection.expects(:query).with(query_update_soa)
-    @connection.expects(:affected_rows).twice.returns(1)
-    assert @provider.delete_record(domain_id, fqdn, 'A')
-  end
-
-  def test_delete_no_record
-    mock_escapes(fqdn, 'A')
-    @connection.expects(:query).with(query_delete)
-    @connection.expects(:affected_rows).returns(0)
-
-    assert_false @provider.delete_record(domain_id, fqdn, 'A')
-  end
-
-  def test_delete_record_no_soa
-    mock_escapes(fqdn, 'A')
-    @connection.expects(:query).with(query_delete)
-    @connection.expects(:query).with(query_update_soa)
-    @connection.expects(:affected_rows).twice.returns(1, 0)
-    logger = mock()
-    logger.expects(:info)
-    @provider.stubs(:logger).returns(logger)
-
-    assert @provider.delete_record(domain_id, fqdn, 'A')
-  end
-
-  def test_delete_record_multiple_soa
-    mock_escapes(fqdn, 'A')
-    @connection.expects(:query).with(query_delete)
-    @connection.expects(:query).with(query_update_soa)
-    @connection.expects(:affected_rows).twice.returns(1, 2)
-    logger = mock()
-    logger.expects(:warning)
-    @provider.stubs(:logger).returns(logger)
-
-    assert @provider.delete_record(domain_id, fqdn, 'A')
-  end
-
-  private
-
-  def mock_escapes(*elts)
-    elts.each { |e| @connection.expects(:escape).with(e).returns(e) }
-  end
-
-  def domain
-    'example.com'
-  end
-
-  def fqdn
-    "test.#{domain}"
-  end
-
-  def domain_id
-    1
-  end
-
-  def query_delete(type='A')
-    "DELETE FROM records WHERE domain_id=#{domain_id} AND name='#{fqdn}' AND type='#{type}'"
-  end
-
-  def query_update_soa
-    "UPDATE records SET change_date=UNIX_TIMESTAMP() WHERE domain_id=#{domain_id} AND type='SOA'"
-  end
-
-end

data/test/unit/dns_powerdns_record_postgresql_test.rb

@@ -1,125 +0,0 @@
-require 'test_helper'
-
-require 'smart_proxy_dns_powerdns/dns_powerdns_main'
-require 'smart_proxy_dns_powerdns/backend/postgresql'
-
-class DnsPowerdnsBackendPostgresqlTest < Test::Unit::TestCase
-  def setup
-    @provider = Proxy::Dns::Powerdns::Backend::Postgresql.new('localhost', 86400, 'sudo pdnssec',
-                                                              'dbname=powerdns')
-    @connection = mock()
-    @provider.stubs(:connection).returns(@connection)
-  end
-
-  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, change_date) VALUES ($1::int, $2, $3::int, $4, $5, extract(epoch from now()))", [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
-    mock_delete_tuples(0)
-    assert_false run_delete_record
-  end
-
-  def test_delete_record_single_record
-    mock_delete_tuples(1)
-    mock_update_soa_tuples(1)
-
-    assert_true run_delete_record
-  end
-
-  def test_delete_record_multiple_records
-    mock_delete_tuples(2)
-    mock_update_soa_tuples(1)
-
-    assert_true run_delete_record
-  end
-
-  def test_delete_record_no_soa
-    mock_delete_tuples(1)
-    mock_update_soa_tuples(0)
-    logger = mock()
-    logger.expects(:info)
-    @provider.stubs(:logger).returns(logger)
-
-    assert_true run_delete_record
-  end
-
-  def test_delete_record_multiple_soa
-    mock_delete_tuples(1)
-    mock_update_soa_tuples(2)
-    logger = mock()
-    logger.expects(:warning)
-    @provider.stubs(:logger).returns(logger)
-
-    assert_true run_delete_record
-  end
-
-  private
-
-  def mock_delete_tuples(cmdtuples)
-    @connection.expects(:exec_params).
-      with(query_delete, [domain_id, fqdn, record_type]).
-      returns(mock(:cmdtuples => cmdtuples))
-  end
-
-  def mock_update_soa_tuples(cmdtuples)
-    @connection.expects(:exec_params).
-      with(query_update_soa, [domain_id]).
-      returns(mock(:cmdtuples => cmdtuples))
-  end
-
-  def run_delete_record
-    @provider.delete_record(domain_id, fqdn, record_type)
-  end
-
-  def domain
-    'example.com'
-  end
-
-  def fqdn
-    "test.#{domain}"
-  end
-
-  def domain_id
-    1
-  end
-
-  def record_type
-    'A'
-  end
-
-  def query_delete
-    "DELETE FROM records WHERE domain_id=$1::int AND name=$2 AND type=$3"
-  end
-
-  def query_update_soa
-    "UPDATE records SET change_date=extract(epoch from now()) WHERE domain_id=$1::int AND type='SOA'"
-  end
-
-end

data/test/unit/dns_powerdns_record_rest_test.rb

@@ -1,67 +0,0 @@
-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