devdnsd 1.0.0

data/lib/devdnsd/configuration.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+#
+# This file is part of the devdns gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module DevDNSd
+  # This class holds the configuration of the applicaton.
+  class Configuration
+    # If to run the server in foreground. Default: `false`.
+    attr_accessor :foreground
+
+    # The address to listen to. Default: `0.0.0.0`.
+    attr_accessor :address
+
+    # The port to listen to. Default: `7771`.
+    attr_accessor :port
+
+    # The TLD to manage. Default: `dev`.
+    attr_accessor :tld
+
+    # The file to log to. Default: `/var/log/devdnsd.log`.
+    attr_accessor :log_file
+
+    # The minimum severity to log. Default: `Logger::INFO`.
+    attr_accessor :log_level
+
+    # The rules of the server. By default, every hostname is resolved with `127.0.0.1`.
+    attr_accessor :rules
+
+    # Creates a new configuration.
+    # A configuration file is a plain Ruby file with a top-level {Configuration config} object.
+    #
+    # Example:
+    #
+    # ```ruby
+    # config.add_rule("match.dev", "10.0.0.1")
+    # ```
+    #
+    # @param file [String] The file to read.
+    # @param application [Application] The application which this configuration is attached to.
+    # @param overrides [Hash] A set of values which override those set in the configuration file.
+    def initialize(file = nil, application = nil, overrides = {})
+      @address = "0.0.0.0"
+      @port = 7771
+      @tld = "dev"
+      @log_file = "/var/log/devdnsd.log"
+      @log_level = Logger::INFO
+      @rules = []
+      @foreground = false
+
+      if file.present?
+        begin
+          # Open the file
+          path = Pathname.new(file).realpath
+          application.logger.info("Using configuration file #{path}.") if application
+          self.tap do |config|
+            eval(File.read(path))
+          end
+
+          @log_file = $stdout if @log_file == "STDOUT"
+          @log_file = $stderr if @log_file == "STDERR"
+        rescue Errno::ENOENT, LoadError
+        rescue Exception => e
+          raise DevDNSd::Errors::InvalidConfiguration.new("Config file #{file} is not valid.")
+        end
+      end
+
+      # Apply overrides
+      if overrides.is_a?(Hash) then
+        overrides.each_pair do |k, v|
+          self.send("#{k}=", v) if self.respond_to?("#{k}=") && !v.nil?
+        end
+      end
+
+      # Make sure some arguments are of correct type
+      @port = @port.to_integer
+      @log_level = @log_level.to_integer
+
+      # Add a default rule
+      self.add_rule(/.+/, "127.0.0.1") if @rules.length == 0
+    end
+
+    # Adds a rule to the configuration.
+    #
+    # @param args [Array] The rule's arguments.
+    # @param block [Proc] An optional block for the rule.
+    # @return [Array] The current set of rule.
+    # @see Rule.create
+    def add_rule(*args, &block)
+      @rules << DevDNSd::Rule.create(*args, &block)
+    end
+  end
+end

data/lib/devdnsd/errors.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+#
+# This file is part of the devdns gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module DevDNSd
+  # Exceptions for {DevDNSd DevDNSd}.
+  module Errors
+    # This exception is raised if a {Rule Rule} is invalid.
+    class InvalidRule < ArgumentError
+    end
+
+    # This exception is raised if a {Configuration Configuration} is invalid.
+    class InvalidConfiguration < ArgumentError
+    end
+  end
+end

