smart_proxy_dns_route53 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afc68be7898dff76e610ac85e992e403f86d6c92
-  data.tar.gz: e88894baa652431ea063b23287c9f9ff909da377
+  metadata.gz: cc34b8b1e28f0d113bc0ded31929bd925d863c70
+  data.tar.gz: 5ebc3509ec21c98e544e41cb577086deb13bf99a
 SHA512:
-  metadata.gz: 64b97a5cbfd2150c4df89b57d86acc26b07c10cc4ca6f630f39533bbfe35ad3e417bf39e998f60b5ec64726fcd7319e5555b3ae05a62c8ca2bac5b11a86dc12b
-  data.tar.gz: 39da40207db0a7083db676da32b085edb38b53c7a63f528a92638c5c4304521995d5e48cdc8210cdf70db5079b4805f4318cd5c64b6618f7eabac2b7fc7b8750
+  metadata.gz: c6bada1d5fca8a12dcdb9b7370ba933db54ac3b7a0cbb3d0d3f28f411066a312edfcba097806d9712a95ba20c9a89bfa3f0a3e458ce1ccd54e68a862d5006c52
+  data.tar.gz: f596aef91a3b5d0f858076ddcdba44beb539db647c9fdfa90435021279fc094c3ac91f7363957f51fc826ca957450b9a7558db6b5fd7cf5565a3a646758090a5

data/README.md

@@ -12,7 +12,8 @@ for how to install Smart Proxy plugins
 | Smart Proxy Version | Plugin Version |
 | ------------------- | --------------:|
 | >= 1.10, < 1.11     | ~> 1.0         |
-| >= 1.11             | ~> 2.0         |
+| >= 1.11, < 1.13     | ~> 2.0         |
+| >= 1.13, < 1.15     | ~> 3.0         |
 
 ## Configuration
 
@@ -27,10 +28,60 @@ Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dns_
 * `:aws_access_key: "ABCDEF123456"` - set to be the Access Key ID of the IAM account
 * `:aws_secret_key: "ABCDEF123456!@#$"` - set to be the Secret Access Key of the IAM account
 
