sprinkle_dns 1.0.0

data/spec/unit/hosted_zone_spec.rb

@@ -0,0 +1,343 @@
+require 'spec_helper'
+
+RSpec.describe SprinkleDNS::HostedZone do
+  context "update data" do
+    it 'should update changed data accordingly' do
+      hz = SprinkleDNS::HostedZone.new('test.billetto.com.')
+      hz_entry01 = sprinkle_entry('A', 'updatevalue.test.billetto.com.', '80.80.22.22', 60, hz.name)
+      hz_entry02 = sprinkle_entry('A', 'updatettl.test.billetto.com.', '80.80.22.22', 60, hz.name)
+      hz_entry01.persisted!
+      hz_entry02.persisted!
+      hz.resource_record_sets = [hz_entry01, hz_entry02]
+
+      hz_entry03 = sprinkle_entry('A', 'updatevalue.test.billetto.com.', '90.90.22.22', 60, hz.name)
+      hz_entry04 = sprinkle_entry('A', 'updatettl.test.billetto.com.', '80.80.22.22', 120, hz.name)
+      [hz_entry03, hz_entry04].each do |hz_entry|
+        hz.add_or_update_hosted_zone_entry(hz_entry)
+      end
+
+      updatedvalue = hz.resource_record_sets.select{|rrs| rrs.name == 'updatevalue.test.billetto.com.'}.first
+      expect(updatedvalue.changed_value).to eq true
+      expect(updatedvalue.changed_ttl).to eq false
+
+      updatedttl = hz.resource_record_sets.select{|rrs| rrs.name == 'updatettl.test.billetto.com.'}.first
+      expect(updatedttl.changed_value).to eq false
+      expect(updatedttl.changed_ttl).to eq true
+    end
+  end
+
+  context "compile_change_batch" do
+    it 'should correctly calculate a change_batch' do
+      hz = SprinkleDNS::HostedZone.new('test.billetto.com.')
+
+      hze01 = sprinkle_entry('A', 'www.test.billetto.com.', '80.80.22.22', 60, 'test.billetto.com.')
+      hze02 = sprinkle_entry('A', 'foo.test.billetto.com.', '80.80.23.23', 70, 'test.billetto.com.')
+      hze03 = sprinkle_entry('A', 'bar.test.billetto.com.', '80.80.24.24', 80, 'test.billetto.com.')
+
+      [hze01, hze02, hze03].each do |hze|
+        hz.add_or_update_hosted_zone_entry(hze)
+      end
+
+      policy = SprinkleDNS::EntryPolicyService.new(hz, SprinkleDNS::Config.new)
+
+      expect(policy.compile).to eq([
+        {:action=>"CREATE", :resource_record_set=>{:name=>"www.test.billetto.com.", :type=>"A", :ttl=>60, :resource_records=>[{:value=>"80.80.22.22"}]}},
+        {:action=>"CREATE", :resource_record_set=>{:name=>"foo.test.billetto.com.", :type=>"A", :ttl=>70, :resource_records=>[{:value=>"80.80.23.23"}]}},
+        {:action=>"CREATE", :resource_record_set=>{:name=>"bar.test.billetto.com.", :type=>"A", :ttl=>80, :resource_records=>[{:value=>"80.80.24.24"}]}},
+      ])
+    end
+
+    context 'delete unreferenced' do
+      before(:all) do
+        hz = SprinkleDNS::HostedZone.new('unreferenced.com.')
+
+        # Entries
+        pe01 = sprinkle_entry('A', 'bar.unreferenced.com', '80.80.24.24', 80, 'unreferenced.com.')
+        pe02 = sprinkle_entry('A', 'noref.unreferenced.com', '127.0.0.1', 80, 'unreferenced.com.')
+
+        # We are emulating that these records are already live, mark them as persisted
+        [pe01, pe02].each do |persisted|
+          persisted.persisted!
+          hz.resource_record_sets << persisted
+        end
+
+        client = SprinkleDNS::MockClient.new([hz])
+        sdns   = SprinkleDNS::Client.new(client, delete: true)
+
+        sdns.entry('A', 'bar.unreferenced.com', '80.80.24.24', 80)
+
+        _, existing_hzs = sdns.compare
+        @existing_hz = existing_hzs.first
+      end
+
+      it 'should include unreferenced entries in deleted list if delete=true' do
+        policy = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: true))
+
+        expect(policy.entries_to_delete.size).to eq 1
+        delete_entry = policy.entries_to_delete.first
+        expect(delete_entry.type).to eq 'A'
+        expect(delete_entry.name).to eq 'noref.unreferenced.com.'
+
+        expect(policy.compile).to eq [
+          {:action=>"DELETE", :resource_record_set=>{:name=>"noref.unreferenced.com.", :type=>"A", :ttl=>80, :resource_records=>[{:value=>"127.0.0.1"}]}}
+        ]
+      end
+
+      it 'should not include unreferenced entries in deleted list if delete=false' do
+        policy = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: false))
+
+        expect(policy.entries_to_delete.size).to eq 0
+        expect(policy.compile).to eq []
+      end
+    end
+
+    context 'advanced compile_change_batch' do
+      before(:all) do
+        hz = SprinkleDNS::HostedZone.new('test.billetto.com.')
+
+        # Static
+        ps01 = sprinkle_entry('A', 'staticentry.test.billetto.com.', '80.80.24.24', 80, 'test.billetto.com.')
+        ps02 = sprinkle_alias('A', 'staticalias.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+        # Entries
+        pe01 = sprinkle_entry('A', 'bar.test.billetto.com.', '80.80.24.24', 80, 'test.billetto.com.')
+        pe02 = sprinkle_entry('A', 'noref.test.billetto.com.', '127.0.0.1', 80, 'test.billetto.com.')
+
+        # Aliases
+        pa01 = sprinkle_alias('A', 'war.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+        pa02 = sprinkle_alias('A', 'noraf.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+        # Mixed to overwrite
+        pi01 = sprinkle_entry('A', 'entry-to-alias.test.billetto.com.', '80.80.24.24', 80, 'test.billetto.com.')
+        pi02 = sprinkle_alias('A', 'alias-to-entry.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+        # We are emulating that these records are already live, mark them as persisted
+        [ps01, ps02, pe01, pe02, pa01, pa02, pi01, pi02].each do |persisted|
+          persisted.persisted!
+          hz.resource_record_sets << persisted
+        end
+
+        client = SprinkleDNS::MockClient.new([hz])
+        sdns   = SprinkleDNS::Client.new(client)
+
+        # Static entries
+        sdns.entry('A', 'staticentry.test.billetto.com.', '80.80.24.24', 80, 'test.billetto.com.')
+        sdns.alias('A', 'staticalias.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+        # PURE ENTRIES
+        # Adds new
+        sdns.entry('A', 'www.test.billetto.com.', '80.80.22.22', 60, 'test.billetto.com.')
+
+        # Adds new and overwrites
+        sdns.entry('A', 'foo.test.billetto.com.', '80.80.23.23', 70, 'test.billetto.com.')
+        sdns.entry('A', 'foo.test.billetto.com.', '81.81.24.24', 80, 'test.billetto.com.')
+
+        # Modifies existing
+        sdns.entry('A', 'bar.test.billetto.com.', '82.82.26.26', 90, 'test.billetto.com.')
+
+        # PURE ALIASES
+        # Adds new
+        sdns.alias('A', 'wap.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+        # Adds new and overwrites
+        sdns.alias('A', 'woo.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+        sdns.alias('A', 'woo.test.billetto.com.', 'Z215JYRZR1TBD6', 'dualstack.mothership-test-elb-444444444.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+        # Modifies existing
+        sdns.alias('A', 'war.test.billetto.com.', 'Z215JYRZR1TBD6', 'dualstack.mothership-test-elb-444444444.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+        # MIXED ENTRIES/ALIASES OVERWRITE
+        sdns.alias('A', 'entry-to-alias.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+        sdns.entry('A', 'alias-to-entry.test.billetto.com.', '80.80.24.24', 80, 'test.billetto.com.')
+
+        _, existing_hzs = sdns.compare
+        @existing_hz = existing_hzs.first
+      end
+
+      it "should have a correct number of changes when delete=true" do
+        policy_service = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: true))
+
+        expect(policy_service.entries_to_create.size).to   eq 4
+        expect(policy_service.entries_to_update.size).to   eq 4
+        expect(policy_service.entries_to_delete.size).to   eq 2
+        expect(policy_service.entries_not_touched.size).to eq 2
+        expect(@existing_hz.entries.size).to               eq 4+4+2+2 # 12
+
+        expect(policy_service.entries_to_delete.map(&:name)).to include('noref.test.billetto.com.')
+        expect(policy_service.entries_to_delete.map(&:name)).to include('noraf.test.billetto.com.')
+      end
+
+      it "should have a correct number of changes when delete=false" do
+        policy_service = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: false))
+
+        expect(policy_service.entries_to_create.size).to   eq 4
+        expect(policy_service.entries_to_update.size).to   eq 4
+        expect(policy_service.entries_to_delete.size).to   eq 0
+        expect(policy_service.entries_not_touched.size).to eq 4
+        expect(@existing_hz.entries.size).to               eq 4+4+0+4 # 12
+
+        expect(policy_service.entries_not_touched.map(&:name)).to include('noref.test.billetto.com.')
+        expect(policy_service.entries_not_touched.map(&:name)).to include('noraf.test.billetto.com.')
+      end
+
+      context "references should be correct for" do
+        it "entries" do
+          ['www.test.billetto.com.', 'foo.test.billetto.com.', 'bar.test.billetto.com.'].each do |referenced|
+            expect(@existing_hz.resource_record_sets
+              .select{|r| r.name == referenced}
+              .select{|r| r.class == SprinkleDNS::HostedZoneEntry}
+              .first.referenced?).to eq true
+          end
+          ['noref.test.billetto.com.'].each do |unreferenced|
+            expect(@existing_hz.resource_record_sets
+              .select{|r| r.name == unreferenced}
+              .select{|r| r.class == SprinkleDNS::HostedZoneEntry}
+              .first.referenced?).to eq false
+          end
+        end
+
+        it "aliases" do
+          ['wap.test.billetto.com.', 'woo.test.billetto.com.', 'war.test.billetto.com.'].each do |referenced|
+            expect(@existing_hz.resource_record_sets
+              .select{|r| r.name == referenced}
+              .select{|r| r.class == SprinkleDNS::HostedZoneAlias}
+              .first.referenced?).to eq true
+          end
+          ['noraf.test.billetto.com.'].each do |unreferenced|
+            expect(@existing_hz.resource_record_sets
+              .select{|r| r.name == unreferenced}
+              .select{|r| r.class == SprinkleDNS::HostedZoneAlias}
+              .first.referenced?).to eq false
+          end
+        end
+
+        it "mixed" do
+          entry_to_alias = @existing_hz.resource_record_sets.select{|r| r.name == 'entry-to-alias.test.billetto.com.'}.first
+          expect(entry_to_alias.referenced?).to eq true
+          expect(entry_to_alias.class).to eq SprinkleDNS::HostedZoneEntry
+          expect(entry_to_alias.new_entry.class).to eq SprinkleDNS::HostedZoneAlias
+
+          alias_to_entry = @existing_hz.resource_record_sets.select{|r| r.name == 'alias-to-entry.test.billetto.com.'}.first
+          expect(alias_to_entry.referenced?).to eq true
+          expect(alias_to_entry.class).to eq SprinkleDNS::HostedZoneAlias
+          expect(alias_to_entry.new_entry.class).to eq SprinkleDNS::HostedZoneEntry
+        end
+      end
+
+      context "entries should be correctly set for" do
+        it 'entries' do
+          policy_service = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: true))
+
+          expect(policy_service.entries_to_create.map(&:name)).to include('www.test.billetto.com.', 'foo.test.billetto.com.')
+          expect(policy_service.entries_to_update.map(&:name)).to include('bar.test.billetto.com.')
+          expect(policy_service.entries_to_delete.map(&:name)).to include('noref.test.billetto.com.')
+        end
+
+        it 'aliases' do
+          policy_service = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: true))
+
+          expect(policy_service.entries_to_create.map(&:name)).to include('wap.test.billetto.com.', 'woo.test.billetto.com.')
+          expect(policy_service.entries_to_update.map(&:name)).to include('war.test.billetto.com.')
+          expect(policy_service.entries_to_delete.map(&:name)).to include('noraf.test.billetto.com.')
+        end
+
+        it "mixed" do
+          policy_service = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: true))
+
+          expect(policy_service.entries_to_update.map(&:name)).to include('entry-to-alias.test.billetto.com.', 'alias-to-entry.test.billetto.com.')
+        end
+      end
+
+      it "should calculate complicated compile_change_batch" do
+        policy_service = SprinkleDNS::EntryPolicyService.new(@existing_hz, SprinkleDNS::Config.new(delete: false))
+
+        expect(policy_service.compile).to eq [
+          {:action=>"UPSERT", :resource_record_set=>{:name=>"bar.test.billetto.com.", :type=>"A", :ttl=>90, :resource_records=>[{:value=>"82.82.26.26"}]}},
+          {:action=>"UPSERT", :resource_record_set=>{:name=>"war.test.billetto.com.", :type=>"A", :alias_target=>{:hosted_zone_id=>"Z215JYRZR1TBD6", :dns_name=>"dualstack.mothership-test-elb-444444444.eu-central-1.elb.amazonaws.com.", :evaluate_target_health=>false}}},
+          {:action=>"UPSERT", :resource_record_set=>{:name=>"entry-to-alias.test.billetto.com.", :type=>"A", :alias_target=>{:hosted_zone_id=>"Z215JYRZR1TBD5", :dns_name=> "dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com.", :evaluate_target_health=>false}}},
+          {:action=>"UPSERT", :resource_record_set=>{:name=>"alias-to-entry.test.billetto.com.", :type=>"A", :ttl=>80, :resource_records=>[{:value=>"80.80.24.24"}]}},
+          {:action=>"CREATE", :resource_record_set=>{:name=>"www.test.billetto.com.", :type=>"A", :ttl=>60, :resource_records=>[{:value=>"80.80.22.22"}]}},
+          {:action=>"CREATE", :resource_record_set=>{:name=>"foo.test.billetto.com.", :type=>"A", :ttl=>80, :resource_records=>[{:value=>"81.81.24.24"}]}},
+          {:action=>"CREATE", :resource_record_set=>{:name=>"wap.test.billetto.com.", :type=>"A", :alias_target=>{:hosted_zone_id=>"Z215JYRZR1TBD5", :dns_name=>"dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com.", :evaluate_target_health=>false}}},
+          {:action=>"CREATE", :resource_record_set=>{:name=>"woo.test.billetto.com.", :type=>"A", :alias_target=>{:hosted_zone_id=>"Z215JYRZR1TBD6", :dns_name=>"dualstack.mothership-test-elb-444444444.eu-central-1.elb.amazonaws.com.", :evaluate_target_health=>false}}},
+        ]
+      end
+    end
+  end
+
+  context "overwrite an entry" do
+    it 'should correctly replace an entry if not persisted' do
+      hz = SprinkleDNS::HostedZone.new('test.billetto.com.')
+
+      hz_entry = sprinkle_entry('A', 'www.test.billetto.com.', '80.80.22.22', 60, 'test.billetto.com.')
+      expect(hz_entry.persisted?).to eq false
+      hz_alias = sprinkle_alias('A', 'www.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+      expect(hz_alias.persisted?).to eq false
+
+      hz.add_or_update_hosted_zone_entry(hz_entry)
+      expect(hz.resource_record_sets).to include(hz_entry)
+      expect(hz.resource_record_sets.size).to eq 1
+
+      hz.add_or_update_hosted_zone_entry(hz_alias)
+      expect(hz.resource_record_sets).to include(hz_alias)
+      expect(hz.resource_record_sets).not_to include(hz_entry)
+      expect(hz.resource_record_sets.size).to eq 1
+    end
+
+    it 'should use #new_value if persisted' do
+      hz = SprinkleDNS::HostedZone.new('test.billetto.com.')
+
+      hz_entry = sprinkle_entry('A', 'www.test.billetto.com.', '80.80.22.22', 60, 'test.billetto.com.')
+      hz_alias = sprinkle_alias('A', 'www.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+      hz_entry.persisted!
+
+      hz.add_or_update_hosted_zone_entry(hz_entry)
+      expect(hz.resource_record_sets).to include(hz_entry)
+      expect(hz.resource_record_sets.size).to eq 1
+
+      hz.add_or_update_hosted_zone_entry(hz_alias)
+      expect(hz.resource_record_sets).not_to include(hz_alias)
+      expect(hz.resource_record_sets.size).to eq 1
+      expect(hz.resource_record_sets.first.new_entry).to eq hz_alias
+    end
+  end
+
+  context "overwrite an alias" do
+    it 'should correctly replace an alias if not persisted' do
+      hz = SprinkleDNS::HostedZone.new('test.billetto.com.')
+
+      hz_alias = sprinkle_alias('A', 'www.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+      expect(hz_alias.persisted?).to eq false
+      hz_entry = sprinkle_entry('A', 'www.test.billetto.com.', '80.80.22.22', 60, 'test.billetto.com.')
+      expect(hz_entry.persisted?).to eq false
+
+      hz.add_or_update_hosted_zone_entry(hz_alias)
+      expect(hz.resource_record_sets).to include(hz_alias)
+      expect(hz.resource_record_sets.size).to eq 1
+
+      hz.add_or_update_hosted_zone_entry(hz_entry)
+      expect(hz.resource_record_sets).to include(hz_entry)
+      expect(hz.resource_record_sets).not_to include(hz_alias)
+      expect(hz.resource_record_sets.size).to eq 1
+    end
+
+    it 'should use #new_value if persisted' do
+      hz = SprinkleDNS::HostedZone.new('test.billetto.com.')
+
+      hz_entry = sprinkle_entry('A', 'www.test.billetto.com.', '80.80.22.22', 60, 'test.billetto.com.')
+      hz_alias = sprinkle_alias('A', 'www.test.billetto.com.', 'Z215JYRZR1TBD5', 'dualstack.mothership-test-elb-546580691.eu-central-1.elb.amazonaws.com', 'test.billetto.com.')
+
+      hz_entry.persisted!
+
+      hz.add_or_update_hosted_zone_entry(hz_entry)
+      expect(hz.resource_record_sets).to include(hz_entry)
+      expect(hz.resource_record_sets.size).to eq 1
+
+      hz.add_or_update_hosted_zone_entry(hz_alias)
+      expect(hz.resource_record_sets).not_to include(hz_alias)
+      expect(hz.resource_record_sets.size).to eq 1
+      expect(hz.resource_record_sets.first.new_entry).to eq hz_alias
+    end
+  end
+end

data/spec/unit/mock_client_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe SprinkleDNS::MockClient do
+  context "#fetch" do
+    it "should return empty list when given empty array" do
+      hz = SprinkleDNS::HostedZone.new('billetto.se.')
+      en = sprinkle_entry("A", "beta.billetto.se", '88.80.188.143', 60, hz.name)
+      hz.add_or_update_hosted_zone_entry(en)
+      c42 = SprinkleDNS::MockClient.new([en])
+
+      expect(c42.fetch_hosted_zones).to eq []
+      expect(c42.fetch_hosted_zones(filter: [])).to eq []
+    end
+
+    it "should initialize correctly" do
+      hz = SprinkleDNS::HostedZone.new('billetto.se.')
+      en = sprinkle_entry("A", "beta.billetto.se", '88.80.188.143', 60, hz.name)
+      hz.add_or_update_hosted_zone_entry(en)
+      c42 = SprinkleDNS::MockClient.new([hz])
+
+      expect(en.persisted?).to be false
+      c42.fetch_hosted_zones(filter: [hz.name])
+      expect(en.persisted?).to be true
+    end
+
+    it "should filter correctly" do
+      hosted_zones = []
+
+      hzdk = SprinkleDNS::HostedZone.new('billetto.dk.')
+
+      e1 = sprinkle_entry("A", "beta.billetto.dk.", '88.80.188.143', 60, hzdk.name)
+      e2 = sprinkle_entry("A", "alph.billetto.dk.", '88.80.188.144', 60, hzdk.name)
+      e3 = sprinkle_entry("A", "lolp.billetto.dk.", '88.80.188.145', 60, hzdk.name)
+
+      [e1, e2, e3].each do |entry|
+        hzdk.add_or_update_hosted_zone_entry(entry)
+      end
+
+      hosted_zones << hzdk
+
+      hzse = SprinkleDNS::HostedZone.new('billetto.se.')
+
+      e4 = sprinkle_entry("A", "beta.billetto.se", '88.80.188.143', 60, hzse.name)
+      e5 = sprinkle_entry("A", "alph.billetto.se", '88.80.188.144', 60, hzse.name)
+      e6 = sprinkle_entry("A", "lolp.billetto.se", '88.80.188.145', 60, hzse.name)
+
+      [e4, e5, e6].each do |entry|
+        hzse.add_or_update_hosted_zone_entry(entry)
+      end
+
+      hosted_zones << hzse
+
+      c42 = SprinkleDNS::MockClient.new(hosted_zones)
+      expect(c42.fetch_hosted_zones(filter: ['billetto.dk.', 'billetto.se.'])).to include(hzdk, hzse)
+      expect(c42.fetch_hosted_zones(filter: ['billetto.dk.'])).to include(hzdk)
+      expect(c42.fetch_hosted_zones(filter: ['billetto.se.'])).to include(hzse)
+    end
+  end
+end

data/spec/unit/sprinkle_dns_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+RSpec.describe SprinkleDNS::Client do
+  it 'should parse and setup' do
+    r53c = SprinkleDNS::Route53Client.new('1','2')
+    sdns = SprinkleDNS::Client.new(r53c)
+
+    sdns.entry('A',     'kaspergrubbe.com',             '88.80.80.80', 60)
+    sdns.entry('A',     'assets.kaspergrubbe.com',      '88.80.80.80', 60)
+    sdns.entry('MX',    'mail.kaspergrubbe.com',        ['10 mailserver.example.com', '20 mailserver2.example.com'], 300)
+    sdns.entry('MX',    'main.kaspergrubbe.com',        ['10 mailserver.example.com'], 300)
+    sdns.entry('A',     'streamy.kaspergrubbe.com.',    '198.211.96.200', 60)
+    sdns.entry('A',     'blog.kaspergrubbe.com',        '198.211.96.200', 60)
+
+    sdns.entry('CNAME', 'www.es.kaspergrubbe.com',      "#{Time.now.to_i}.example.com.", 42, 'es.kaspergrubbe.com')
+    sdns.entry('CNAME', 'staging.es.kaspergrubbe.com.', "#{Time.now.to_i}.example.com.", 42, 'es.kaspergrubbe.com.')
+
+    expect(sdns.wanted_hosted_zones.count).to eq 2
+    expect(sdns.wanted_hosted_zones.select{|whz| whz.name == 'kaspergrubbe.com.'}.first).to be_truthy
+    expect(sdns.wanted_hosted_zones.select{|whz| whz.name == 'es.kaspergrubbe.com.'}.first).to be_truthy
+
+    expect(sdns.wanted_hosted_zones.select{|whz| whz.name == 'kaspergrubbe.com.'}.first.resource_record_sets.count).to eq 6
+    expect(sdns.wanted_hosted_zones.select{|whz| whz.name == 'es.kaspergrubbe.com.'}.first.resource_record_sets.count).to eq 2
+  end
+
+  it 'should support alias records' do
+    r53c = SprinkleDNS::Route53Client.new('1','2')
+    sdns = SprinkleDNS::Client.new(r53c)
+
+    sdns.entry('A', 'billetto.com',     '88.80.80.80', 60)
+    sdns.alias('A', 'www.billetto.com', 'Z215JYRZR1TBD5', 'dualstack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com')
+
+    expect(sdns.wanted_hosted_zones.count).to eq 1
+    expect(sdns.wanted_hosted_zones.select{|whz| whz.name == 'billetto.com.'}.first).to be_truthy
+    expect(sdns.wanted_hosted_zones.select{|whz| whz.name == 'billetto.com.'}.first.resource_record_sets.count).to eq 2
+  end
+
+  context "overwrites" do
+    it 'should allow overwrites for a-records' do
+      r53c = SprinkleDNS::Route53Client.new('1','2')
+      sdns = SprinkleDNS::Client.new(r53c)
+
+      ['billetto.at', 'billetto.io', 'billetto.my'].each do |domain|
+        sdns.entry('A', domain, '88.80.80.80', 60)
+        sdns.entry('A', "www.#{domain}", '88.80.80.80', 60)
+      end
+      # Overwrite and null-route to localhost
+      sdns.entry('A', 'billetto.at', '127.0.0.1', 70)
+
+      hz = sdns.wanted_hosted_zones.select{|hz| hz.name == 'billetto.at.'}.first
+      rrs = hz.resource_record_sets.select{|rrs| rrs.type == 'A' && rrs.name == 'billetto.at.'}.first
+
+      expect(rrs.ttl).to eq 70
+      expect(rrs.value).to eq ["127.0.0.1"]
+    end
+
+    it 'should allow overwrites for aliases' do
+      r53c = SprinkleDNS::Route53Client.new('1','2')
+      sdns = SprinkleDNS::Client.new(r53c)
+
+      ['billetto.at', 'billetto.io', 'billetto.my'].each do |domain|
+        sdns.alias('A', domain, 'Z215JYRZR1TBD5', 'dualstack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com')
+      end
+      sdns.alias('A', 'billetto.at', 'X317JYRZR1TBD5', 'triplestack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com')
+
+      hz = sdns.wanted_hosted_zones.select{|hz| hz.name == 'billetto.at.'}.first
+      rrs = hz.resource_record_sets.select{|rrs| rrs.type == 'A' && rrs.name == 'billetto.at.'}.first
+
+      expect(rrs.target_hosted_zone_id).to eq 'X317JYRZR1TBD5'
+      expect(rrs.target_dns_name).to eq 'triplestack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com.'
+    end
+
+    it 'should allow overwrites of an a-record with an alias' do
+      r53c = SprinkleDNS::Route53Client.new('1','2')
+      sdns = SprinkleDNS::Client.new(r53c)
+
+      sdns.entry('A', "billetto.pl", '88.80.80.80', 60)
+      sdns.alias('A', 'billetto.pl', 'Z215JYRZR1TBD5', 'dualstack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com')
+
+      hz = sdns.wanted_hosted_zones.select{|hz| hz.name == 'billetto.pl.'}.first
+      rrs = hz.resource_record_sets.select{|rrs| rrs.type == 'A' && rrs.name == 'billetto.pl.'}.first
+
+      expect(rrs.target_hosted_zone_id).to eq 'Z215JYRZR1TBD5'
+      expect(rrs.target_dns_name).to eq 'dualstack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com.'
+    end
+
+    it 'should allow overwrites of an alias with an a-record' do
+      r53c = SprinkleDNS::Route53Client.new('1','2')
+      sdns = SprinkleDNS::Client.new(r53c)
+
+      sdns.alias('A', 'billetto.pl', 'Z215JYRZR1TBD5', 'dualstack.mothership-prod-elb-546580691.eu-central-1.elb.amazonaws.com')
+      sdns.entry('A', "billetto.pl", '88.80.80.80', 60)
+
+      hz = sdns.wanted_hosted_zones.select{|hz| hz.name == 'billetto.pl.'}.first
+      rrs = hz.resource_record_sets.select{|rrs| rrs.type == 'A' && rrs.name == 'billetto.pl.'}.first
+
+      expect(rrs.ttl).to eq 60
+      expect(rrs.value).to eq ['88.80.80.80']
+    end
+  end
+
+  context 'syncing' do
+    before(:all) do
+      hz = SprinkleDNS::HostedZone.new('billetto.se.')
+      en = sprinkle_entry("A", "beta.billetto.se", '88.80.188.143', 60, hz.name)
+      hz.add_or_update_hosted_zone_entry(en)
+
+      r42c = SprinkleDNS::MockClient.new([hz])
+      @sdns = SprinkleDNS::Client.new(r42c)
+
+      @sdns.entry('A', 'billetto.se', '88.80.80.80', 60)
+      @sdns.entry('A', 'beta.billetto.se', '88.80.80.80', 70)
+    end
+
+    it 'sprinkle! should return change_requests' do
+      _, change_requests = @sdns.sprinkle!
+
+      change_requests.each do |cr|
+        expect(cr.in_sync).to eq true
+        expect(cr.tries).to eq cr.tries_needed
+      end
+    end
+  end
+
+  context 'delete config option' do
+    before(:all) do
+      @hz01 = SprinkleDNS::HostedZone.new('colourful.co.uk.')
+
+      e1 = SprinkleDNS::HostedZoneEntry.new('A', 'updateme.colourful.co.uk.', Array.wrap('80.80.80.80'), 3600, @hz01.name)
+      e2 = SprinkleDNS::HostedZoneEntry.new('TXT', 'txt.colourful.co.uk.', %Q{"#{Time.now.to_i}"}, 60, @hz01.name)
+      e3 = SprinkleDNS::HostedZoneEntry.new('A', 'nochange.colourful.co.uk.', Array.wrap('80.80.80.80'), 60, @hz01.name)
+      e4 = SprinkleDNS::HostedZoneEntry.new('A', 'noref.colourful.co.uk.', Array.wrap('80.80.80.80'), 3600, @hz01.name)
+      e5 = SprinkleDNS::HostedZoneEntry.new('A', 'www1.colourful.co.uk.', Array.wrap('80.80.80.80'), 60, @hz01.name)
+      e6 = SprinkleDNS::HostedZoneEntry.new('A', 'www2.colourful.co.uk.', Array.wrap('80.80.80.80'), 60, @hz01.name)
+      e7 = SprinkleDNS::HostedZoneEntry.new('A', 'www3.colourful.co.uk.', Array.wrap('80.80.80.80'), 60, @hz01.name)
+
+      # We are emulating that these records are already live, mark them as persisted
+      [e1, e2, e3, e4, e5, e6, e7].each do |persisted|
+        persisted.persisted!
+        @hz01.resource_record_sets << persisted
+      end
+    end
+
+    it 'it should not list deletes if delete=false' do
+      client = SprinkleDNS::MockClient.new([@hz01])
+      sdns = SprinkleDNS::Client.new(client, dry_run: true, delete: false)
+
+      sdns.entry('A', 'updateme.colourful.co.uk', '90.90.90.90', 3601)
+      sdns.entry('A', 'addnew.colourful.co.uk', '90.90.90.90', 3601)
+      sdns.entry('TXT', 'txt.colourful.co.uk', %Q{"#{Time.now.to_i+1}"}, 60)
+      sdns.entry('A', 'nochange.colourful.co.uk.', Array.wrap('80.80.80.80'), 60)
+
+      existing_hosted_zones, _ = sdns.sprinkle!
+
+      expect(existing_hosted_zones.size).to eq 1
+
+      policy_service = SprinkleDNS::EntryPolicyService.new(@hz01, sdns.config)
+      expect(policy_service.entries_to_delete.size).to eq 0
+      expect(policy_service.compile.select{|rrset| rrset[:action] == 'DELETE'}.count).to eq 0
+    end
+
+    it 'it should list deletes if delete=true' do
+      client = SprinkleDNS::MockClient.new([@hz01])
+      sdns = SprinkleDNS::Client.new(client, dry_run: true, delete: true)
+
+      sdns.entry('A', 'updateme.colourful.co.uk', '90.90.90.90', 3601)
+      sdns.entry('A', 'addnew.colourful.co.uk', '90.90.90.90', 3601)
+      sdns.entry('TXT', 'txt.colourful.co.uk', %Q{"#{Time.now.to_i+1}"}, 60)
+      sdns.entry('A', 'nochange.colourful.co.uk.', Array.wrap('80.80.80.80'), 60)
+
+      existing_hosted_zones, _ = sdns.sprinkle!
+
+      expect(existing_hosted_zones.size).to eq 1
+
+      policy_service = SprinkleDNS::EntryPolicyService.new(@hz01, sdns.config)
+      expect(policy_service.entries_to_delete.size).to eq 4
+      expect(policy_service.compile.select{|rrset| rrset[:action] == 'DELETE'}.count).to eq 4
+    end
+  end
+
+  context 'record validation' do
+    it 'should only allow valid string records' do
+      valid_records = ['SOA','A','TXT','NS','CNAME','MX','NAPTR','PTR','SRV','SPF','AAAA']
+
+      valid_records.each do |record_type|
+        r53c = SprinkleDNS::Route53Client.new('1','2')
+        sdns = SprinkleDNS::Client.new(r53c)
+
+        sdns.entry(record_type, 'kaspergrubbe.com', '88.80.80.80')
+      end
+    end
+
+    it 'should not allow symbols for records' do
+      invalid_records = [:SOA, :A, :TXT, :NS, :CNAME, :MX, :NAPTR, :PTR, :SRV, :SPF, :AAAA]
+
+      invalid_records.each do |record_type|
+        r53c = SprinkleDNS::Route53Client.new('1','2')
+        sdns = SprinkleDNS::Client.new(r53c)
+
+        expect{sdns.entry(record_type, 'kaspergrubbe.com', '88.80.80.80')}.to raise_error(SprinkleDNS::RecordNotAString)
+      end
+    end
+
+    it 'should not allow other types of records' do
+      invalid_records = ['a', 'r', 'p']
+
+      invalid_records.each do |record_type|
+        r53c = SprinkleDNS::Route53Client.new('1','2')
+        sdns = SprinkleDNS::Client.new(r53c)
+
+        expect{sdns.entry(record_type, 'kaspergrubbe.com', '88.80.80.80')}.to raise_error(SprinkleDNS::RecordNotValid)
+      end
+    end
+  end
+
+  context 'ttl validation' do
+    it 'should allow integers' do
+      (1..(3600*60)).minmax.each do |ttl|
+        r53c = SprinkleDNS::Route53Client.new('1','2')
+        sdns = SprinkleDNS::Client.new(r53c)
+
+        sdns.entry('A', 'kaspergrubbe.com', '88.80.80.80', ttl)
+      end
+    end
+
+    it 'should not allow strings' do
+      (1..(3600*60)).minmax.each do |ttl|
+        r53c = SprinkleDNS::Route53Client.new('1','2')
+        sdns = SprinkleDNS::Client.new(r53c)
+
+        expect{sdns.entry('A', 'kaspergrubbe.com', '88.80.80.80', ttl.to_s)}.to raise_error(SprinkleDNS::TtlNotInteger)
+      end
+    end
+  end
+end

data/sprinkle_dns.gemspec

@@ -0,0 +1,29 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'sprinkle_dns/version'
+
+Gem::Specification.new do |gem|
+  gem.name        = "sprinkle_dns"
+  gem.version     = SprinkleDNS::VERSION
+  gem.authors     = ["Kasper Grubbe"]
+  gem.email       = ["kaspergrubbe@gmail.com"]
+  gem.homepage    = "http://github.com/gfish/sprinkle_dns"
+  gem.summary     = %q{Make handling DNS easier}
+  gem.description = %q{Make handling DNS easier by using simple Ruby constructs}
+
+  gem.licenses = ['MIT', 'GPL-2.0']
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = ">= 2.4.0"
+  gem.add_runtime_dependency 'aws-sdk-route53', '~> 1.21'
+
+  gem.add_development_dependency "rspec", '~> 3.8'
+  gem.add_development_dependency "simplecov", '~> 0.16'
+  gem.add_development_dependency "pry", '~> 0.12'
+  gem.add_development_dependency "rake", '~> 12.3'
+  gem.add_development_dependency "vcr", '~> 3.0'
+  gem.add_development_dependency "webmock", '~> 2.3'
+end