ip_tracker 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+
+platforms :mswin, :mingw do
+  gem 'win32console'
+  gem 'win32-changenotify'
+  gem 'win32-event'
+  gem 'rb-readline'
+  gem 'rb-notifu'
+end
+
+platform :ruby do
+  gem 'rb-inotify'
+end
+
+gem 'guard', :git => "git://github.com/guard/guard.git"    
+gem 'looper', :git => "git@github.com:diedthreetimes/looper.git"
+
+# Specify your gem's dependencies in ip_tracker.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :all_after_pass => false, :cli => '--color', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+end

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/ipme

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'ip_tracker'
+
+IpTracker::CLI.start

data/ip_tracker.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ip_tracker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ip_tracker"
+  s.version     = IpTracker::VERSION
+  s.authors     = ["Sky Faber"]
+  s.email       = ["skyfaber@gmail.com"]
+  s.homepage    = "https://github.com/diedthreetimes/IpTracker"
+  s.summary     = %q{A command line utility to interface with IpMe}
+  s.description = %q{Keep a dynamic IP up to date without the use of DNS. Either sync manually or automatically to a known location.}
+
+  s.rubyforge_project = "ip_tracker"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", '~> 2.6'
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "rb-readline"
+  s.add_development_dependency "webmock"
+
+  s.add_runtime_dependency "thor"
+  s.add_runtime_dependency "faraday_middleware"
+  s.add_runtime_dependency "yajl-ruby"
+  s.add_runtime_dependency "multi_json"
+  s.add_runtime_dependency "rash"
+  s.add_runtime_dependency "looper"
+end

data/lib/ip_tracker/cli/methods/register.rb

@@ -0,0 +1,24 @@
+module IpTracker
+  class CLI
+    desc "register", "register this computer with IpMe"
+    method_option :hostname, :type => :string, :desc => "What name to store this hoste under"
+    def register
+      unless config.host_token
+        hostname = options[:hostname] || get_option(:hostname)
+
+        say "Attempting to register this computer.", :yellow
+
+        token = client.register(hostname)
+        say "Registration completed.", :green
+        config.update(:host_token, token)
+      else
+        say "This computer has already been registered."
+      end
+    rescue IpTracker::Client::TargetError
+      say "Registration failed."
+    rescue IpTracker::Client::HostTakenError
+      say "You must enter a unique name."
+    end
+  end
+end
+

data/lib/ip_tracker/cli/methods/sync.rb

@@ -0,0 +1,44 @@
+module IpTracker
+  class CLI
+    desc "sync", "continuously sync the ip with IpMe"
+    method_option :start, :type => :boolean, :desc => "Command start", :default => true
+    method_option :stop, :type => :boolean, :desc => "Command stop", :default => false
+    method_option :daemon, :type => :boolean, :aliases => ["-d"], :default => false, :desc => "Run this as a daemon, only works with start"
+
+    def sync
+      command = options[:stop] ? :stop : :start
+      daemonize = options[:daemon] && Process.respond_to?(:fork)
+
+      case command
+      when :start
+        if config.pid
+          say "IpMe is already running."
+        else
+          if daemonize
+            pid = Process.fork do
+              SyncDaemon.new.run
+              Process.daemon
+            end
+
+            # TODO verify if detach and daemon work together
+            config.update(:pid, pid)
+            Process.detach(pid)
+          else
+            SyncDaemon.new.run
+          end
+        end
+      when :stop
+        if config.pid
+          say "Killing #{config.pid}"
+
+          Process.kill("TERM", config.pid)
+
+          say "Killed"
+        else
+          say "No PID saved"
+        end
+      end
+
+    end
+  end
+end

data/lib/ip_tracker/cli/methods/update.rb

@@ -0,0 +1,21 @@
+module IpTracker
+  class CLI
+    desc "update", "update IpMe with the specified IP"
+    method_option :ip, :type => :string, :desc => "Which IP to update use", :required => true
+    def update
+      ip = options[:ip]
+      host = config.host_token
+      if host.nil?
+        say "Please first register this computer."
+      else
+        say "Attempting to update ip.", :yellow
+
+        client.update(host, :ip, ip)
+
+        say "Update completed", :green
+      end
+    rescue IpTracker::Client::TargetError
+      say "Update failed."
+    end
+  end
+end

