devdnsd 1.0.3 → 1.1.0

data/.travis.yml

@@ -1,5 +1,8 @@
+language: ruby
 rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
 script: bundle exec rake spec:coverage
+notifications:
+  email: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    devdnsd (1.0.3)
+    devdnsd (1.1.0)
       cowtech-extensions (~> 2.7.0)
       gli (~> 1.6.0)
       rainbow (~> 1.1.0)

data/lib/devdnsd/application.rb

@@ -52,8 +52,8 @@ module DevDNSd
         @logger = self.get_logger
 
       rescue DevDNSd::Errors::InvalidConfiguration, DevDNSd::Errors::InvalidRule => e
-        @logger.fatal(e.message)
-        raise SystemExit
+        @logger ? @logger.fatal(e.message) : DevDNSd::Logger.create("STDERR").fatal("Cannot log to #{config.log_file}. Exiting...")
+        raise ::SystemExit
       end
 
       self
@@ -64,7 +64,7 @@ module DevDNSd
     #
     # @return [Boolean] `true` if the current platform is MacOS X, `false` otherwise.
     def is_osx?
-      Config::CONFIG['host_os'] =~ /^darwin/
+      ::Config::CONFIG['host_os'] =~ /^darwin/
     end
 
     # Gets the current logger of the application.
@@ -112,23 +112,24 @@ module DevDNSd
     # @return [Object] The result of stop callbacks.
     def perform_server
       RubyDNS::run_server(:listen => [[:udp, @config.address, @config.port.to_integer]]) do
-        self.logger = Application.instance.logger
+        self.logger = DevDNSd::Application.instance.logger
 
-        match(/.+/, Application::ANY_REQUEST) do |match_data, transaction|
+        match(/.+/, DevDNSd::Application::ANY_CLASSES) do |match_data, transaction|
           transaction.append_question!
 
-          Application.instance.config.rules.each do |rule|
+          DevDNSd::Application.instance.config.rules.each do |rule|
             begin
               # Get the subset of handled class that is valid for the rule
-              resource_classes = Application::ANY_CLASSES & rule.resource_class.ensure_array
+              resource_classes = DevDNSd::Application::ANY_CLASSES & rule.resource_class.ensure_array
+              resource_classes = resource_classes & [transaction.resource_class] if transaction.resource_class != DevDNSd::Application::ANY_REQUEST
 
               if resource_classes.present? then
                 resource_classes.each do |resource_class| # Now for every class
                   matches = rule.match_host(match_data[0])
-                  Application.instance.process_rule(rule, resource_class, rule.is_regexp? ? matches : nil, transaction) if matches
+                  DevDNSd::Application.instance.process_rule(rule, resource_class, rule.is_regexp? ? matches : nil, transaction) if matches
                 end
               end
-            rescue Exception => e
+            rescue ::Exception => e
               raise e
             end
           end
@@ -141,11 +142,11 @@ module DevDNSd
 
         # Attach event handlers
         self.on(:start) do
-          Application.instance.on_start
+          DevDNSd::Application.instance.on_start
         end
 
         self.on(:stop) do
-          Application.instance.on_stop
+          DevDNSd::Application.instance.on_stop
         end
       end
     end
@@ -158,10 +159,10 @@ module DevDNSd
     # @param transaction [Transaction] The current DNS transaction (http://rubydoc.info/gems/rubydns/RubyDNS/Transaction).
     # @return A reply for the request if matched, otherwise `false` or `nil`.
     def process_rule(rule, type, match_data, transaction)
-      is_regex = rule.match.is_a?(Regexp)
+      is_regex = rule.match.is_a?(::Regexp)
       type = DevDNSd::Rule.resource_class_to_symbol(type)
 
-      Application.instance.logger.debug("Found match on #{rule.match} with type #{type}.")
+      DevDNSd::Application.instance.logger.debug("Found match on #{rule.match} with type #{type}.")
 
       if !rule.block.nil? then
         reply = rule.block.call(match_data, type, transaction)
@@ -173,7 +174,7 @@ module DevDNSd
         reply = match_data[0].gsub(rule.match, reply.gsub("$", "\\"))
       end
 
-      Application.instance.logger.debug(reply ? "Reply is #{reply} with type #{type}." : "No reply found.")
+      DevDNSd::Application.instance.logger.debug(reply ? "Reply is #{reply} with type #{type}." : "No reply found.")
 
       if reply then
         options = rule.options