data/lib/devdnsd/logger.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+#
+# This file is part of the devdnsd gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module DevDNSd
+  # A custom logger for DevDNSd.
+  class Logger < ::Logger
+    # The start time of first line. This allows to show a `T+0.1234` information into the log.
+    mattr_accessor :start_time
+
+    # The file or device to log messages to.
+    attr_reader :device
+
+    # Creates a new logger
+    # @see http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html
+    #
+    # @param logdev [String|IO] The log device. This is a filename (String) or IO object (typically STDOUT, STDERR, or an open file).
+    # @param shift_age [Fixnum]  Number of old log files to keep, or frequency of rotation (daily, weekly or monthly).
+    # @param shift_size [Fixnum] Maximum logfile size (only applies when shift_age is a number).
+    def initialize(logdev, shift_age = 0, shift_size = 1048576)
+      @device = logdev
+      super(logdev, shift_age, shift_size)
+    end
+
+    # Creates a new logger
+    #
+    # @param file [String|IO] The log device. This is a filename (String) or IO object (typically STDOUT, STDERR, or an open file).
+    # @param level [Fixnum] The minimum severity to log. See http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html for valid levels.
+    # @param formatter [Proc] The formatter to use for logging.
+    # @return [Logger] The new logger.
+    def self.create(file = nil, level = Logger::INFO, formatter = nil)
+      file ||= self.default_file
+      rv = self.new(self.get_real_file(file))
+      rv.level = level.to_i
+      rv.formatter = formatter || self.default_formatter
+      rv
+    end
+
+    # Translates a file to standard input or standard ouput in some special cases.
+    #
+    # @param file [String] The string to translate.
+    # @return [String|IO] The translated file name.
+    def self.get_real_file(file)
+      case file
+        when "STDOUT" then $stdout
+        when "STDERR" then $stderr
+        else file
+      end
+    end
+
+    # The default file for logging.
+    # @return [String|IO] The default file for logging.
+    def self.default_file
+      @default_file ||= $stdout
+    end
+
+    # The default formatter for logging.
+    # @return [Proc] The default formatter for logging.
+    def self.default_formatter
+      @default_formatter ||= Proc.new {|severity, datetime, progname, msg|
+        color = case severity
+          when "DEBUG" then :cyan
+          when "INFO" then :green
+          when "WARN" then :yellow
+          when "ERROR" then :red
+          when "FATAL" then :magenta
+          else :white
+        end
+
+        header = ("[%s T+%0.5f] %s:" %[datetime.strftime("%Y/%b/%d %H:%M:%S"), [datetime.to_f - self.start_time.to_f, 0].max, severity.rjust(5)]).bright
+        header = header.color(color) if color.present?
+        "%s %s\n" % [header, msg]
+      }
+    end
+
+    # The log time of the first logger. This allows to show a `T+0.1234` information into the log.
+    # @return [Time] The log time of the first logger.
+    def self.start_time
+      @start_time ||= Time.now
+    end
+  end
+end