data/lib/ip_tracker/cli.rb

@@ -0,0 +1,25 @@
+require 'thor'
+
+module IpTracker
+  class CLI < Thor
+    protected
+
+    def get_option(option)
+      value = ask("Please enter your #{option}:")
+      raise Thor::Error, "You must enter a value for that field." if value.empty?
+      value
+    end
+
+    def client
+      @client ||= IpTracker::Client.new
+    end
+
+    def config
+      @config ||= IpTracker::Config.new
+    end
+  end
+end
+
+require 'ip_tracker/cli/methods/register'
+require 'ip_tracker/cli/methods/update'
+require 'ip_tracker/cli/methods/sync'

data/lib/ip_tracker/client/authentication.rb

@@ -0,0 +1,18 @@
+module IpTracker
+  class Client
+    module Authentication
+      attr_accessor :auth_token
+      attr_reader :user
+
+      def login(username, password)
+        response = post("#{IpTracker::USERS_PATH}/#{username}/tokens",
+                        :body => { :password => password })
+
+        raise TargetError if response.code == 200
+
+        @user = username
+        @auth_token = response.token
+      end
+    end
+  end
+end

data/lib/ip_tracker/client/connection.rb

@@ -0,0 +1,19 @@
+require'faraday_middleware'
+
+module IpTracker
+  class Client
+    module Connection
+      private
+
+      def connection
+        connection = Faraday.new(:url => target_url) do |builder|
+          builder.use Faraday::Request::JSON
+          builder.use Faraday::Response::Rashify
+          builder.use Faraday::Response::ParseJson
+
+          builder.adapter http_adapter
+        end
+      end
+    end
+  end
+end

data/lib/ip_tracker/client/errors.rb

@@ -0,0 +1,6 @@
+module IpTracker
+  class Client
+    class HostTakenError < RuntimeError; end
+    class TargetError < RuntimeError; end
+  end
+end

data/lib/ip_tracker/client/request.rb

@@ -0,0 +1,23 @@
+module IpTracker
+  class Client
+    module Request
+      def post(path, options={})
+        request(:post, path, options)
+      end
+
+      def put(path, options={})
+        request(:put, path, options)
+      end
+
+      private
+
+      def request(action, path, options)
+        response = connection.send(action, path) do |request|
+          request.body = options[:body] if options[:body]
+        end
+
+        response.body
+      end
+    end
+  end
+end

data/lib/ip_tracker/client.rb

@@ -0,0 +1,38 @@
+
+require 'ip_tracker/client/authentication'
+require 'ip_tracker/client/connection'
+require 'ip_tracker/client/errors'
+require 'ip_tracker/client/request'
+
+module IpTracker
+  class Client
+    attr_reader :http_adapter, :target_url
+
+    def initialize
+      @target_url = IpTracker::DEFAULT_LOCAL_TARGET
+      @http_adapter = :net_http
+    end
+
+    # include Authentication
+    include Connection
+    include Request
+
+    attr_accessor :host_token
+
+    def register hostname
+      response = post(IpTracker::HOSTS_PATH, :body => { name: hostname } )
+      raise HostTakenError if response.code == 201
+      raise TargetError if response.code == 200 || response.id == nil
+
+      @host_token = response.id
+    end
+
+    def update host_id, attr, value
+      response = put(IpTracker::HOSTS_PATH + "/#{host_id}", :body => {attr.to_sym => value})
+
+      raise TargetError if response.code == 200 || response.send(attr) != value
+
+      true
+    end
+  end
+end

data/lib/ip_tracker/config.rb