@@ -261,8 +262,8 @@ module DevDNSd
 
         args = $ARGV ? $ARGV[0, $ARGV.length - 1] : ["A"]
 
-        plist = {"KeepAlive" => true, "Label" => "it.cowtech.devdnsd", "Program" => (Pathname.new(Dir.pwd) + $0).to_s, "ProgramArguments" => args, "RunAtLoad" => true}
-        File.open(launch_agent, "w") {|f|
+        plist = {"KeepAlive" => true, "Label" => "it.cowtech.devdnsd", "Program" => (::Pathname.new(Dir.pwd) + $0).to_s, "ProgramArguments" => args, "RunAtLoad" => true}
+        ::File.open(launch_agent, "w") {|f|
           f.write(plist.to_json)
           f.flush
         }
@@ -302,7 +303,7 @@ module DevDNSd
       # Remove the resolver
       begin
         logger.info("Deleting the resolver #{resolver_file} ...")
-        File.delete(resolver_file)
+        ::File.delete(resolver_file)
       rescue => e
         logger.warn("Cannot delete the resolver file.")
         return false
@@ -318,7 +319,7 @@ module DevDNSd
       # Delete the launch agent.
       begin
         logger.info("Deleting the launch agent #{launch_agent} ...")
-        File.delete(launch_agent)
+        ::File.delete(launch_agent)
       rescue => e
         logger.warn("Cannot delete the launch agent.")
         return false
@@ -345,10 +346,11 @@ module DevDNSd
     # @param globals [Hash] Global options.
     # @param locals [Hash] Local command options.
     # @param args [Array] Extra arguments.
+    # @param force [Boolean] If to force recreation of the instance.
     # @return [Application] The unique (singleton) instance of the application.
     def self.instance(globals = {}, locals = {}, args = [], force = false)
-      @@instance = nil if force
-      @@instance ||= Application.new(globals, locals, args)
+      @instance = nil if force
+      @instance ||= DevDNSd::Application.new(globals, locals, args)
     end
 
     # Runs the application in foreground.
@@ -360,7 +362,7 @@ module DevDNSd
 
     # Stops the application.
     def self.quit
-      EventMachine.stop
+      ::EventMachine.stop
     end
   end
 end

data/lib/devdnsd/configuration.rb

@@ -45,29 +45,29 @@ module DevDNSd
       @port = 7771
       @tld = "dev"
       @log_file = "/var/log/devdnsd.log"
-      @log_level = Logger::INFO
+      @log_level = ::Logger::INFO
       @rules = []
       @foreground = false
 
       if file.present?
         begin
           # Open the file
-          path = Pathname.new(file).realpath
+          path = ::Pathname.new(file).realpath
           application.logger.info("Using configuration file #{path}.") if application
           self.tap do |config|
-            eval(File.read(path))
+            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
+        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
+      if overrides.is_a?(::Hash) then
         overrides.each_pair do |k, v|
           self.send("#{k}=", v) if self.respond_to?("#{k}=") && !v.nil?
         end

data/lib/devdnsd/errors.rb

@@ -8,11 +8,11 @@ module DevDNSd
   # Exceptions for {DevDNSd DevDNSd}.
   module Errors
     # This exception is raised if a {Rule Rule} is invalid.
-    class InvalidRule < ArgumentError
+    class InvalidRule < ::ArgumentError
     end
 
     # This exception is raised if a {Configuration Configuration} is invalid.
-    class InvalidConfiguration < ArgumentError
+    class InvalidConfiguration < ::ArgumentError
     end
   end
 end

data/lib/devdnsd/logger.rb

@@ -32,7 +32,13 @@ module DevDNSd
     # @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))
+
+      begin
+        rv = self.new(self.get_real_file(file))
+      rescue
+        raise DevDNSd::Errors::InvalidConfiguration
+      end
+
       rv.level = level.to_i
       rv.formatter = formatter || self.default_formatter
       rv
@@ -59,7 +65,7 @@ module DevDNSd
     # The default formatter for logging.
     # @return [Proc] The default formatter for logging.
     def self.default_formatter
-      @default_formatter ||= Proc.new {|severity, datetime, progname, msg|
+      @default_formatter ||= ::Proc.new {|severity, datetime, progname, msg|
         color = case severity
           when "DEBUG" then :cyan
           when "INFO" then :green
@@ -78,7 +84,7 @@ module DevDNSd
     # 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
+      @start_time ||= ::Time.now
     end
   end
 end

data/lib/devdnsd/rule.rb

@@ -46,7 +46,7 @@ module DevDNSd
       @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)
+      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.
@@ -61,7 +61,7 @@ module DevDNSd
     #
     # @return [Boolean] `true` if the rule is a Regexp, `false` otherwise.
     def is_regexp?
-      self.match.is_a?(Regexp)
+      self.match.is_a?(::Regexp)
     end
 
     # Checks if the rule is a regexp.
@@ -88,7 +88,7 @@ module DevDNSd
     # @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)
+      raise(DevDNSd::Errors::InvalidRule.new("You can only use hashs for options.")) if !options.is_a?(::Hash)
 
       rv = self.new(match)
       rv.options = options
@@ -122,7 +122,7 @@ module DevDNSd
 
       begin
         "Resolv::DNS::Resource::IN::#{symbol}".constantize
-      rescue NameError
+      rescue ::NameError
         raise(DevDNSd::Errors::InvalidRule.new("Invalid resource class #{symbol}."))
       end
     end

data/lib/devdnsd/version.rb

@@ -13,10 +13,10 @@ module DevDNSd
     MAJOR = 1
 
     # The minor version.
-    MINOR = 0
+    MINOR = 1
 
     # The patch version.
-    PATCH = 3
+    PATCH = 0
 
     # The current version number of DevDNSd.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/spec/devdnsd/application_spec.rb

@@ -11,12 +11,12 @@ describe DevDNSd::Application do
     DevDNSd::Logger.stub(:default_file).and_return("/dev/null")
   end
 
-  let(:log_file) { "/tmp/devdnsd-test-log-#{Time.now.strftime("%Y%m%d-%H:%M:%S")}" }
-  let(:application){ app = DevDNSd::Application.instance(:log_file => log_file) }
-  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")}" }
+  let(:log_file) { "/tmp/devdnsd-test-log-#{Time.now.strftime("%Y%m%d-%H%M%S")}" }
+  let(:application){ DevDNSd::Application.instance({:log_file => log_file}, {}, {}, true) }
+  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
@@ -24,122 +24,130 @@ describe DevDNSd::Application do
 
     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 = ::File.new(path, "w")
       file.write("config.port = ")
       file.close
 
-      expect { DevDNSd::Application.new({:config => file.path, :log_file => log_file}) }.to raise_error(SystemExit)
-      File.unlink(path)
+      expect { DevDNSd::Application.new({:config => file.path, :log_file => log_file}) }.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 ".quit" do
+    it "should quit the application" do
+      ::EventMachine.should_receive(:stop)
+      DevDNSd::Application.quit
+    end
+  end
+
   describe "#perform_server" do
+    let(:application){ DevDNSd::Application.instance({:log_file => log_file, :config => sample_config}, {}, {}, true) }
+
     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
+          Thread.main[:resolver].wakeup if Thread.main[:resolver].try(:alive?)
         end
       end
+    end
+
+    def test_resolve(host = "match_1.dev", type = "ANY", nameserver = "127.0.0.1", port = 7771, logger = nil)
+      host ||= "match.dev"
+
+      Thread.current[:resolver] = Thread.start {
+        Thread.stop
+        Thread.main[:result] = devdnsd_resolv(host, type, nameserver, port, logger)
+      }
+
+      Thread.current[:server] = Thread.start {
+        sleep(0.1)
+
+        if block_given? then
+          yield
+        else
+          application.perform_server
+        end
+      }
+
+      Thread.current[:resolver].join
+      Thread.kill(Thread.current[:server])
+      Thread.main[:running] = false
+      Thread.main[:result]
+    end
 
+    it "should run the server" do
       RubyDNS.should_receive(:run_server)
-      DevDNSd::Application.instance.perform_server
+      application.perform_server
+    end
+
+    it "should stop the server" do
+      application.should_receive(:on_stop)
+
+      Thread.new {
+        sleep(1)
+        application.class.quit
+      }
+
+      application.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
+      test_resolve do
+        application.config.rules.should_receive(:each).at_least(1)
+        application.perform_server
       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
+      test_resolve do
+        application.should_receive(:process_rule).at_least(1)
+        application.perform_server
       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
+      test_resolve do
+        application.stub(:process_rule).and_raise(::Exception)
+        expect { application.perform_server }.to raise_exception
       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]