data/lib/devdnsd/rule.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+#
+# This file is part of the devdns gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module DevDNSd
+  # This class encapsulate a rule for matching an hostname.
+  class Rule
+    # The pattern to match. Default: `/.+/`.
+    attr_accessor :match
+
+    # The type of request to match. Default: `:A`.
+    #
+    # @see .create
+    attr_accessor :type
+
+    # The IP or hostname to reply back to the client. Default: `127.0.0.1`.
+    #
+    # @see .create
+    attr_accessor :reply
+
+    # A list of options for the request. Default is an empty hash.
+    attr_accessor :options
+
+    # An optional block to compute the reply instead of using the `reply` parameter.
+    #
+    # @see .create
+    attr_accessor :block
+
+    # Creates a new rule.
+    #
+    # @param match [String|Regexp] The pattern to match.
+    # @param reply [String] The IP or hostname to reply back to the client.
+    # @param type [Symbol] The type of request to match.
+    # @param options [Hash] A list of options for the request.
+    # @param block [Proc] An optional block to compute the reply instead of using the `reply` parameter.
+    # @see .create
+    def initialize(match = /.+/, reply = "127.0.0.1", type = :A, options = {}, &block)
+      reply ||= "127.0.0.1"
+      type ||= :A
+      @match = match
+      @type = type
+      @reply = block.blank? ? reply : nil
+      @options = options
+      @block = block
+
+      raise(DevDNSd::Errors::InvalidRule.new("You must specify at least a rule and a host (also via a block). Optionally you can add a record type (default: A) and the options.")) if @reply.blank? && @block.nil?
+      raise(DevDNSd::Errors::InvalidRule.new("You can only use hashs for options.")) if !@options.is_a?(Hash)
+    end
+
+    # Returns the resource class(es) for the current rule.
+    #
+    # @return [Array|Class] The class(es) for the current rule.
+    def resource_class
+      classes = self.type.ensure_array.collect {|cls| self.class.symbol_to_resource_class(cls) }.compact.uniq
+      classes.length == 1 ? classes.first : classes
+    end
+
+    # Checks if the rule is a regexp.
+    #
+    # @return [Boolean] `true` if the rule is a Regexp, `false` otherwise.
+    def is_regexp?
+      self.match.is_a?(Regexp)
+    end
+
+    # Checks if the rule is a regexp.
+    #
+    # @return [Boolean] `true` if the rule has a block, `false` otherwise.
+    def has_block?
+      self.block.present?
+    end
+
+    # Matches a hostname to the rule.
+    #
+    # @param [String] The hostname to match.
+    # @return [MatchData|Boolean|Nil] Return `true` or MatchData (if the pattern is a regexp) if the rule matches, `false` or `nil` otherwise.
+    def match_host(hostname)
+      self.is_regexp? ? self.match.match(hostname) : (self.match == hostname)
+    end
+
+    # Creates a new rule.
+    #
+    # @param match [String|Regexp] The pattern to match.
+    # @param reply_or_type [String|Symbol] The IP or hostname to reply back to the client (or the type of request to match, if a block is provided).
+    # @param type [Symbol] The type of request to match. This is ignored if a block is provided.
+    # @param options [Hash] A list of options for the request.
+    # @param block [Proc] An optional block to compute the reply instead of using the `reply_or_type` parameter. In this case `reply_or_type` is used for the type of the request and `type` is ignored.
+    def self.create(match, reply_or_type = nil, type = nil, options = {}, &block)
+      raise(DevDNSd::Errors::InvalidRule.new("You must specify at least a rule and a host (also via a block). Optionally you can add a record type (default: A) and the options.")) if reply_or_type.blank? && block.nil?
+      raise(DevDNSd::Errors::InvalidRule.new("You can only use hashs for options.")) if !options.is_a?(Hash)
+
+      rv = self.new(match)
+      rv.options = options
+
+      if block.present? then # reply_or_type acts like a type, type is ignored
+        rv.type = reply_or_type || :A
+        rv.reply = nil
+        rv.block = block
+      else # reply_or_type acts like a reply
+        rv.reply = reply_or_type || "127.0.0.1"
+        rv.type = type || :A
+      end
+
+      rv
+    end
+
+    # Converts a class to the correspondent symbol.
+    #
+    # @param klass [Class] The class to convert.
+    # @return [Symbol] The symbol representation of the class.
+    def self.resource_class_to_symbol(klass)
+      klass.to_s.gsub(/(.+::)?(.+)/, "\\2").to_sym
+    end
+
+    # Converts a symbol to the correspondent DNS resource class.
+    #
+    # @param symbol [Symbol] The symbol to convert.
+    # @return [Symbol] The class associated to the symbol.
+    def self.symbol_to_resource_class(symbol)
+      symbol = symbol.to_s.upcase
+
+      begin
+        "Resolv::DNS::Resource::IN::#{symbol}".constantize
+      rescue NameError
+        raise(DevDNSd::Errors::InvalidRule.new("Invalid resource class #{symbol}."))
+      end
+    end
+  end
+end

data/lib/devdnsd/version.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+#
+# This file is part of the devdns gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module DevDNSd
+  # The current version of DevDNSd.
+  # For version, semantic version is used. See: http://semver.org/
+  module Version
+    # The major version.
+    MAJOR = 1
+
+    # The minor version.
+    MINOR = 0
+
+    # The patch version.
+    PATCH = 0
+
+    # The current version number of DevDNSd.
+    STRING = [MAJOR, MINOR, PATCH].compact.join(".")
+  end
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+#
+# This file is part of the devdns gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "simplecov"
+require "pathname"
+
+if ENV["DEVDNSD_COVERAGE"] == "TRUE" then
+  root = Pathname.new(File.dirname(__FILE__)) + ".."
+
+  SimpleCov.start do
+    add_filter do |src_file|
+      path = Pathname.new(src_file.filename).relative_path_from(root).to_s
+      path =~ /^lib\/devdnsd\/patches/ || path !~ /^(bin|lib)/
+    end
+  end
+end

data/spec/devdnsd/application_spec.rb