@@ -0,0 +1,32 @@
+module IpTracker
+  class Config
+    attr_accessor :config_hash, :settings_path
+
+    def initialize(options={})
+      @settings_path = File.expand_path(IpTracker::DEFAULT_CONFIG_PATH)
+      @config_hash = load_settings || {}
+    end
+
+    def host_token
+      config_hash["host_token"] || nil
+    end
+
+    def pid
+      config_hash["pid"] || nil
+    end
+
+    def update(attr, value)
+      config_hash[attr.to_s] = value
+
+      File.open(settings_path, 'w') do |out|
+        YAML.dump(config_hash, out)
+      end
+    end
+
+    private
+
+    def load_settings
+      File.exists?(settings_path) ? YAML.load_file(settings_path) : nil
+    end
+  end
+end

data/lib/ip_tracker/sync_daemon.rb

@@ -0,0 +1,64 @@
+require 'socket'
+require 'looper'
+
+module IpTracker
+  class SyncDaemon
+    include ::Looper
+
+    attr_accessor :last_ip
+
+    def initialize(config = {})
+      @run = true
+      @runs = config[:runs].nil? ? nil : config[:runs]
+      @sleep = config[:sleep].nil? ? 60 : config[:sleep]
+    end
+
+    def run
+      loopme(@sleep) do
+        if @runs == 0
+          @run = false
+        elsif !@runs.nil?
+          @runs -= 1
+        end
+
+        begin
+          new_ip = local_ip
+
+          if @last_ip != new_ip
+            puts "#{Time.now}: Updating to #{new_ip}"
+            update_ip new_ip
+
+            @last_ip = new_ip
+          end
+        rescue Client::TargetError
+          puts "An error occured trying to communicate with the server, sleeping"
+          sleep(6000) unless !@runs.nil?
+        end
+      end
+    end
+
+    def local_ip
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true # turn off reverse DNS resolution temporarily
+
+      UDPSocket.open do |s|
+        s.connect '64.233.187.99', 1
+        s.addr.last
+      end
+    ensure
+      Socket.do_not_reverse_lookup = orig
+    end
+
+    def update_ip ip
+      client.update(config.host_token, :ip, ip)
+      #  CLI.start( ['update', '--ip', ip] )
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def client
+      @client ||= Client.new
+    end
+  end
+end

data/lib/ip_tracker/version.rb

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

data/lib/ip_tracker.rb

@@ -0,0 +1,13 @@
+require "ip_tracker/version"
+
+module IpTracker
+  DEFAULT_CONFIG_PATH  = '~/.ip_tracker'
+  DEFAULT_LOCAL_TARGET = 'http://ipme.herokuapp.com'
+  # DEFAULT_LOCAL_TARGET = 'http://localhost:4567'
+  HOSTS_PATH           = '/hosts'
+end
+
+require 'ip_tracker/config'
+require 'ip_tracker/cli'
+require 'ip_tracker/client'
+require 'ip_tracker/sync_daemon'

data/spec/fixtures/register_failure.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 403 Forbidden
+Server: nginx/0.7.65
+Date: Thu, 03 Mar 2011 18:29:40 GMT
+Content-Type: application/json
+Connection: keep-alive
+Keep-Alive: timeout=20
+Content-Length: 52
+
+{"code":200,"description":"Operation not permitted"}

data/spec/fixtures/register_invalid.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 200 OK
+Server: nginx/0.7.65
+Date: Thu, 03 Mar 2011 18:26:45 GMT
+Content-Type: application/json
+Connection: keep-alive
+Keep-Alive: timeout=20
+Content-Length: 28
+
+{"id":null}

data/spec/fixtures/register_success.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 200 OK
+Server: nginx/0.7.65
+Date: Thu, 03 Mar 2011 18:26:45 GMT
+Content-Type: application/json
+Connection: keep-alive
+Keep-Alive: timeout=20
+Content-Length: 28
+
+{"id":6}

data/spec/fixtures/register_taken.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 400 Bad Request
+Server: nginx/0.7.65
+Date: Thu, 03 Mar 2011 18:29:40 GMT
+Content-Type: application/json
+Connection: keep-alive
+Keep-Alive: timeout=20
+Content-Length: 52
+
+{"code":201,"description":"Name already taken."}