+        test_resolve("match_1.dev").should == ["10.0.1.1", :A]
+        test_resolve("match_2.dev").should == ["10.0.2.1", :MX]
+        test_resolve("match_3.dev").should == ["10.0.3.1", :A]
+        test_resolve("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]
-
+        test_resolve("match_5_11.dev").should == ["10.0.5.11", :A]
+        test_resolve("match_5_22.dev").should == ["10.0.5.22", :A]
+        test_resolve("match_6_33.dev").should == ["10.0.6.33", :PTR]
+        test_resolve("match_6_44.dev").should == ["10.0.6.44", :PTR]
+        test_resolve("match_7_55.dev").should == ["10.0.7.55", :A]
+        test_resolve("match_7_66.dev").should == ["10.0.7.66", :A]
+        test_resolve("match_8_77.dev").should == ["10.0.8.77", :PTR]
+        test_resolve("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 return multiple or only relevant answsers" do
+        test_resolve("match_10.dev").should == [["10.0.10.1", :A], ["10.0.10.2", :MX]]
+        test_resolve("match_10.dev", "MX").should == ["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
+        test_resolve("match_9.dev").should be_nil
+        test_resolve("invalid.dev").should be_nil
       end
     end
   end
@@ -157,7 +165,7 @@ describe DevDNSd::Application do
       end
     end
 
-    let(:application){ DevDNSd::Application.new({:config => Pathname.new(File.dirname((__FILE__))) + "../../config/devdnsd_config.sample" }) }
+    let(:application){ DevDNSd::Application.instance({:log_file => log_file, :config => sample_config}, {}, {}, true) }
     let(:transaction){ FakeTransaction.new }
 
     it "should match a valid string request" do
@@ -180,7 +188,6 @@ describe DevDNSd::Application do
       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")
@@ -229,115 +236,118 @@ describe DevDNSd::Application do
     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
+  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 = DevDNSd::Application.instance({:log_file => log_file}, {:foreground => true}, [], true)
+      application.should_receive(:perform_server)
       application.action_start
     end
 
     it "should start the daemon" do
-      DevDNSd::Application.instance({:log_file => log_file}, {}, [], true)
-      RExec::Daemon::Controller.should_receive(:start)
+      application = DevDNSd::Application.instance({:log_file => log_file}, {}, [], 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)
+      ::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
+    if ::Config::CONFIG['host_os'] =~ /^darwin/ then
+      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)
+      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
+        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
+        ::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)
+      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
+        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
+        ::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)
+      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
+        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
+        ::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)
+      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
+        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
+        ::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)
+      it "should not load an invalid agent" do
+        class DevDNSd::Application
+          def execute_command(command)
+            command =~ /^launchctl/ ? raise(StandardError) : system(command)
+          end
         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.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
