cloud-dyndns 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+tags
+test/fixtures/test.log
+.bundle
+pkg/*
+

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org/'
+
+gemspec
+
+group :test do
+  gem 'minitest-reporters'
+  gem 'minitest-matchers'
+  gem 'minitest'
+  gem 'mocha'
+  gem 'minitest-spec-expect'
+end
+
+group :development do
+  gem 'guard'
+  gem 'guard-minitest'
+end

data/Gemfile.lock

@@ -0,0 +1,94 @@
+PATH
+  remote: .
+  specs:
+    cloud-dyndns (0.0.1)
+      fog (= 1.18.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.4.3)
+    builder (3.2.2)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    excon (0.28.0)
+    ffi (1.9.3)
+    fog (1.18.0)
+      builder
+      excon (~> 0.28.0)
+      formatador (~> 0.2.0)
+      mime-types
+      multi_json (~> 1.0)
+      net-scp (~> 1.1)
+      net-ssh (>= 2.1.3)
+      nokogiri (~> 1.5)
+      ruby-hmac
+    formatador (0.2.4)
+    guard (2.2.4)
+      formatador (>= 0.2.4)
+      listen (~> 2.1)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-minitest (2.1.1)
+      guard (~> 2.0)
+      minitest (>= 3.0)
+    hashie (2.0.5)
+    listen (2.2.0)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.4)
+    metaclass (0.0.1)
+    method_source (0.8.2)
+    mime-types (2.0)
+    mini_portile (0.5.2)
+    minitest (4.7.5)
+    minitest-matchers (1.3.0)
+      minitest (~> 4.7)
+    minitest-reporters (0.14.23)
+      ansi
+      builder
+      minitest (>= 2.12, < 5.0)
+      powerbar
+    minitest-spec-expect (0.1.1)
+      minitest (>= 2.4)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.8.2)
+    net-scp (1.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.7.0)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+    powerbar (1.0.11)
+      ansi (~> 1.4.0)
+      hashie (>= 1.1.0)
+    pry (0.9.12.3)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.2)
+      ffi (>= 0.5.0)
+    ruby-hmac (0.4.0)
+    slop (3.4.7)
+    thor (0.18.1)
+    timers (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  cloud-dyndns!
+  guard
+  guard-minitest
+  minitest
+  minitest-matchers
+  minitest-reporters
+  minitest-spec-expect
+  mocha
+  rake

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+
+  # with Minitest::Spec
+   watch(%r{^spec/(.*)_spec\.rb})
+   watch(%r{^lib/(.+)\.rb})         { |m| "spec/#{m[1]}_spec.rb" }
+   watch(%r{^spec/spec_helper\.rb}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                   { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb})
+  # watch(%r{^test/test_helper\.rb}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 nat
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# cloud-dyndns
+
+Use a cloud DNS provider like a dynamic dns service.  A Ruby executable to
+stick in a crontab.  If the excellent [fog](http://fog.io/) supports the
+service, cloud-dyndns will (probably) work for you.
+
+# install
+
+```
+gem install cloud-dyndns
+```
+
+# usage
+
+```
+cloud-dyndns --config ~/$your_yaml_file
+```
+
+where `$your_yaml_file` is the path to a file that looks like:
+
+# config example
+
+```yaml
+:credentials:
+  :provider: 'AWS'
+  :aws_secret_access_key: 'your-secretkeykeykey'
+  :aws_access_key_id: 'your-access-id'
+:zones:
+  - :domain: "looting.biz"
+    :targets:
+      - "phl.looting.biz"
+      - "*.phl.looting.biz"
+  - :domain: "narf.io"
+    :targets:
+      - "phl.narf.io"
+      - "*.phl.narf.io"
+```
+
+# command line options
+
+there's -c/--config and -l/--log:
+
+* --config is mandatory:  a path to your config file
+* --log is optional:  if not given it will log to stdout.  if given a path it
+  will log to that file.
+
+# crontab example
+
+```
+*/15 * * * * cloud-dyndns --config /Users/nat/.cloud-dyndns.yml > ~/.cdyndns.log
+```
+
+will make sure your domain is up to date every 15 minutes, and will log to
+`~/.cdyndns.log`
+
+If you use rbenv, rvm, or rb-john-wanamaker...I'm not sure what you can do.  I
+vaguely remember with rvm you could create "wrappers".  I know it's possible to
+use software the way you might want.  Sorry I'm not more helpful here.
+
+# other
+
+I refactored this and added tests for release.  I've been using it for about a
+year.  [Fog](http://fog.io/) is good, contributions welcome.
+
+# testing
+
+```
+bundle install --without development
+```
+
+```
+rake test
+```
+
+This will allow running tests on ruby >= 1.9.2
+
+# development
+
+```
+bundle install --without nothing
+```
+
+(See [this SO
+post](http://stackoverflow.com/questions/4118055/rails-bundler-doesnt-install-gems-inside-a-group)
+about why I suggest just throwing that `--without nothing` in there.
+
+```
+bundle exec guard
+```
+
+Development requires Ruby >= 1.9.3 due to the listen gem's requirement of Ruby
+1.9.3.
+
+# todo
+
+* allow setting of hostmaster email?
+* allow usage of a different wtfismyip-type service?
+* use a version of fog that requires only 1.8.7?
+  * this would include adding a fix for [this
+    issue](https://github.com/fog/fog/issues/1093) in this library.
+

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+
+Rake::TestTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :test

data/bin/cloud-dyndns

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require File.expand_path(File.dirname(__FILE__) + '/../cloud-dyndns')
+
+config = CloudDyndns::Config.new(ARGV)
+dns    = CloudDyndns::Updater.new(config.config, config.log)
+
+dns.update!

data/cloud-dyndns.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+description = %q{
+update DNS entries on cloud providers (Route 53 et al) based on your current external IP address. think like a dyndns updater. no-ip, et al.
+}
+
+Gem::Specification.new do |spec|
+  spec.name          = "cloud-dyndns"
+  spec.version       = CloudDyndns::VERSION
+  spec.authors       = ["Nat Lownes"]
+  spec.email         = ["nat.lownes@gmail.com"]
+  spec.description   = description
+  spec.summary       = description
+  spec.homepage      = "https://github.com/natlownes/cloud-dyndns"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "fog", '=1.18.0'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "minitest-matchers"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "minitest-spec-expect"
+end

data/cloud-dyndns.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+
+
+module CloudDyndns
+  ROOTDIR=File.expand_path(File.join(File.dirname(__FILE__)))
+  LIBDIR=File.join(ROOTDIR, 'lib')
+end
+
+
+require File.join CloudDyndns::LIBDIR, 'version'
+require File.join CloudDyndns::LIBDIR, 'config'
+require File.join CloudDyndns::LIBDIR, 'updater'

data/doc/crontab_example

@@ -0,0 +1,2 @@
+*/15 * * * * cd ~/.ddns && /Users/nat/.rvm/bin/ruby-1.9.2-p290@ddns phl_looting_biz.rb > ~/.ddns/out.log
+

data/lib/config.rb

@@ -0,0 +1,68 @@
+require 'optparse'
+require 'logger'
+require 'yaml'
+
+
+module CloudDyndns
+
+  class Config
+
+    def usage_banner
+      <<-EOF
+    USAGE:  cloud-dyndns --config [/path/to/config.yaml] --log [/path/to/log]
+      EOF
+    end
+
+    def config_instructions
+      'Path to config file (required)'
+    end
+
+    def log_instructions
+      'Path to log file (if not given, will write to stdout)'
+    end
+
+    def initialize(args)
+      check_args(args)
+
+      parser = OptionParser.new do |opts|
+        opts.banner = usage_banner
+
+        opts.on '-c', '--config PATH', config_instructions do |v|
+          set_config!(v)
+        end
+
+        opts.on '-l', '--log [PATH]', log_instructions do |v|
+          set_log!(v)
+        end
+      end
+
+      parser.parse!(args)
+    end
+
+    def log
+      @log ||= ::Logger.new(@log_path || STDOUT)
+    end
+
+    def config
+      @config ||= ::YAML.load_file(@config_path)
+    end
+
+    private
+
+    def check_args(args)
+      if !args or args.length == 0
+        puts usage_banner
+        exit(1)
+      end
+    end
+
+    def set_config!(path)
+      @config_path = File.expand_path(path) if path
+    end
+
+    def set_log!(path)
+      @log_path = path
+      ::Kernel.at_exit { @log.close() if @log }
+    end
+  end
+end

data/lib/updater.rb

@@ -0,0 +1,169 @@
+require 'open-uri'
+require 'fog'
+
+
+class CloudDyndns::Updater
+  class NoIPAddressError < StandardError
+    def message
+      "could not get your current ip address: \n
+       cowardly refusing to update your DNS record to nothing"
+    end
+  end
+
+  class NoTargetsSpecified < StandardError
+    def message
+      "no domain names to update were specified"
+    end
+  end
+
+  def self.domain_name_to_provider_name(name)
+    "#{name}."
+  end
+
+  def initialize(config_object, logger)
+    @credentials  = config_object[:credentials]
+    @log          = logger
+    @zone_configs = config_object[:zones]
+  end
+
+  def update!
+    updates = []
+    zone_configs.each do |zone_config|
+      targets        = zone_config[:targets]
+      top_level_zone = zone_config[:domain]
+
+      check_config_targets(top_level_zone, targets)
+
+      zone = find_zone_by_name(top_level_zone)
+
+      targets.each do |target|
+        updates << update_record_for_zone(zone, target, zone_config)
+      end
+    end
+
+    updates = []
+  end
+
+  def zones
+    dns.zones
+  end
+
+  def dns
+    @dns ||= create_dns(@credentials)
+  end
+
+  def log
+    @log
+  end
+
+  def zone_configs
+    @zone_configs || []
+  end
+
+  def find_zone_by_name(zone_domain)
+    find_zone_by_domain(zone_domain) or create_zone_by_domain(zone_domain)
+  end
+
+  def find_zone_by_domain(domain_name)
+    zones.find do |z|
+      z.domain.match(%r{#{domain_name}\.$})
+    end
+  end
+
+  def create_zone_by_domain(domain_name)
+    zones.create({
+      :domain => domain_name,
+      :email =>  "hostmaster@#{domain_name}"
+    })
+  end
+
+  def records_for_zone(zone)
+    zone.records.reload
+  end
+
+  def find_record_for_zone_by_name(zone, name)
+    records_for_zone(zone).find do |r|
+      r.name == self.class.domain_name_to_provider_name(name)
+    end
+  end
+
+  def update_record_for_zone(zone, target, zone_config={})
+    # zone is the zone object from Fog
+    # target is a string, like "*.example.com"
+    # or just name.example.com" or just
+    # "example.com"
+    # zone_config is the object from the zones array
+    # in the yaml config
+    current_ip = get_ip_address()
+
+    if current_ip.empty?
+      raise NoIPAddressError.new
+    end
+
+    record     = find_record_for_zone_by_name(zone, target)
+
+    target_attributes = {
+      :name => target,
+      :value => current_ip,
+      :ttl => zone_config[:ttl]
+    }
+
+    if is_record_create?(record)
+      return create_record_for_zone(zone, target_attributes)
+    end
+
+    if is_record_update?(record)
+      record.destroy
+      return create_record_for_zone(zone, target_attributes)
+    end
+
+    record
+  end
+
+  private
+
+  def check_config_targets(top_level_zone, targets)
+    if !targets or targets.empty?
+      @log << %{
+      #{top_level_zone} has zero targets in config, add some domains to update in your config file
+      }
+      raise NoTargetsSpecified.new
+    end
+  end
+
+  def create_dns(credentials)
+    Fog::DNS.new(credentials)
+  end
+
+  def default_ttl
+    300
+  end
+
+  def get_ip_address
+    ip_url = "http://wtfismyip.com/text"
+
+    @external_ip ||=  OpenURI.open_uri(ip_url).read.strip
+  end
+
+  def is_record_create?(record)
+    !record
+  end
+
+  def is_record_update?(record)
+    # record exists and is not our external ip
+    external_ip = get_ip_address()
+    record && !record.value.include?(external_ip)
+  end
+
+  def create_record_for_zone(zone, attrs={})
+    attributes = {
+      :ttl => (attrs[:ttl] || default_ttl()),
+      :value => attrs[:value],
+      :name => attrs[:name],
+      :type => 'A'
+    }
+    zone.records.create(attributes)
+    @log << "created record: #{attributes.to_yaml}"
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module CloudDyndns
+  VERSION = "0.0.1"
+end

data/spec/config_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+root = CloudDyndns::ROOTDIR
+
+config_file_path   = File.join(root, 'spec', 'fixtures', 'config.yml')
+test_log_path      = File.join(root, 'spec', 'fixtures', 'test.log')
+cloud_dyndyns_path = File.join(root, 'bin', 'cloud-dyndns')
+
+
+describe 'option parsing' do
+
+  describe  'with no options' do
+    it 'should exit with exit code 1' do
+      exited_status_zero = system(cloud_dyndyns_path)
+
+      expect(exited_status_zero).to_equal false
+    end
+
+    it 'should print the usage banner to stdout' do
+      out = `#{cloud_dyndyns_path}`
+
+      expect(out).to_match(/USAGE:  cloud-dyndns/)
+    end
+
+  end
+
+  describe 'with invalid --config' do
+
+    it 'should raise MissingArgument' do
+      args = ['--config']
+
+      expect { CloudDyndns::Config.new(args) }.
+        to_raise OptionParser::MissingArgument
+    end
+
+  end
+
+  describe 'with valid options' do
+    after do
+      FileUtils.rm_rf(test_log_path)
+    end
+
+    it 'should read the config file' do
+      args = ['--config', config_file_path]
+      config = CloudDyndns::Config.new(args)
+
+      expect(config.config[:credentials][:provider]).to_equal 'AWS'
+      expect(config.config[:zones][0][:domain]).to_equal 'looting.biz'
+      expect(config.config[:zones][1][:domain]).to_equal 'narf.io'
+
+      expect(
+        config.config[:credentials][:aws_secret_access_key]
+      ).to_equal 'honk-secret'
+
+      expect(
+        config.config[:credentials][:aws_access_key_id]
+      ).to_equal 'honk-key'
+    end
+
+    describe 'with no log option' do
+      it 'should set a log to stdout' do
+        args = ['--config', config_file_path]
+        config = CloudDyndns::Config.new(args)
+
+        logdev = config.log.instance_variable_get :@logdev
+
+        expect(logdev.dev).to_equal $stdout
+      end
+    end
+
+    describe 'with a log option' do
+      it 'should create a file at that path' do
+        args = ['--config', config_file_path, '--log', test_log_path]
+        config = CloudDyndns::Config.new(args)
+
+        logdev = config.log.instance_variable_get :@logdev
+
+        expect(logdev.filename).to_equal test_log_path
+      end
+    end
+
+  end #valid options
+end
+