data/spec/fixtures/update_failed.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 403 Forbidden
+Server: nginx/0.7.65
+Date: Thu, 03 Mar 2011 18:29:40 GMT
+Content-Type: application/json
+Connection: keep-alive
+Keep-Alive: timeout=20
+Content-Length: 52
+
+{"code":200,"description":"Operation not permitted"}

data/spec/fixtures/update_invalid.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 200 OK
+Server: nginx/0.7.65
+Date: Thu, 03 Mar 2011 18:26:45 GMT
+Content-Type: application/json
+Connection: keep-alive
+Keep-Alive: timeout=20
+Content-Length: 30
+
+{"id":7, "ip":"127.0.1.10034"}

data/spec/fixtures/update_success.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 200 OK
+Server: nginx/0.7.65
+Date: Thu, 03 Mar 2011 18:26:45 GMT
+Content-Type: application/json
+Connection: keep-alive
+Keep-Alive: timeout=20
+Content-Length: 28
+
+{"id":7, "ip":"127.0.0.1"}

data/spec/ip_tracker/cli/methods/register_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'ip_tracker'
+
+describe IpTracker::CLI do
+
+  describe 'executable' do
+    it 'should print usage' do
+      `ipme`.should match /Tasks:/
+    end
+  end
+
+  describe '#register' do
+    context "when there is no hostid token" do
+      def stub_client_and_config
+        mock_client.should_receive(:register).with('foo') { 'token' }
+
+        config = mock_config
+        config.should_receive(:update).with(:host_token, 'token')
+        config.should_receive(:host_token).and_return(nil)
+      end
+
+      context 'and no arguments are provided' do
+        let(:register) { IpTracker::CLI.start(['register']) }
+
+        it "asks for a new hostname" do
+          stub_client_and_config
+          $stdin.should_receive(:gets).and_return('foo')
+
+          results = capture(:stdout) { register }
+          results.should match /Please enter your hostname:/
+        end
+
+        context "displays an error if" do
+          it "hostname is blank" do
+            mock_config.should_receive(:host_token).and_return(nil)
+
+            $stdin.should_receive(:gets).and_return('')
+            results = capture(:stderr, :stdout) { register }
+            results.should match /must enter a value/
+            results.should_not match /success/
+          end
+
+          it "hostname is taken" do
+            mock_config.should_receive(:host_token).and_return(nil)
+
+            $stdin.should_receive(:gets).and_return('')
+            results = capture(:stderr, :stdout) { register }
+            results.should match /must enter a/
+            results.should_not match /success/
+          end
+        end
+
+      end
+
+      context "and a hostname is provided" do
+        let(:register) do
+          IpTracker::CLI.start(["register", "--hostname", "foo"])
+        end
+
+        it "does not ask for hostnme" do
+          stub_client_and_config
+          $stdin.should_not_receive(:gets)
+          results = capture(:stdout) { register }
+          results.should match /Attempting to register/
+        end
+
+        context "and hostname will fail" do
+          it "displays a failed message if host taken" do
+            mock_client.should_receive(:register).
+              with('foo') { raise IpTracker::Client::HostTakenError }
+            mock_config.should_receive(:host_token).and_return(nil)
+
+            results = capture(:stdout) { register }
+            results.should match /You must enter a unique name./
+          end
+
+          it "displays a failed message if client errors" do
+            mock_client.should_receive(:register).
+              with('foo') { raise IpTracker::Client::TargetError }
+            mock_config.should_receive(:host_token).and_return(nil)
+
+            results = capture(:stdout) { register }
+            results.should match /Registration failed./
+
+          end
+        end
+
+        context "and hostname will succeed" do
+          it "saves a hostid token and displays success" do
+            stub_client_and_config
+
+            results = capture(:stdout) { register }
+            results.should match /completed/
+          end
+        end
+      end
+    end
+
+    context "when there is a hostid token" do
+      let(:register) { IpTracker::CLI.start(['register']) }
+      it "should not ask for hostname and print a message" do
+        mock_config.should_receive(:host_token).and_return('token')
+        $stdin.should_not_receive(:gets)
+        results = capture(:stdout) { register }
+        results.should match /This computer has already been registered./
+      end
+    end
+  end # register
+end # CLI