+        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)
+        ::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
     end
 
     it "should raise an exception if not running on OSX" do
@@ -348,84 +358,86 @@ describe DevDNSd::Application do
   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
+    if ::Config::CONFIG['host_os'] =~ /^darwin/ then
+      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)
+      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
+        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
+        ::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")
+      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
+        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
+        ::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")
+      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
+        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
+        ::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")
+      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
+        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
+        ::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)
+      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
+        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)
+        ::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
     end
 
     it "should raise an exception if not running on OSX" do

data/spec/devdnsd/configuration_spec.rb

@@ -29,13 +29,13 @@ describe DevDNSd::Configuration do
       config.port.should == 7771
       config.tld.should == "dev"
       config.log_file.should == "/var/log/devdnsd.log"
-      config.log_level.should == Logger::INFO
+      config.log_level.should == ::Logger::INFO
       config.rules.count.should == 1
       config.foreground.should == false
     end
 
     it "reads a valid configuration file" do
-      file = Tempfile.new('devdnsd-test')
+      file = ::Tempfile.new('devdnsd-test')
       file.write("config.port = 7772")
       file.close
 
@@ -45,7 +45,7 @@ describe DevDNSd::Configuration do
     end
 
     it "reject an invalid configuration" do
-      file = Tempfile.new('devdnsd-test')
+      file = ::Tempfile.new('devdnsd-test')
       file.write("config.port = ")
       file.close
 