+### IAM policy
+
+The IAM account must have the following actions associated via a policy:
+
+* `route53:ListHostedZones` (all resources)
+* `route53:ChangeResourceRecordSets` (on all zones being managed)
+* `route53:ListResourceRecordSets` (on all zones being managed)
+
+An example policy document follows:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "Stmt1485852222000",
+            "Effect": "Allow",
+            "Action": [
+                "route53:ListHostedZones"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Sid": "Stmt1485852222001",
+            "Effect": "Allow",
+            "Action": [
+                "route53:ChangeResourceRecordSets",
+                "route53:ListResourceRecordSets"
+            ],
+            "Resource": [
+                "arn:aws:route53:::hostedzone/Z1HNC9XBMDGFH9",
+                "arn:aws:route53:::hostedzone/Z2MCBLVJI24XOO",
+                "arn:aws:route53:::hostedzone/Z5H8WZ62ARI5V"
+            ]
+        }
+    ]
+}
+```
+
 ## Contributing
 
 Fork and send a Pull Request. Thanks!
 
+### Integration test
+
+The integration test runs against the AWS Route 53 API, so requires IAM credentials. To run it locally, set up an IAM policy with actions described above, _plus_ the `route53:GetHostedZone` action.
+
+Three zones must also be set up - a forward, reverse IPv4 and reverse IPv6 zone. The names do not matter. *All records will be deleted* in these zones when running the test, so do not use the zones for any other purpose.
+
+Export the following environment variables:
+
+* `AWS_ACCESS_KEY`, `AWS_SECRET_KEY` - per regular plugin configuration
+* `AWS_FORWARD_ZONE`, `AWS_REVERSE_V4_ZONE`, `AWS_REVERSE_V6_ZONE` - zone names that will be under complete control of the test suite
+
 ## Copyright
 
 Copyright (c) 2015 Daniel Maraio, Sol Cates, Red Hat Inc. and other contributors

data/lib/smart_proxy_dns_route53/dns_route53_configuration.rb

@@ -0,0 +1,16 @@
+module ::Proxy::Dns::Route53
+  class PluginConfiguration
+    def load_classes
+      require 'smart_proxy_dns_plugin_template/dns_plugin_template_main'
+    end
+
+    def load_dependency_injection_wirings(container_instance, settings)
+      container_instance.dependency :dns_provider, (lambda do
+        ::Proxy::Dns::Route53::Record.new(
+            settings[:aws_access_key],
+            settings[:aws_secret_key],
+            settings[:dns_ttl])
+      end)
+    end
+  end
+end

data/lib/smart_proxy_dns_route53/dns_route53_main.rb

@@ -10,15 +10,18 @@ module Proxy::Dns::Route53
 
     attr_reader :aws_access_key, :aws_secret_key
 
-    def initialize(a_server = nil, a_ttl = nil)
-      @aws_access_key = Proxy::Dns::Route53::Plugin.settings.aws_access_key
-      @aws_secret_key = Proxy::Dns::Route53::Plugin.settings.aws_secret_key
-      super(a_server, a_ttl || ::Proxy::Dns::Plugin.settings.dns_ttl)
+    def initialize(aws_access_key, aws_secret_key, ttl = nil)
+      @aws_access_key = aws_access_key
+      @aws_secret_key = aws_secret_key
+      super(nil, ttl)
     end
 
     def create_a_record(fqdn, ip)
-      if found = dns_find(fqdn)
-        raise(Proxy::Dns::Collision, "#{fqdn} is already used by #{ip}") unless found == ip
+      case a_record_conflicts(fqdn, ip) #returns -1, 0, 1
+      when 1 then
+        raise(Proxy::Dns::Collision, "#{fqdn} is already used by #{ip}")
+      when 0 then
+        return nil
       else
         zone = get_zone(fqdn)
         new_record = Route53::DNSRecord.new(fqdn, 'A', ttl, [ip], zone)
@@ -28,12 +31,30 @@ module Proxy::Dns::Route53
       end
     end
 
-    def create_ptr_record(fqdn, ip)
-      if found = dns_find(ip)
-        raise(Proxy::Dns::Collision, "#{ip} is already used by #{found}") unless found == fqdn
+    def create_aaaa_record(fqdn, ip)
+      case aaaa_record_conflicts(fqdn, ip) #returns -1, 0, 1
+      when 1 then
+        raise(Proxy::Dns::Collision, "#{fqdn} is already used by #{ip}")
+      when 0 then
+        return nil
       else
-        zone = get_zone(ip)
-        new_record = Route53::DNSRecord.new(ip, 'PTR', ttl, [fqdn], zone)
+        zone = get_zone(fqdn)
+        new_record = Route53::DNSRecord.new(fqdn, 'AAAA', ttl, [ip], zone)
+        resp = new_record.create
+        raise "AWS Response Error: #{resp}" if resp.error?
+        true
+      end
+    end
+
+    def create_ptr_record(fqdn, ptr)
+      case ptr_record_conflicts(fqdn, ptr_to_ip(ptr)) #returns -1, 0, 1
+      when 1 then
+        raise(Proxy::Dns::Collision, "#{ptr} is already in use")
+      when 0 then
+        return nil
+      else
+        zone = get_zone(ptr)
+        new_record = Route53::DNSRecord.new(ptr, 'PTR', ttl, [fqdn], zone)
         resp = new_record.create
         raise "AWS Response Error: #{resp}" if resp.error?
         true
@@ -44,7 +65,20 @@ module Proxy::Dns::Route53
       zone = get_zone(fqdn)
       recordset = zone.get_records
       recordset.each do |rec|
-        if rec.name == fqdn + '.'
+        if rec.name == fqdn + '.' && rec.type == 'A'
+          resp = rec.delete
+          raise "AWS Response Error: #{resp}" if resp.error?
+          return true
+        end
+      end
+      raise Proxy::Dns::NotFound, "Could not find forward record #{fqdn}"
+    end
+
+    def remove_aaaa_record(fqdn)
+      zone = get_zone(fqdn)
+      recordset = zone.get_records
+      recordset.each do |rec|
+        if rec.name == fqdn + '.' && rec.type == 'AAAA'
           resp = rec.delete
           raise "AWS Response Error: #{resp}" if resp.error?
           return true
@@ -76,9 +110,14 @@ module Proxy::Dns::Route53
       @resolver ||= Resolv::DNS.new
     end
 
-    def get_zone(fqdn)
-      domain = fqdn.split('.', 2).last + '.'
-      conn.get_zones(domain)[0]
+    def get_zone(name)
+      zones = conn.get_zones
+      name_arr = name.split('.')
+      (1 ... name_arr.size).each do |i|
+        search_domain = name_arr.last(name_arr.size - i).join('.') + "."
+        zone_select = zones.select { |z| z.name == search_domain }
+        return zone_select.first if zone_select.any?
+      end
     end
   end
 end

data/lib/smart_proxy_dns_route53/dns_route53_plugin.rb

@@ -1,16 +1,15 @@
 require 'smart_proxy_dns_route53/dns_route53_version'
+require 'smart_proxy_dns_route53/dns_route53_configuration'
 
 module Proxy::Dns::Route53
   class Plugin < ::Proxy::Provider
     plugin :dns_route53, ::Proxy::Dns::Route53::VERSION
 
-    requires :dns, '>= 1.11'
+    requires :dns, '>= 1.13'
 
-    validate_presence :aws_access_key, :aws_secret_key
+    default_settings :aws_access_key => nil, :aws_secret_key => nil
 
-    after_activation do
-      require 'smart_proxy_dns_route53/dns_route53_main'
-      require 'smart_proxy_dns_route53/route53_dependencies'
-    end
+    load_classes ::Proxy::Dns::Route53::PluginConfiguration
+    load_dependency_injection_wirings ::Proxy::Dns::Route53::PluginConfiguration
   end
 end

data/lib/smart_proxy_dns_route53/dns_route53_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module Dns
     module Route53
-      VERSION = '2.0.0'
+      VERSION = '3.0.0'
     end
   end
 end

data/test/dns_route53_integration_test.rb

@@ -0,0 +1,158 @@
+require 'test_helper'
+
+require 'smart_proxy_dns_route53/dns_route53_plugin'
+require 'smart_proxy_dns_route53/dns_route53_main'
+
+require 'dns/dependency_injection'
+
+module Proxy::Dns
+  module DependencyInjection
+    include Proxy::DependencyInjection::Accessors
+    def container_instance
+      Proxy::DependencyInjection::Container.new do |c|
+				c.dependency :dns_provider, (lambda do
+					::Proxy::Dns::Route53::Record.new(
+							ENV['AWS_ACCESS_KEY'],
+							ENV['AWS_SECRET_KEY'])
+        end)
+      end
+    end
+  end
+end
+
+require 'dns/dns_api'
+require 'rack/test'
+require 'resolv'
+
+TestRecord = Struct.new(:ip, :type) do
+  alias_method :fqdn, :ip
+end
+
+class DnsRoute53IntegrationTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    @app = Proxy::Dns::Api.new
+  end
+
+  def setup
+    omit_if(%w[AWS_ACCESS_KEY AWS_SECRET_KEY AWS_FORWARD_ZONE AWS_REVERSE_V4_ZONE AWS_REVERSE_V6_ZONE].any? { |e| !ENV.has_key?(e) })
+    clean_zones
+    @record = nil
+  end
+
+  def test_create_a_record
+    post '/', :fqdn => "test.#{forward_zone}", :value => '192.168.33.33', :type => 'A'
+    assert_equal 200, last_response.status
+    assert_equal '192.168.33.33', record(forward_zone, "test.#{forward_zone}.", 'A').ip
+    assert_equal 'A', @record.type
+  end
+
+  def test_create_ptr_v4_record
+    post '/', :fqdn => "test.#{forward_zone}.", :value => "33.#{reverse_v4_zone}", :type => 'PTR'
+    assert_equal 200, last_response.status
+    assert_equal "test.#{forward_zone}.", record(reverse_v4_zone, "33.#{reverse_v4_zone}.", 'PTR').fqdn
+    assert_equal 'PTR', @record.type
+  end
+
+  def test_create_ptr_v6_record
+    post '/', :fqdn => "test.#{forward_zone}.", :value => "1.#{reverse_v6_zone(true)}", :type => 'PTR'
+    assert_equal 200, last_response.status
+    assert_equal "test.#{forward_zone}.", record(reverse_v6_zone, "1.#{reverse_v6_zone(true)}.", 'PTR').fqdn
+    assert_equal 'PTR', @record.type
+  end
+
+  def test_create_aaaa_record
+    post '/', :fqdn => "test.#{forward_zone}", :value => '2001:db8::1', :type => 'AAAA'
+    assert_equal 200, last_response.status
+    assert_equal '2001:db8::1', record(forward_zone, "test.#{forward_zone}.", 'AAAA').ip
+    assert_equal 'AAAA', @record.type
+  end
+
+  def test_create_cname_record
+    omit 'CNAME support not implemented'
+    post '/', :fqdn => "test.#{forward_zone}", :value => 'test1.com', :type => 'CNAME'
+    assert_equal 200, last_response.status
+    assert_equal 'test1.com.', record(forward_zone, "test.#{forward_zone}.", 'CNAME').fqdn
+    assert_equal 'CNAME', @record.type
+  end
+
+  def test_delete_a_record
+    create_record forward_zone, "test.#{forward_zone}.", 'A', '3600', ['1.2.3.4']
+    delete "/test.#{forward_zone}"
+    assert_equal 200, last_response.status
+    assert_nil record(forward_zone, "test.#{forward_zone}.", 'A')
+  end
+
+  def test_delete_ptr_record
+    create_record reverse_v4_zone, "33.#{reverse_v4_zone}.", 'PTR', '3600', ['test.example.com.']
+    delete "/33.#{reverse_v4_zone}"
+    assert_equal 200, last_response.status
+    assert_nil record(reverse_v4_zone, "33.#{reverse_v4_zone}.", 'PTR')
+  end
+
+  def test_delete_aaaa_record
+    create_record forward_zone, "test.#{forward_zone}.", 'AAAA', '3600', ['2001:db8::1']
+    delete "/test.#{forward_zone}/AAAA"
+    assert_equal 200, last_response.status
+    assert_nil record(forward_zone, "test.#{forward_zone}.", 'AAAA')
+  end
+
+  def test_delete_explicit_cname_record
+    omit 'CNAME support not implemented'
+    create_record forward_zone, "test.#{forward_zone}.", 'CNAME', '3600', ['test.example.com.']
+    delete "/test.#{forward_zone}/CNAME"
+    assert_equal 200, last_response.status
+    assert_nil record(forward_zone, "test.#{forward_zone}.", 'CNAME')
+  end
+
+  private
+
+  def forward_zone
+    ENV['AWS_FORWARD_ZONE'].chomp('.')
+  end
+
+  def reverse_v4_zone
+    ENV['AWS_REVERSE_V4_ZONE'].chomp('.')
+  end
+
+  def reverse_v6_zone(pad = false)
+    zone = ENV['AWS_REVERSE_V6_ZONE'].chomp('.')
+    if pad
+      zeros = '0.' * ((62 - (reverse_v6_zone.length - 'ip6.arpa'.length)) / 2)
+      "#{zeros}#{zone}"
+    else
+      zone
+    end
+  end
+
+  def conn
+    @conn ||= Route53::Connection.new(ENV['AWS_ACCESS_KEY'], ENV['AWS_SECRET_KEY'])
+  end
+
+  def clean_zones
+    [forward_zone, reverse_v4_zone, reverse_v6_zone].each do |zone_name|
+      zone = conn.get_zones(zone_name)
+      raise "Cannot find AWS zone #{zone_name}" if zone.nil?
+      zone.first.get_records.each do |record|
+        next if %w[SOA NS].include?(record.type)
+        raise "AWS error while deleting #{record}: #{response}" if (response = record.delete).error?
+      end
+    end
+  end
+
+  def record(zone_name, name, type)
+    zone = conn.get_zones(zone_name)
+    raise "Cannot find AWS zone #{zone_name}" if zone.nil?
+    record = zone.first.get_records.find { |rec| rec.name == name && rec.type == type }
+    @record = record.nil? ? nil : TestRecord.new(record.values.first, record.type)
+  end
+
+  def create_record(zone_name, *record)
+    zone = conn.get_zones(zone_name)
+    raise "Cannot find AWS zone #{zone_name}" if zone.nil?
+    response = Route53::DNSRecord.new(*(record.push(zone.first))).create
+    raise "Failed to create test record #{record}: #{response}" if response.error?
+    record
+  end
+end

data/test/dns_route53_record_test.rb

@@ -4,141 +4,145 @@ require 'smart_proxy_dns_route53/dns_route53_plugin'
 require 'smart_proxy_dns_route53/dns_route53_main'
 
 class DnsRoute53RecordTest < Test::Unit::TestCase
+  def setup
+    @provider = Proxy::Dns::Route53::Record.new('foo', 'bar', 86400)
+  end
+
   # Test that correct initialization works
   def test_provider_initialization
-    Proxy::Dns::Route53::Plugin.load_test_settings(:aws_access_key => 'foo', :aws_secret_key => 'bar')
-    provider = klass.new
-    assert_equal 'foo', provider.aws_access_key
-    assert_equal 'bar', provider.aws_secret_key
+    assert_equal 'foo', @provider.aws_access_key
+    assert_equal 'bar', @provider.aws_secret_key
+    assert_equal 86400, @provider.ttl
   end
 
   # Test A record creation
   def test_create_a
-    record = klass.new
-    record.expects(:dns_find).returns(false)
+    @provider.expects(:a_record_conflicts).with('test.example.com', '10.1.1.1').returns(-1)
 
     zone = mock()
-    record.expects(:get_zone).with('test.example.com').returns(zone)
+    @provider.expects(:get_zone).with('test.example.com').returns(zone)
 
     dnsrecord = mock(:create => mock(:error? => false))
     Route53::DNSRecord.expects(:new).with('test.example.com', 'A', 86400, ['10.1.1.1'], zone).returns(dnsrecord)
 
-    assert record.create_a_record(fqdn, ip)
+    assert @provider.create_a_record(fqdn, ip)
   end
 
   # Test A record creation fails if the record exists
   def test_create_a_conflict
-    record = klass.new
-    record.expects(:dns_find).returns('10.2.2.2')
-    assert_raise(Proxy::Dns::Collision) { record.create_a_record(fqdn, ip) }
+    @provider.expects(:a_record_conflicts).with(fqdn, ip).returns(1)
+    assert_raise(Proxy::Dns::Collision) { @provider.create_a_record(fqdn, ip) }
+  end
+
+  # Test AAAA record creation
+  def test_create_aaaaa
+    @provider.expects(:aaaa_record_conflicts).with('test.example.com', '2001:db8::1').returns(-1)
+
+    zone = mock()
+    @provider.expects(:get_zone).with('test.example.com').returns(zone)
+
+    dnsrecord = mock(:create => mock(:error? => false))
+    Route53::DNSRecord.expects(:new).with('test.example.com', 'AAAA', 86400, ['2001:db8::1'], zone).returns(dnsrecord)
+
+    assert @provider.create_aaaa_record(fqdn, '2001:db8::1')
+  end
+
+  # Test AAAA record creation fails if the record exists
+  def test_create_aaaa_conflict
+    @provider.expects(:aaaa_record_conflicts).with(fqdn, '2001:db8::1').returns(1)
+    assert_raise(Proxy::Dns::Collision) { @provider.create_aaaa_record(fqdn, '2001:db8::1') }
   end
 
   # Test PTR record creation
   def test_create_ptr
-    record = klass.new
-    record.expects(:dns_find).returns(false)
+    @provider.expects(:ptr_record_conflicts).with('test.example.com', '10.1.1.1').returns(false)
 
     zone = mock()
-    record.expects(:get_zone).with('10.1.1.1').returns(zone)
+    @provider.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns(zone)
 
     dnsrecord = mock(:create => mock(:error? => false))
-    Route53::DNSRecord.expects(:new).with('10.1.1.1', 'PTR', 86400, ['test.example.com'], zone).returns(dnsrecord)
+    Route53::DNSRecord.expects(:new).with('1.1.1.10.in-addr.arpa', 'PTR', 86400, ['test.example.com'], zone).returns(dnsrecord)
 
-    assert record.create_ptr_record(fqdn, ip)
+    assert @provider.create_ptr_record(fqdn, '1.1.1.10.in-addr.arpa')
   end
 
   # Test PTR record creation fails if the record exists
   def test_create_ptr_conflict
-    record = klass.new
-    record.expects(:dns_find).returns('else.example.com')
-    assert_raise(Proxy::Dns::Collision) { record.create_ptr_record(fqdn, ip) }
+    @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, '1.1.1.10.in-addr.arpa') }
   end
 
   # Test A record removal
   def test_remove_a
-    zone = mock(:get_records => [mock(:name => 'test.example.com.', :delete => mock(:error? => false))])
-    record = klass.new
-    record.expects(:get_zone).with('test.example.com').returns(zone)
-    assert record.remove_a_record(fqdn)
+    zone = mock(:get_records => [mock(:name => 'test.example.com.', :type => 'A', :delete => mock(:error? => false))])
+    @provider.expects(:get_zone).with('test.example.com').returns(zone)
+    assert @provider.remove_a_record(fqdn)
   end
 
   # Test A record removal fails if the record doesn't exist
   def test_remove_a_not_found
-    record = klass.new
-    record.expects(:get_zone).with('test.example.com').returns(mock(:get_records => []))
-    assert_raise(Proxy::Dns::NotFound) { assert record.remove_a_record(fqdn) }
+    @provider.expects(:get_zone).with('test.example.com').returns(mock(:get_records => []))
+    assert_raise(Proxy::Dns::NotFound) { assert @provider.remove_a_record(fqdn) }
+  end
+
+  # Test AAAA record removal
+  def test_remove_aaaa
+    zone = mock(:get_records => [mock(:name => 'test.example.com.', :type => 'AAAA', :delete => mock(:error? => false))])
+    @provider.expects(:get_zone).with('test.example.com').returns(zone)
+    assert @provider.remove_aaaa_record(fqdn)
+  end
+
+  # Test A record removal fails if the record doesn't exist
+  def test_remove_a_not_found
+    @provider.expects(:get_zone).with('test.example.com').returns(mock(:get_records => []))
+    assert_raise(Proxy::Dns::NotFound) { assert @provider.remove_a_record(fqdn) }
   end
 
   # Test PTR record removal
   def test_remove_ptr
     # FIXME: record name seems incorrect for rDNS
     zone = mock(:get_records => [mock(:name => '10.1.1.1.', :delete => mock(:error? => false))])
-    record = klass.new
-    record.expects(:get_zone).with('10.1.1.1').returns(zone)
-    assert record.remove_ptr_record(ip)
+    @provider.expects(:get_zone).with('10.1.1.1').returns(zone)
+    assert @provider.remove_ptr_record(ip)
   end
 
   # Test PTR record removal fails if the record doesn't exist
   def test_remove_ptr_not_found
-    record = klass.new
-    record.expects(:get_zone).with('10.1.1.1').returns(mock(:get_records => []))
-    assert_raise(Proxy::Dns::NotFound) { assert record.remove_ptr_record(ip) }
+    @provider.expects(:get_zone).with('10.1.1.1').returns(mock(:get_records => []))
+    assert_raise(Proxy::Dns::NotFound) { assert @provider.remove_ptr_record(ip) }
   end
 
   def test_get_zone_forward
-    record = klass.new
-    conn = mock()
-    conn.expects(:get_zones).with('example.com.').returns([:zone])
-    record.expects(:conn).returns(conn)
-    assert_equal :zone, record.send(:get_zone, 'test.example.com')
+    zone = stub(:name => 'example.com.')
+    conn = mock(:get_zones => [zone])
+    @provider.expects(:conn).returns(conn)
+    assert_equal zone, @provider.send(:get_zone, 'test.example.com.')
   end
 
   def test_get_zone_reverse
-    record = klass.new
-    conn = mock()
-    conn.expects(:get_zones).with('1.1.1.').returns([:zone])  # FIXME, incorrect rDNS zone
-    record.expects(:conn).returns(conn)
-    assert_equal :zone, record.send(:get_zone, '10.1.1.1')
+    zone = stub(:name => '2.1.10.in-addr.arpa.')
+    conn = mock(:get_zones => [zone])
+    @provider.expects(:conn).returns(conn)
+    assert_equal zone, @provider.send(:get_zone, '3.2.1.10.in-addr.arpa.')
   end
 
-  def test_dns_find_forward
-    record = klass.new
-    resolver = mock()
-    resolver.expects(:getaddress).with('test.example.com').returns('10.1.1.1')
-    record.expects(:resolver).returns(resolver)
-    assert_equal '10.1.1.1', record.send(:dns_find, 'test.example.com')
+  def test_get_zone_reverse_v6
+    zone = stub(:name => '8.b.d.0.1.0.0.2.ip6.arpa.')
+    conn = mock(:get_zones => [zone])
+    @provider.expects(:conn).returns(conn)
+    assert_equal zone, @provider.send(:get_zone, '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.')
   end
 
-  def test_dns_find_forward_not_found
-    record = klass.new
-    resolver = mock()
-    resolver.expects(:getaddress).with('test.example.com').raises(Resolv::ResolvError)
-    record.expects(:resolver).returns(resolver)
-    refute record.send(:dns_find, 'test.example.com')
-  end
-
-  def test_dns_find_reverse
-    record = klass.new
-    resolver = mock()
-    resolver.expects(:getname).with('3.2.1.10').returns('test.example.com')
-    record.expects(:resolver).returns(resolver)
-    assert_equal 'test.example.com', record.send(:dns_find, '10.1.2.3')
-  end
-
-  def test_dns_find_reverse_not_found
-    record = klass.new
-    resolver = mock()
-    resolver.expects(:getname).with('3.2.1.10').raises(Resolv::ResolvError)
-    record.expects(:resolver).returns(resolver)
-    refute record.send(:dns_find, '10.1.2.3')
+  def test_get_zone_longest_match
+    zone = stub(:name => 'sub.example.com.')
+    other = stub(:name => 'example.com.')
+    conn = mock(:get_zones => [other, zone])
+    @provider.expects(:conn).returns(conn)
+    assert_equal zone, @provider.send(:get_zone, 'host.sub.example.com.')
   end
 
   private
 
-  def klass
-    Proxy::Dns::Route53::Record
-  end
-
   def fqdn
     'test.example.com'
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dns_route53
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Foreman developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-15 00:00:00.000000000 Z
+date: 2017-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: route53
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Route 53 DNS provider plugin for Foreman's smart proxy
 email:
 - foreman-dev@googlegroups.com
@@ -78,15 +92,16 @@ files:
 - bundler.d/dns_route53.rb
 - config/dns_route53.yml
 - lib/smart_proxy_dns_route53.rb
+- lib/smart_proxy_dns_route53/dns_route53_configuration.rb
 - lib/smart_proxy_dns_route53/dns_route53_main.rb
 - lib/smart_proxy_dns_route53/dns_route53_plugin.rb
 - lib/smart_proxy_dns_route53/dns_route53_version.rb
-- lib/smart_proxy_dns_route53/route53_dependencies.rb
+- test/dns_route53_integration_test.rb
 - test/dns_route53_record_test.rb
 - test/test_helper.rb
 homepage: https://github.com/theforeman/smart_proxy_dns_route53
 licenses:
-- GPLv3
+- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -104,10 +119,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Route 53 DNS provider plugin for Foreman's smart proxy
 test_files:
+- test/dns_route53_integration_test.rb
 - test/dns_route53_record_test.rb
 - test/test_helper.rb

data/lib/smart_proxy_dns_route53/route53_dependencies.rb

@@ -1,5 +0,0 @@
-require 'dns_common/dependency_injection/dependencies'
-
-class Proxy::Dns::DependencyInjection::Dependencies
-  dependency :dns_provider, Proxy::Dns::Route53::Record
-end