data/spec/ip_tracker/cli/methods/sync_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'ip_tracker'
+
+describe IpTracker::CLI do
+  describe '#sync' do
+
+    def stub_config(pid=nil)
+      config = mock_config
+      config.should_receive(:update).with(:pid, pid) if !pid.nil?
+      config.should_receive(:pid).and_return(nil)
+    end
+
+    def stub_daemon
+      daemon = double(IpTracker::SyncDaemon, {})
+      IpTracker::SyncDaemon.stub(:new) { daemon }
+      daemon.should_receive(:run)
+    end
+    describe "start" do
+      context "when there are no options" do
+        let(:sync) { IpTracker::CLI.start(['sync']) }
+
+        it "should call sync_daemon" do
+          stub_config
+          stub_daemon
+
+          sync
+        end
+
+        it "prints an error when a pid is saved" do
+          mock_config.should_receive(:pid).and_return(343)
+          IpTracker::SyncDaemon.should_not_receive(:new)
+
+          results = capture(:stdout) { sync }
+          results.should match /IpMe is already running./
+        end
+      end
+
+      context "when daemonize is provided" do
+        let(:sync) { IpTracker::CLI.start(['sync', '--start', '-d']) }
+
+        it "should detach and store a pid" do
+          stub_config(36)
+
+          Process.should_receive(:fork).and_return(36)
+          Process.should_receive(:respond_to?).with(:fork).and_return(true)
+          Process.should_receive(:detach)
+
+          results = capture(:stdout) { sync }
+          results.should == ""
+
+          #TODO: assert output is redirected to a file
+        end
+      end
+    end
+
+    describe "#stop" do
+      let(:sync) { IpTracker::CLI.start(['sync', '--stop']) }
+      context "when a pid is saved" do
+        it "should send sigterm to the daemon and delete the pid" do
+          mock_config.should_receive(:pid).at_least(1).times.and_return(36)
+          Process.should_receive(:kill).with("TERM", 36)
+
+          results = capture(:stdout) { sync }
+          results.should match /killed/i
+        end
+      end
+
+      it "should print a warning when a pid doesn't exist" do
+        stub_config
+
+        results = capture(:stdout) { sync }
+        results.should match /no pid/i
+      end
+    end
+  end
+end

data/spec/ip_tracker/cli/methods/update_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'ip_tracker'
+
+describe IpTracker::CLI do
+  describe '#update' do
+    let(:update) { IpTracker::CLI.start(['update','--ip','127.0.0.1']) }
+    context "should display an error if" do
+      it "no arguments are provided" do
+        mock_config
+        mock_client
+
+        results = capture(:stderr) { IpTracker::CLI.start(['update']) }
+        results.should match /No value provided/
+      end
+
+      # TODO: Automatically call register
+      it "no hostid token present" do
+        mock_config.should_receive(:host_token).and_return nil
+        mock_client
+
+        results = capture(:stdout) { update }
+        results.should match /Please first register this computer./
+      end
+    end
+
+    context "when a hostid token is present" do
+      it "displays a failed message if client errors" do
+        mock_client.should_receive(:update).
+          with('token', :ip, '127.0.0.1') { raise IpTracker::Client::TargetError }
+        mock_config.should_receive(:host_token).and_return('token')
+
+        results = capture(:stdout) { update }
+        results.should match /Update failed./
+      end
+
+      context "and client will succeed" do
+        it "displays success" do
+          mock_client.should_receive(:update).
+            with('token', :ip, '127.0.0.1')
+          mock_config.should_receive(:host_token).and_return('token')
+
+          results = capture(:stdout) { update }
+          results.should match /completed/
+        end
+      end
+    end
+  end
+end