@@ -54,7 +54,7 @@ describe DevDNSd::Configuration do
     end
 
     it "allows overrides" do
-      file = Tempfile.new('devdnsd-test')
+      file = ::Tempfile.new('devdnsd-test')
       file.write("config.port = 7772")
       file.close
 

data/spec/devdnsd/logger_spec.rb

@@ -15,28 +15,32 @@ describe DevDNSd::Logger do
     it("should create a new default logger") do
       logger = DevDNSd::Logger.create
       logger.device.should == DevDNSd::Logger.default_file
-      logger.level.should == Logger::INFO
+      logger.level.should == ::Logger::INFO
       logger.formatter.should == DevDNSd::Logger.default_formatter
     end
 
     it("should create a logger with a custom file and level") do
-      logger = DevDNSd::Logger.create("/dev/null", Logger::WARN)
+      logger = DevDNSd::Logger.create("/dev/null", ::Logger::WARN)
       logger.device.should == "/dev/null"
-      logger.level.should == Logger::WARN
+      logger.level.should == ::Logger::WARN
       logger.formatter.should == DevDNSd::Logger.default_formatter
     end
 
     it("should create a logger with a custom formatter") do
       formatter = Proc.new {|severity, datetime, progname, msg| msg }
-      logger = DevDNSd::Logger.create("/dev/null", Logger::WARN, formatter)
+      logger = DevDNSd::Logger.create("/dev/null", ::Logger::WARN, formatter)
       logger.device.should == "/dev/null"
-      logger.level.should == Logger::WARN
+      logger.level.should == ::Logger::WARN
       logger.formatter.should == formatter
     end
+
+    it("should raise exceptions for invalid files") do
+      expect { DevDNSd::Logger.create("/invalid/file") }.to raise_error(DevDNSd::Errors::InvalidConfiguration)
+    end
   end
 
   describe ".default_formatter" do
-    let(:output) { StringIO.new }
+    let(:output) { ::StringIO.new }
     let(:logger) { DevDNSd::Logger.create(output, Logger::DEBUG) }
 
     def get_last_line(buffer)
@@ -45,32 +49,32 @@ describe DevDNSd::Logger do
 
     it "should correctly format a DEBUG message" do
       logger.debug("Message.")
-      get_last_line(output).should == "[#{Time.now.strftime("%Y/%b/%d %H:%M:%S")}] DEBUG: Message."
+      get_last_line(output).should == "[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] DEBUG: Message."
     end
 
     it "should correctly format a INFO message" do
       logger.info("Message.")
-      get_last_line(output).should == "[#{Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  INFO: Message."
+      get_last_line(output).should == "[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  INFO: Message."
     end
 
     it "should correctly format a WARN message" do
       logger.warn("Message.")
-      get_last_line(output).should == "[#{Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  WARN: Message."
+      get_last_line(output).should == "[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  WARN: Message."
     end
 
     it "should correctly format a ERROR message" do
       logger.error("Message.")
-      get_last_line(output).should == "[#{Time.now.strftime("%Y/%b/%d %H:%M:%S")}] ERROR: Message."
+      get_last_line(output).should == "[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] ERROR: Message."
     end
 
     it "should correctly format a FATAL message" do
       logger.fatal("Message.")
-      get_last_line(output).should == "[#{Time.now.strftime("%Y/%b/%d %H:%M:%S")}] FATAL: Message."
+      get_last_line(output).should == "[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] FATAL: Message."
     end
 
     it "should correctly format a INVALID message" do
-      logger.log(Logger::UNKNOWN, "Message.")
-      get_last_line(output).should == "[#{Time.now.strftime("%Y/%b/%d %H:%M:%S")}]   ANY: Message."
+      logger.log(::Logger::UNKNOWN, "Message.")
+      get_last_line(output).should == "[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]   ANY: Message."
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: devdnsd
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-24 00:00:00.000000000 Z
+date: 2012-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubydns
@@ -266,7 +266,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 433211050793937719
+      hash: 97728399073097527
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -275,7 +275,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 433211050793937719
+      hash: 97728399073097527
 requirements: []
 rubyforge_project: devdnsd
 rubygems_version: 1.8.24