data/spec/fixtures/config.yml

@@ -0,0 +1,17 @@
+:credentials:
+  :provider: 'AWS'
+  :aws_secret_access_key: 'honk-secret'
+  :aws_access_key_id: 'honk-key'
+:zones:
+  - :domain: "looting.biz"
+    :targets:
+      - "phl.looting.biz"
+      - "*.phl.looting.biz"
+    :ttl: 600
+  - :domain: "narf.io"
+    :targets:
+      - "phl.narf.io"
+      - "*.phl.narf.io"
+
+
+

data/spec/test_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'fileutils'
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/mock'
+require 'minitest/reporters'
+require 'minitest/matchers'
+require 'minitest/spec/expect'
+require 'mocha/setup'
+
+require File.join(File.dirname(__FILE__), '..', 'cloud-dyndns')
+
+Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]

data/spec/updater_spec.rb

@@ -0,0 +1,313 @@
+require 'ostruct'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+root = CloudDyndns::ROOTDIR
+
+config_file_path   = File.join(root, 'spec', 'fixtures', 'config.yml')
+test_log_path      = File.join(root, 'spec', 'fixtures', 'test.log')
+
+Fog.mock!
+test_logger = Logger.new(test_log_path)
+config      = YAML.load_file(config_file_path)
+
+
+describe 'CloudDyndns::Updater' do
+
+  after do
+    FileUtils.rm_rf test_log_path
+  end
+  describe '.domain_name_to_provider_name' do
+    it 'should return the given name appended with a "."' do
+      result = CloudDyndns::Updater.domain_name_to_provider_name('ox')
+
+      expect(result).to_equal 'ox.'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should set a dns interface' do
+      dns = CloudDyndns::Updater.new(config, test_logger)
+
+      expect(dns.dns).to_respond_to :zones
+    end
+
+    it 'should set a log interface' do
+      dns = CloudDyndns::Updater.new(config, test_logger)
+
+      expect(dns.log.class).to_equal ::Logger
+    end
+
+    it 'should set zone_configs' do
+      dns = CloudDyndns::Updater.new(config, test_logger)
+
+      expect(dns.zone_configs).to_not_be_empty
+      expect(dns.zone_configs[0][:domain]).to_equal 'looting.biz'
+      expect(dns.zone_configs[0][:targets]).to_include 'phl.looting.biz'
+    end
+  end
+
+  describe '#find_zone_by_name' do
+    before do
+      @dns = CloudDyndns::Updater.new(config, test_logger)
+    end
+
+    describe 'when a zone is found' do
+      before do
+        @mock_zone = {}
+        @dns.expects(:find_zone_by_domain).
+          with('looting.biz').
+          returns(@mock_zone)
+      end
+
+      it 'should return that zone' do
+        expect(@dns.find_zone_by_name('looting.biz')).to_equal(@mock_zone)
+      end
+    end
+
+    describe 'when a zone is not found' do
+      before do
+        @dns.expects(:find_zone_by_domain).
+          with('looting.biz').
+          returns(nil)
+      end
+
+      it 'should create a new zone for the given domain' do
+        zone = @dns.find_zone_by_name('looting.biz')
+
+        expect(zone.domain).to_equal 'looting.biz'
+      end
+    end
+
+    it 'should return a zone' do
+      dns = CloudDyndns::Updater.new(config, test_logger)
+
+      result = dns.find_zone_by_name('honk')
+
+      expect(result).to_respond_to :records
+    end
+  end
+
+  describe '#find_zone_by_domain' do
+    before do
+      @dns = CloudDyndns::Updater.new(config, test_logger)
+    end
+
+    it 'should return a domain if it matches the domain with a trailing "."' do
+      zone = @dns.zones.create(
+        :domain => 'looting.biz.'
+      )
+      found_zone = @dns.find_zone_by_domain('looting.biz')
+
+      expect(found_zone.domain).to_equal 'looting.biz.'
+    end
+
+    it 'should return nil if not found' do
+      @dns.zones.clear()
+      found_zone = @dns.find_zone_by_domain('narf.io')
+
+      expect(found_zone).to_be_nil
+    end
+  end
+
+  describe '#create_zone_by_domain' do
+    before do
+      @dns = CloudDyndns::Updater.new(config, test_logger)
+    end
+
+    it 'should create a zone for the passed domain' do
+      zone = @dns.create_zone_by_domain('looting.biz')
+
+      expect(zone.domain).to_equal 'looting.biz'
+    end
+
+    it 'should set the :email as hostmaster@{{passed domain}}' do
+      @dns.stubs(:zones).returns(mock_zones = mock())
+
+      mock_zones.expects(:create).with(({
+          :domain => 'example.com',
+          :email => 'hostmaster@example.com'
+        })
+      )
+
+      @dns.create_zone_by_domain('example.com')
+    end
+  end
+
+  describe '#records_for_zone' do
+    before do
+      @dns = CloudDyndns::Updater.new(config, test_logger)
+    end
+
+    it 'should get the most up to date records for the zone' do
+      zone = mock()
+      records = mock()
+      zone.expects(:records).returns(records)
+      records.expects(:reload)
+
+      @dns.records_for_zone(zone)
+    end
+  end
+
+  describe '#find_record_for_zone_by_name' do
+    before do
+      @dns = CloudDyndns::Updater.new(config, test_logger)
+    end
+
+    it 'should return the zone if the name matches the given name + "."' do
+      zone = @dns.zones.create(:domain => 'horseblood.biz')
+      # openstruct because it behaves like the returned object
+      record = OpenStruct.new(
+        :name => 'phl.horseblood.biz.',
+        :value => "8.8.8.8",
+        :type => 'A'
+      )
+
+      @dns.stubs(:records_for_zone).returns([record])
+
+      expect(@dns.find_record_for_zone_by_name(zone, 'phl.horseblood.biz')).
+             to_equal record
+
+    end
+  end
+
+  describe '#update_record_for_zone' do
+
+    before do
+      @dns = CloudDyndns::Updater.new(config, test_logger)
+    end
+
+    describe 'when current_ip is empty' do
+      it 'should raise error' do
+        @dns.stubs(:get_ip_address).returns('')
+        zone   = mock()
+        target = 'phl.looting.biz'
+
+        expect(lambda {@dns.update_record_for_zone(zone, target) }).
+          to_raise CloudDyndns::Updater::NoIPAddressError
+      end
+    end
+
+    describe 'when current ip is not empty' do
+      before do
+        @dns.stubs(:get_ip_address).returns('8.8.4.4')
+      end
+
+      describe 'when record does not exist' do
+        before do
+          @dns.stubs(:find_record_for_zone_by_name).returns(nil)
+        end
+
+        it 'should call create_record_for_zone' do
+          zone = mock()
+          expected_attrs = {
+            :name => 'ff.phl.looting.biz',
+            :value => '8.8.4.4',
+            :ttl => nil
+          }
+
+          @dns.expects(:create_record_for_zone).with(zone, expected_attrs)
+
+          @dns.update_record_for_zone(zone, 'ff.phl.looting.biz')
+        end
+      end
+
+      describe 'when record exists' do
+        before do
+          @mock_record = mock()
+          @dns.stubs(:find_record_for_zone_by_name).returns(@mock_record)
+        end
+
+        describe 'and matches current ip address' do
+          before do
+            @mock_zone = mock()
+            @mock_record = OpenStruct.new(
+              :name => 'f.phl.narf.io',
+              :value => ['8.8.4.4']
+            )
+            @dns.stubs(:get_ip_address).returns('8.8.4.4')
+            @dns.stubs(:find_record_for_zone_by_name).returns(@mock_record)
+          end
+
+          it 'should not call :create_record_for_zone' do
+            @dns.expects(:create_record_for_zone).never
+
+            @dns.update_record_for_zone(@mock_zone, 'f.phl.narf.io')
+          end
+
+          it 'should return record' do
+            result = @dns.update_record_for_zone(@mock_zone, 'f.phl.narf.io')
+
+            expect(result).to_equal @mock_record
+          end
+        end
+
+        describe 'and does not match current ip address' do
+          before do
+            @mock_zone = mock()
+            @mock_record = OpenStruct.new(
+              :name => 'f.phl.narf.io',
+              :value => ['192.168.1.12']
+            )
+            @dns.stubs(:get_ip_address).returns('10.30.1.2')
+            @dns.stubs(:find_record_for_zone_by_name).returns(@mock_record)
+          end
+
+          it 'should destroy the record and create a new record' do
+            @mock_record.expects(:destroy)
+
+            @dns.expects(:create_record_for_zone)
+            @dns.update_record_for_zone(@mock_zone, 'f.phl.narf.io')
+          end
+
+        end
+      end
+    end
+  end
+
+  describe '#update!' do
+    describe 'when domains to update are not set' do
+      before do
+        empty_config = config.clone
+        empty_config[:zones].first[:targets] = nil
+
+        @dns = CloudDyndns::Updater.new(empty_config, test_logger)
+      end
+
+      it 'should raise error' do
+        operation = lambda {
+          @dns.update!
+        }
+        expect(operation).to_raise CloudDyndns::Updater::NoTargetsSpecified
+      end
+    end
+
+    describe 'when domains are set' do
+      before do
+        @dns = CloudDyndns::Updater.new(config, test_logger)
+      end
+
+      it 'should update the domains for each zone' do
+        mock_zone1 = mock()
+        mock_zone2 = mock()
+
+        @dns.expects(:find_zone_by_name).
+          with('looting.biz').returns(mock_zone1)
+        @dns.expects(:find_zone_by_name).
+          with('narf.io').returns(mock_zone2)
+
+        @dns.expects(:update_record_for_zone).
+          with(mock_zone1, 'phl.looting.biz', config[:zones][0])
+        @dns.expects(:update_record_for_zone).
+          with(mock_zone1, '*.phl.looting.biz', config[:zones][0])
+
+        @dns.expects(:update_record_for_zone).
+          with(mock_zone2, 'phl.narf.io', config[:zones][1])
+        @dns.expects(:update_record_for_zone).
+          with(mock_zone2, '*.phl.narf.io', config[:zones][1])
+
+        @dns.update!
+      end
+
+    end
+  end
+
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: cloud-dyndns
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nat Lownes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &2164884840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.18.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164884840
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2164884340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: *2164884340
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2164883960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2164883960
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: &2164883480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2164883480
+- !ruby/object:Gem::Dependency
+  name: minitest-matchers
+  requirement: &2164880620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2164880620
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2164880200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2164880200
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &2164879700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2164879700
+- !ruby/object:Gem::Dependency
+  name: minitest-spec-expect
+  requirement: &2164879000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2164879000
+description: ! '
+
+  update DNS entries on cloud providers (Route 53 et al) based on your current external
+  IP address. think like a dyndns updater. no-ip, et al.
+
+'
+email:
+- nat.lownes@gmail.com
+executables:
+- cloud-dyndns
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/cloud-dyndns
+- cloud-dyndns.gemspec
+- cloud-dyndns.rb
+- doc/crontab_example
+- lib/config.rb
+- lib/updater.rb
+- lib/version.rb
+- spec/config_spec.rb
+- spec/fixtures/config.yml
+- spec/test_helper.rb
+- spec/updater_spec.rb
+homepage: https://github.com/natlownes/cloud-dyndns
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: update DNS entries on cloud providers (Route 53 et al) based on your current
+  external IP address. think like a dyndns updater. no-ip, et al.
+test_files:
+- spec/config_spec.rb
+- spec/fixtures/config.yml
+- spec/test_helper.rb
+- spec/updater_spec.rb