data/spec/ip_tracker/client_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'ip_tracker'
+
+describe IpTracker::Client do
+  def stub_register(status)
+    fixture_file =
+      case status
+      when :success
+        "register_success.txt"
+      when :no_name
+        "register_taken.txt"
+      when :invalid
+        "register_invalid.txt"
+      else
+        "register_failure.txt"
+      end
+    stub_request(:post, IpTracker::DEFAULT_LOCAL_TARGET + IpTracker::HOSTS_PATH).
+      with(:body => {:name => "foo"}).
+          to_return(fixture(fixture_file))
+  end
+
+  def stub_update(status)
+    fixture_file =
+      case status
+      when :success
+        "update_success.txt"
+      when :invalid
+        "update_invalid.txt"
+      else
+        "update_failed.txt"
+      end
+
+    stub_request(:put, IpTracker::DEFAULT_LOCAL_TARGET + IpTracker::HOSTS_PATH+ '/9').
+      with(:body => {:ip => "127.0.0.1"}).
+          to_return(fixture(fixture_file))
+  end
+
+  #TODO: Refactor target+hosts to be configurable
+  describe "#register" do
+
+    context "when successful" do
+
+      it "sets and returns the token" do
+        stub_register(:success)
+
+        host_token = subject.register 'foo'
+        subject.host_token.should == host_token
+        host_token.should == 6
+      end
+    end
+
+    context "raises an exception when" do
+
+      it "failed" do
+        stub_register(:failed)
+        expect { subject.register('foo') }.to raise_error IpTracker::Client::TargetError
+      end
+
+
+      it "name taken" do
+        stub_register(:no_name)
+        expect { subject.register('foo') }.to raise_error IpTracker::Client::HostTakenError
+      end
+
+      it "response invalid" do
+        stub_register(:invalid)
+        expect { subject.register('foo') }.to raise_error IpTracker::Client::TargetError
+      end
+    end
+  end
+
+  describe "#update" do
+    context "when successful" do
+      it "returns true" do
+        stub_update(:success)
+        subject.update(9, :ip, '127.0.0.1').should == true
+      end
+    end
+
+    context "raises an exception when" do
+      it "response failed " do
+        stub_update(:failed)
+        expect { subject.update(9, :ip, '127.0.0.1') }.to raise_error IpTracker::Client::TargetError
+      end
+
+      it "response invalid" do
+        stub_update(:invalid)
+        expect { subject.update(9, :ip, '127.0.0.1') }.to raise_error IpTracker::Client::TargetError
+      end
+    end
+  end
+end

data/spec/ip_tracker/config_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'ip_tracker'
+
+describe IpTracker::Config do
+  let(:path) { File.expand_path(IpTracker::DEFAULT_CONFIG_PATH) }
+  let(:io) { StringIO.new }
+
+  #  TODO refactor tests to use settings once configurable
+
+  def stub_config_file(contents=nil)
+    File.stub(:exists?).with(path) { contents ? true : false }
+    YAML.stub(:load_file).with(path) { contents } if contents
+    File.stub(:open).with(path, 'w').and_yield(io)
+  end
+
+  describe "#update" do
+    context "when a .ip_tracker file doesn't exist" do
+      it "creates the file and can add a new token" do
+        expected_token = 'new_token'
+
+        stub_config_file(nil)
+        YAML.should_receive(:dump).with({"host_token" => expected_token}, io)
+
+        config = IpTracker::Config.new
+        config.update(:host_token, 'new_token')
+        config.host_token.should == expected_token
+      end
+    end
+
+    context "when a .ip_tracker file exists" do
+      it "can update tokens in the .ip_tracker file" do
+        expected_token = 'new_token'
+        old_token = 'old_token'
+
+        stub_config_file("host_token" => old_token)
+        YAML.should_receive(:dump).with({"host_token" => expected_token}, io)
+
+        config = IpTracker::Config.new
+        config.host_token.should == old_token
+        config.update(:host_token, 'new_token')
+        config.host_token.should == expected_token
+      end
+    end
+  end
+end