@@ -0,0 +1,436 @@
+# encoding: utf-8
+#
+# This file is part of the devdns gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe DevDNSd::Application do
+  before(:each) do
+    DevDNSd::Logger.stub(:default_file).and_return("/dev/null")
+  end
+
+  let(:application){ app = DevDNSd::Application.instance }
+  let(:executable) { Pathname.new(File.dirname((__FILE__))) + "../../bin/devdnsd" }
+  let(:sample_config) { Pathname.new(File.dirname((__FILE__))) + "../../config/devdnsd_config.sample" }
+  let(:resolver_path) { "/tmp/devdnsd-test-resolver-#{Time.now.strftime("%Y%m%d-%H:%M:%S")}" }
+  let(:launch_agent_path) { "/tmp/devdnsd-test-agent-#{Time.now.strftime("%Y%m%d-%H:%M:%S")}" }
+
+  describe "#initialize" do
+    it("should setup the logger") do application.logger.should_not be_nil end
+    it("should setup the configuration") do application.config.should_not be_nil end
+
+    it("should abort with an invalid configuration") do
+      path = "/tmp/devdnsd-test-#{Time.now.strftime("%Y%m%d-%H:%M:%S")}"
+      file = File.new(path, "w")
+      file.write("config.port = ")
+      file.close
+
+      expect { DevDNSd::Application.new({:config => file.path}) }.to raise_error(SystemExit)
+      File.unlink(path)
+    end
+  end
+
+  describe "#run" do
+    it "should run the server" do
+      application.should_receive(:perform_server)
+
+      Thread.start {
+        devdnsd_resolv("match.dev")
+        DevDNSd::Application.quit
+      }
+
+      DevDNSd::Application.run
+    end
+  end
+
+  describe "#perform_server" do
+    before(:each) do
+      DevDNSd::Logger.stub(:default_file).and_return($stdout)
+    end
+
+    it "should run the server" do
+      class DevDNSd::Application
+        def on_start
+          EventMachine.add_periodic_timer(1) do
+            devdnsd_resolv("match.dev")
+            DevDNSd::Application.quit
+          end
+        end
+      end
+
+      RubyDNS.should_receive(:run_server)
+      DevDNSd::Application.instance.perform_server
+    end
+
+    it "should iterate the rules" do
+      class DevDNSd::Application
+        def on_start
+          EventMachine.add_periodic_timer(1) do
+            devdnsd_resolv("match.dev")
+            DevDNSd::Application.quit
+          end
+        end
+      end
+
+      DevDNSd::Application.instance.config.rules.should_receive(:each).at_least(1)
+      DevDNSd::Application.instance.perform_server
+    end
+
+    it "should call process_rule" do
+      class DevDNSd::Application
+        def on_start
+          EventMachine.add_periodic_timer(1) do
+            devdnsd_resolv("match.dev")
+            DevDNSd::Application.quit
+          end
+        end
+      end
+
+      DevDNSd::Application.instance.should_receive(:process_rule).at_least(1)
+      DevDNSd::Application.instance.perform_server
+    end
+
+    it "should complain about wrong rules" do
+      class DevDNSd::Application
+        def on_start
+          EventMachine.add_periodic_timer(1) do
+            devdnsd_resolv("invalid.dev")
+            DevDNSd::Application.quit
+          end
+        end
+      end
+
+      DevDNSd::Application.instance.stub(:process_rule).and_raise(Exception)
+      expect { DevDNSd::Application.instance.perform_server }.to raise_exception
+    end
+
+    describe "should correctly resolve hostnames" do
+      before(:all) do
+        system("ruby \"#{executable}\" -L 0 -l /dev/null -c \"#{sample_config}\" start > /dev/null 2>&1")
+      end
+
+      after(:all) do
+        system("ruby \"#{executable}\" -L 0 -l /dev/null stop > /dev/null 2>&1")
+      end
+
+      it "basing on a exact pattern" do
+        devdnsd_resolv("match_1.dev").should == ["10.0.1.1", :A]
+        devdnsd_resolv("match_2.dev").should == ["10.0.2.1", :MX]
+        devdnsd_resolv("match_3.dev").should == ["10.0.3.1", :A]
+        devdnsd_resolv("match_4.dev").should == ["10.0.4.1", :CNAME]
+      end
+
+      it "basing on a regexp pattern" do
+        devdnsd_resolv("match_5_11.dev").should == ["10.0.5.11", :A]
+        devdnsd_resolv("match_5_22.dev").should == ["10.0.5.22", :A]
+        devdnsd_resolv("match_6_33.dev").should == ["10.0.6.33", :PTR]
+        devdnsd_resolv("match_6_44.dev").should == ["10.0.6.44", :PTR]
+        devdnsd_resolv("match_7_55.dev").should == ["10.0.7.55", :A]
+        devdnsd_resolv("match_7_66.dev").should == ["10.0.7.66", :A]
+        devdnsd_resolv("match_8_77.dev").should == ["10.0.8.77", :PTR]
+        devdnsd_resolv("match_8_88.dev").should == ["10.0.8.88", :PTR]
+
+      end
+
+      it "and return multiple answsers" do devdnsd_resolv("match_10.dev").should == [["10.0.10.1", :A], ["10.0.10.2", :MX]] end
+
+      it "and reject invalid matches (with or without rules)" do
+        devdnsd_resolv("match_9.dev").should be_nil
+        devdnsd_resolv("invalid.dev").should be_nil
+      end
+    end
+  end
+
+  describe "#process_rule" do
+    class FakeTransaction
+      attr_reader :resource_class
+
+      def initialize(cls = Resolv::DNS::Resource::IN::ANY)
+        @resource_class = cls
+      end
+
+      def respond!(*args)
+        true
+      end
+    end
+
+    let(:application){ DevDNSd::Application.new({:config => Pathname.new(File.dirname((__FILE__))) + "../../config/devdnsd_config.sample" }) }
+    let(:transaction){ FakeTransaction.new }
+
+    it "should match a valid string request" do
+      rule = application.config.rules[0]
+      application.process_rule(rule, rule.resource_class, nil, transaction).should be_true
+    end
+
+    it "should match a valid string request with specific type" do
+      rule = application.config.rules[1]
+      application.process_rule(rule, rule.resource_class, nil, transaction).should be_true
+    end
+
+    it "should match a valid string request with a block" do
+      rule = application.config.rules[2]
+      application.process_rule(rule, rule.resource_class, nil, transaction).should be_true
+    end
+
+    it "should match a valid string request with a block" do
+      rule = application.config.rules[3]
+      application.process_rule(rule, rule.resource_class, nil, transaction).should be_true
+    end
+
+
+    it "should match a valid regexp request" do
+      rule = application.config.rules[4]
+      mo = rule.match_host("match_5_12.dev")
+      application.process_rule(rule, rule.resource_class, mo, transaction).should be_true
+    end
+
+    it "should match a valid regexp request with specific type" do
+      rule = application.config.rules[5]
+      mo = rule.match_host("match_6_34.dev")
+      application.process_rule(rule, rule.resource_class, mo, transaction).should be_true
+    end
+
+    it "should match a valid regexp request with a block" do
+      rule = application.config.rules[6]
+      mo = rule.match_host("match_7_56.dev")
+      application.process_rule(rule, rule.resource_class, mo, transaction).should be_true
+    end
+
+    it "should match a valid regexp request with a block and specific type" do
+      rule = application.config.rules[7]
+      mo = rule.match_host("match_8_78.dev")
+      application.process_rule(rule, rule.resource_class, mo, transaction).should be_true
+    end
+
+    it "should return false for a false block" do
+      rule = application.config.rules[8]
+      application.process_rule(rule, rule.resource_class, nil, transaction).should be_false
+    end
+
+    it "should return nil for a nil reply" do
+      rule = application.config.rules[0]
+      rule.reply = nil
+      application.process_rule(rule, rule.resource_class, nil, transaction).should be_nil
+    end
+  end
+
+  describe "#dns_update" do
+    it "should update the DNS cache" do
+      application.stub(:execute_command).and_return("EXECUTED")
+      application.dns_update.should == "EXECUTED"
+    end
+  end
+
+  describe "#resolver_path" do
+    it "should return the resolver file basing on the configuration" do application.resolver_path.should == "/etc/resolver/#{application.config.tld}" end
+    it "should return the resolver file basing on the argument" do application.resolver_path("foo").should == "/etc/resolver/foo" end
+  end
+
+  describe "launch_agent_path" do
+    it "should return the agent file with a default name" do application.launch_agent_path.should == ENV["HOME"] + "/Library/LaunchAgents/it.cowtech.devdnsd.plist" end
+    it "should return the agent file with a specified name" do application.launch_agent_path("foo").should == ENV["HOME"] + "/Library/LaunchAgents/foo.plist" end
+  end
+
+  describe "#action_start" do
+    it "should call perform_server in foreground" do
+      DevDNSd::Application.instance({}, {:foreground => true}, [], true).should_receive(:perform_server)
+      application.action_start
+    end
+
+    it "should start the daemon" do
+      DevDNSd::Application.instance({}, {}, [], true)
+      RExec::Daemon::Controller.should_receive(:start)
+      application.action_start
+    end
+  end
+
+  describe "#action_stop" do
+    it "should stop the daemon" do
+      RExec::Daemon::Controller.should_receive(:stop)
+      application.action_stop
+    end
+  end
+
+  describe "#action_install" do
+    it "should create the resolver" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return(launch_agent_path)
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.action_install
+      File.exists?(resolver_path).should be_true
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should create the agent" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return(launch_agent_path)
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.action_install
+      File.exists?(application.launch_agent_path).should be_true
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should update the DNS cache" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return(launch_agent_path)
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.should_receive(:dns_update)
+      application.action_install
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should not create and invalid logger" do
+      application.stub(:resolver_path).and_return("/invalid/resolver")
+      application.stub(:launch_agent_path).and_return("/invalid/agent")
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.get_logger.should_receive(:error).with("Cannot create the resolver file.")
+      application.action_install
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should not create and invalid agent" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return("/invalid/agent")
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.get_logger.should_receive(:error).with("Cannot create the launch agent.")
+      application.action_install
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should not load an invalid agent" do
+      class DevDNSd::Application
+        def execute_command(command)
+          command =~ /^launchctl/ ? raise(StandardError) : system(command)
+        end
+      end
+
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return(launch_agent_path)
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.get_logger.should_receive(:error).with("Cannot load the launch agent.")
+      application.action_install
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should raise an exception if not running on OSX" do
+      application.stub(:is_osx?).and_return(false)
+      application.get_logger.should_receive(:fatal).with("Install DevDNSd as a local resolver is only available on MacOSX.")
+      application.action_install.should be_false
+    end
+  end
+
+  describe "#action_uninstall" do
+    it "should remove the resolver" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return(launch_agent_path)
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.action_install
+      application.action_uninstall
+      File.exists?(resolver_path).should be_false
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should remove the agent" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return(launch_agent_path)
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      DevDNSd::Logger.stub(:default_file).and_return($stdout)
+      application.action_install
+      application.action_uninstall
+      File.exists?(application.launch_agent_path).should be_false
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should not load delete an invalid resolver" do
+      application.stub(:resolver_path).and_return("/invalid/resolver")
+      application.stub(:launch_agent_path).and_return("/invalid/agent")
+
+      application.action_install
+      application.get_logger.should_receive(:warn).at_least(1)
+      application.action_uninstall
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should not delete an invalid agent" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return("/invalid/agent")
+
+      application.action_install
+      application.get_logger.should_receive(:warn).at_least(1)
+      application.action_uninstall
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should not load delete invalid agent" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return("/invalid/agent")
+
+      application.action_install
+      application.stub(:execute_command).and_raise(StandardError)
+      application.get_logger.should_receive(:warn).at_least(1)
+      application.action_uninstall
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should update the DNS cache" do
+      application.stub(:resolver_path).and_return(resolver_path)
+      application.stub(:launch_agent_path).and_return(launch_agent_path)
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+
+      application.action_install
+      application.should_receive(:dns_update)
+      application.action_uninstall
+
+      File.unlink(application.resolver_path) if File.exists?(application.resolver_path)
+      File.unlink(application.launch_agent_path) if File.exists?(application.launch_agent_path)
+    end
+
+    it "should raise an exception if not running on OSX" do
+      application.stub(:is_osx?).and_return(false)
+      application.get_logger.should_receive(:fatal).with("Install DevDNSd as a local resolver is only available on MacOSX.")
+      application.action_uninstall.should be_false
+    end
+  end
+end