data/spec/ip_tracker/sync_daemon_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'ip_tracker'
+
+describe IpTracker::SyncDaemon do
+  describe "#run" do
+    let(:run) { IpTracker::SyncDaemon.new( runs: 5, sleep: 1 ).run }
+    let(:mock_ip) { "127.0.0.1" }
+
+    it "should update the ip exactly once" do
+      UDPSocket.should_receive(:open).exactly(6).times.and_return(mock_ip)
+
+      mock_config.should_receive(:host_token).and_return(6)
+      mock_client.should_receive(:update).with(6, :ip,  mock_ip)
+
+      results = capture(:stdout) { run }
+      results.should match /process started/
+      results.should_not match /error/
+    end
+
+    it "should degrade gracefully upon error" do
+      UDPSocket.should_receive(:open).exactly(6).times.and_return(mock_ip)
+
+      mock_config.should_receive(:host_token).at_least(1).times.and_return(6)
+      mock_client.should_receive(:update).at_least(1).times.with(6, :ip, mock_ip) { raise IpTracker::Client::TargetError }
+
+      results = capture(:stdout){ run }
+      results.should match /error/
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'ip_tracker'
+
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+
+end
+
+def fixture_path
+  File.expand_path("../fixtures", __FILE__)
+end
+
+def fixture(file)
+  File.new(fixture_path + '/' + file)
+end
+
+def capture(*streams)
+  streams = [*streams]
+  begin
+    streams.each { |stream|
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+    }
+
+    yield
+
+    result = streams.map { |stream|
+      eval("$#{stream}").string
+    }.inject(:+)
+  ensure
+    streams.each { |stream|
+      eval("$#{stream} = #{stream.upcase}")
+    }
+  end
+
+  result
+end
+
+
+def mock_client(stubs={})
+  client = double(IpTracker::Client, stubs)
+  IpTracker::Client.stub(:new) { client }
+  client
+end
+
+def mock_config(stubs={})
+  config = double(IpTracker::Config, stubs)
+  IpTracker::Config.stub(:new) { config }
+  config
+end
+

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: ip_tracker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sky Faber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-04 00:00:00.000000000 -07:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &16815264 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *16815264
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &16815012 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16815012
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &16814736 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16814736
+- !ruby/object:Gem::Dependency
+  name: rb-readline
+  requirement: &16814484 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16814484
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &16814232 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16814232
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &16813980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16813980
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: &16813728 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16813728
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &22777668 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *22777668
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &22777416 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *22777416
+- !ruby/object:Gem::Dependency
+  name: rash
+  requirement: &22777164 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *22777164
+- !ruby/object:Gem::Dependency
+  name: looper
+  requirement: &22776912 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *22776912
+description: Keep a dynamic IP up to date without the use of DNS. Either sync manually
+  or automatically to a known location.
+email:
+- skyfaber@gmail.com
+executables:
+- ipme
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- Rakefile
+- bin/ipme
+- ip_tracker.gemspec
+- lib/ip_tracker.rb
+- lib/ip_tracker/cli.rb
+- lib/ip_tracker/cli/methods/register.rb
+- lib/ip_tracker/cli/methods/sync.rb
+- lib/ip_tracker/cli/methods/update.rb
+- lib/ip_tracker/client.rb
+- lib/ip_tracker/client/authentication.rb
+- lib/ip_tracker/client/connection.rb
+- lib/ip_tracker/client/errors.rb
+- lib/ip_tracker/client/request.rb
+- lib/ip_tracker/config.rb
+- lib/ip_tracker/sync_daemon.rb
+- lib/ip_tracker/version.rb
+- spec/fixtures/register_failure.txt
+- spec/fixtures/register_invalid.txt
+- spec/fixtures/register_success.txt
+- spec/fixtures/register_taken.txt
+- spec/fixtures/update_failed.txt
+- spec/fixtures/update_invalid.txt
+- spec/fixtures/update_success.txt
+- spec/ip_tracker/cli/methods/register_spec.rb
+- spec/ip_tracker/cli/methods/sync_spec.rb
+- spec/ip_tracker/cli/methods/update_spec.rb
+- spec/ip_tracker/client_spec.rb
+- spec/ip_tracker/config_spec.rb
+- spec/ip_tracker/sync_daemon_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/diedthreetimes/IpTracker
+licenses: []
+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: ip_tracker
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A command line utility to interface with IpMe
+test_files: []