devdnsd 3.1.2 → 4.0.0

data/lib/devdnsd/server.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+#
+# This file is part of the devdnsd gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+# A small DNS server to enable local .dev domain resolution.
+module DevDNSd
+  # Methods to process requests.
+  module Server
+    # Starts the DNS server.
+    #
+    # @return [Object] The result of stop callbacks.
+    def perform_server
+      application = self
+
+      @server = RubyDNS.run_server(server_options) do
+        self.logger = application.logger
+
+        match(/.+/, DevDNSd::Application::ANY_CLASSES) do |transaction, match_data|
+          # During debugging, wrap the inside of the block with a begin rescue and PRINT the exception because RubyDNS hides it.
+          application.config.rules.each { |rule| application.process_rule_in_classes(rule, match_data, transaction) }
+        end
+
+        # Default DNS handler and event handlers
+        otherwise { |transaction| transaction.failure!(:NXDomain) }
+        on(:start) { application.on_start }
+        on(:stop) { application.on_stop }
+      end
+    end
+
+    alias_method :startup, :perform_server
+
+    # Processes a DNS rule.
+    #
+    # @param rule [Rule] The rule to process.
+    # @param type [Symbol] The type of the query.
+    # @param match_data [MatchData|nil] If the rule pattern was a Regexp, then this holds the match data, otherwise `nil` is passed.
+    # @param transaction [RubyDNS::Transaction] The current DNS transaction (http://rubydoc.info/gems/rubydns/RubyDNS/Transaction).
+    def process_rule(rule, type, match_data, transaction)
+      reply, type = perform_process_rule(rule, type, match_data, transaction)
+      logger.debug(reply ? i18n.reply(reply, type) : i18n.no_reply)
+
+      if reply
+        transaction.respond!(*finalize_reply(reply, rule, type))
+      else
+        reply.is_a?(FalseClass) ? false : nil
+      end
+    end
+
+    # Processes a rule against a set of DNS resource classes.
+    #
+    # @param rule [Rule] The rule to process.
+    # @param match_data [MatchData|nil] If the rule pattern was a Regexp, then this holds the match data, otherwise `nil` is passed.
+    # @param transaction [RubyDNS::Transaction] The current DNS transaction (http://rubydoc.info/gems/rubydns/RubyDNS/Transaction).
+    def process_rule_in_classes(rule, match_data, transaction)
+      # Get the subset of handled class that is valid for the rule
+      resource_classes = DevDNSd::Application::ANY_CLASSES & rule.resource_class.ensure_array
+      resource_classes &= [transaction.resource_class] if transaction.resource_class != DevDNSd::Application::ANY_REQUEST
+
+      if resource_classes.present?
+        resource_classes.each do |resource_class| # Now for every class
+          matches = rule.match_host(match_data[0])
+          process_rule(rule, resource_class, rule.regexp? ? matches : nil, transaction) if matches
+        end
+      end
+    end
+
+    private
+
+    # :nodoc:
+    def server_options
+      {asynchronous: !@config.foreground, listen: build_listen_interfaces}
+    end
+
+    # :nodoc:
+    def build_listen_interfaces
+      port = @config.port.to_integer
+      @config.bind_addresses.ensure_array { |address| [:udp, address, port] } + @config.bind_addresses.ensure_array { |address| [:tcp, address, port] }
+    end
+
+    # :nodoc:
+    def perform_process_rule(rule, type, match_data, transaction)
+      type = DevDNSd::Rule.resource_class_to_symbol(type)
+      reply = execute_rule(transaction, rule, type, match_data)
+
+      logger.debug(i18n.match(rule.match, type))
+      [reply, type]
+    end
+
+    # :nodoc:
+    def execute_rule(transaction, rule, type, match_data)
+      reply = rule.block ? rule.block.call(match_data, type, transaction) : rule.reply
+      reply = match_data[0].gsub(rule.match, reply.gsub("$", "\\")) if rule.match.is_a?(::Regexp) && reply && match_data && match_data[0]
+      reply
+    end
+
+    # :nodoc:
+    def finalize_reply(reply, rule, type)
+      rv = []
+      rv << rule.options.delete(:priority).to_integer(10) if type == :MX
+      rv << ([:A, :AAAA].include?(type) ? reply : Resolv::DNS::Name.create(reply))
+      rv << prepare_reply_options(rule, type)
+      rv
+    end
+
+    # :nodoc:
+    def prepare_reply_options(rule, type)
+      rule.options.merge({resource_class: DevDNSd::Rule.symbol_to_resource_class(type, @locale), ttl: validate_ttl(rule.options.delete(:ttl))})
+    end
+
+    # :nodoc:
+    def validate_ttl(current, default = 300)
+      current = current.to_integer
+      current > 0 ? current : default
+    end
+  end
+end

data/lib/devdnsd/system.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+#
+# This file is part of the devdnsd gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+# A small DNS server to enable local .dev domain resolution.
+module DevDNSd
+  # System management methods.
+  module System
+    extend ActiveSupport::Concern
+
+    # Returns the name of the daemon.
+    #
+    # @return [String] The name of the daemon.
+    def daemon_name
+      config ? File.basename(config.pid_file, ".pid") : "devdnsd"
+    end
+
+    alias_method :name, :daemon_name
+
+    # Returns the standard location of the PID file.
+    #
+    # @return [String] The standard location of the PID file.
+    def working_directory
+      config ? File.dirname(config.pid_file) : Dir.pwd
+    end
+    alias_method :runtime_directory, :working_directory
+
+    # Returns the complete path of the PID file.
+    #
+    # @return [String] The complete path of the PID file.
+    def process_file_path
+      config ? config.pid_file : Dir.pwd + "devdnsd.pid"
+    end
+
+    # Returns the complete path of the log file.
+    #
+    # @return [String] The complete path of the log file.
+    def log_file_path
+      config.log_file
+    end
+
+    # Returns the standard location of the log file.
+    #
+    # @return [String] The standard location of the log file.
+    def log_directory
+      File.dirname(config.log_file)
+    end
+
+    # Starts the server in background.
+    #
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_start
+      logger.info(i18n.starting)
+
+      prepare_start
+
+      @config.foreground ? perform_server : self.class.start
+      true
+    end
+
+    # Stops the server in background.
+    #
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_stop
+      self.class.stop
+      true
+    end
+
+    # Restarts the server in background.
+    #
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_restart
+      action_stop
+      action_start
+      true
+    end
+
+    # Shows the status of the server
+    #
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_status
+      status = self.class.status
+      status = :crashed if status == :unknown && self.class.crashed?
+
+      log_status(self.class.controller.pid, status)
+    end
+
+    private
+
+    # :nodoc:
+    def prepare_start
+      if !Process.respond_to?(:fork)
+        logger.warn(i18n.no_fork)
+        @config.foreground = true
+      elsif @command.options[:foreground].value
+        @config.foreground = true
+      end
+    end
+  end
+end

data/lib/devdnsd/version.rb

@@ -10,13 +10,13 @@ module DevDNSd
   # @see http://semver.org
   module Version
     # The major version.
-    MAJOR = 3
+    MAJOR = 4
 
     # The minor version.
-    MINOR = 1
+    MINOR = 0
 
     # The patch version.
-    PATCH = 2
+    PATCH = 0
 
     # The current version number of DevDNSd.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/locales/en.yml

@@ -5,33 +5,34 @@
 #
 
 ---
+en:
   devdnsd:
     rule_invalid_call: "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."
     rule_invalid_options: "You can only use hashs for options."
-    rule_invalid_resource: "Invalid resource class %1."
+    rule_invalid_resource: "Invalid resource class %s."
     dns_update: "Flushing DNS cache and resolvers ..."
     no_jruby: "DevDNSd is not available on JRuby."
     no_fork: "Forking is not available for this platform. Running in foreground ..."
     starting: "Starting DevDNSd ..."
-    match: "Found match on %1 with type %2."
-    reply: "Reply is %1 with type %2."
+    match: "Found match on %s with type %s."
+    reply: "Reply is %s with type %s."
     no_reply: "No reply found."
     no_agent: "Install DevDNSd as a local resolver is only available on MacOSX."
     admin_privileges_warning: "Basing on your setup, the system might ask you up to twice to grant {mark=bright}osascript{/mark} application admin privileges."
-    resolver_creating: "Creating the resolver in {mark=bright}%1{/mark} ..."
+    resolver_creating: "Creating the resolver in {mark=bright}%s{/mark} ..."
     resolver_creating_error: "Cannot create the resolver file."
-    resolver_deleting: "Deleting the resolver %1 ..."
+    resolver_deleting: "Deleting the resolver %s ..."
     resolver_deleting_error: "Cannot delete the resolver file."
-    agent_creating: "Creating the launch agent in {mark=bright}%1{/mark} ..."
+    agent_creating: "Creating the launch agent in {mark=bright}%s{/mark} ..."
     agent_creating_error: "Cannot create the launch agent."
-    agent_deleting: "Deleting the launch agent %1 ..."
+    agent_deleting: "Deleting the launch agent %s ..."
     agent_deleting_error: "Cannot delete the launch agent."
-    agent_loading: "Loading the launch agent %1 ..."
+    agent_loading: "Loading the launch agent %s ..."
     agent_loading_error: "Cannot load the launch agent."
-    agent_unloading: "Unloading the launch agent %1 ..."
+    agent_unloading: "Unloading the launch agent %s ..."
     agent_unloading_error: "Cannot unload the launch agent."
-    logging_failed: "Cannot log to {mark=bright}%1{/mark}. Logging to terminal..."
-    invalid_directory: "Cannot write on directory {mark=bright}%1{/mark}. Exiting..."
+    logging_failed: "Cannot log to {mark=bright}%s{/mark}. Logging to terminal..."
+    invalid_directory: "Cannot write on directory {mark=bright}%s{/mark}. Exiting..."
     application_description: "A small DNS server to enable local domain resolution."
     application_help_configuration: "The configuration file to use. Default is \"~/.devdnsd_config\"."
     application_help_tld: "The TLD to handle. Default is \"dev\"."
@@ -56,7 +57,7 @@
     application_meta_addresses: "ADDRESSES"
     application_meta_aliases: "ALIASES"
     application_meta_command: "COMMAND"
-    application_create_config: "To execute devdnsd, please create the file {mark=bright}%1{/mark}. An empty file is sufficient."
+    application_create_config: "To execute devdnsd, please create the file {mark=bright}%s{/mark}. An empty file is sufficient."
     command_start: "Starts the server."
     command_stop: "Stops the server."
     command_restart: "Restarts the server."
@@ -67,7 +68,7 @@
     command_aliases: "Adds or removes aliases to network interfaces."
     command_add: "Adds aliases."
     command_remove: "Removes aliases."
-    status_running: "The server is running with process ID {mark=bright}%1{/mark}."
+    status_running: "The server is running with process ID {mark=bright}%s{/mark}."
     status_stopped: "The server is stopped."
     status_crashed: "The server crashed. See the log for more information."
     status_unknown: "The server status is unknown."
@@ -77,8 +78,8 @@
     add: "add"
     to: "to "
     from: "from "
-    general_error: "Cannot {mark=bright}%1{/mark} address {mark=bright}%2{/mark} %3interface {mark=bright}%4{/mark}."
+    general_error: "Cannot {mark=bright}%s{/mark} address {mark=bright}%s{/mark} %sinterface {mark=bright}%s{/mark}."
     add_empty: "No valid addresses to add to the interface found."
     remove_empty: "No valid addresses to remove from the interface found."
-    run: "%1 {mark=bright}%2{/mark} address {mark=bright}%3{/mark} %4interface {mark=bright}%5{/mark}..."
-    dry_run: "%1 I will {mark=bright}%2{/mark} address {mark=bright}%3{/mark} %4interface {mark=bright}%5{/mark}..."
+    run: "%s {mark=bright}%s{/mark} address {mark=bright}%s{/mark} %sinterface {mark=bright}%s{/mark}..."
+    dry_run: "%s I will {mark=bright}%s{/mark} address {mark=bright}%s{/mark} %sinterface {mark=bright}%s{/mark}..."

data/locales/it.yml

@@ -5,33 +5,34 @@
 #
 
 ---
+it:
   devdnsd:
     rule_invalid_call: "Devi specificare almeno una regola e un host (anche tramite un blocco). Opzionalmente puoi aggiungere un tipo di record (default: A) e le opzioni."
     rule_invalid_options: "Puoi usare solo hash per le opzioni."
-    rule_invalid_resource: "Classe di risorsa %1 non valida."
+    rule_invalid_resource: "Classe di risorsa %s non valida."
     no_jruby: "DevDNSd non è disponibile per JRuby."
     no_fork: "Il forking non è disponibile per questa piattaforma. Eseguo foreground ..."
     dns_update: "Cancello la cache dei DNS e dei resolver ..."
     starting: "Avvio DevDNSd ..."
-    match: "Trovata corrispondenza per %1 con tipo %2."
-    reply: "La risposta è %1 con tipo %2."
+    match: "Trovata corrispondenza per %s con tipo %s."
+    reply: "La risposta è %s con tipo %s."
     no_reply: "Nessuna risposta trovata."
     no_agent: "Installare DevDNSd come resolver locale è disponibile solo su MacOSX."
     admin_privileges_warning: "In base alla tua configurazione, il sistema potrebbe chiederti fino a due volte di garantire all'applicazione {mark=bright}osascript{/mark} i privilegi di amministratore."
-    resolver_creating: "Creo il resolver in {mark=bright}%1{/mark} ..."
+    resolver_creating: "Creo il resolver in {mark=bright}%s{/mark} ..."
     resolver_creating_error: "Impossible creare il file del resolver."
-    resolver_deleting: "Cancello resolver %1 ..."
+    resolver_deleting: "Cancello resolver %s ..."
     resolver_deleting_error: "Impossibile cancellare il file del resolver."
-    agent_creating: "Creo il launch agent in {mark=bright}%1{/mark} ..."
+    agent_creating: "Creo il launch agent in {mark=bright}%s{/mark} ..."
     agent_creating_error: "Impossibile creare il launch agent."
-    agent_deleting: "Cancello il launch agent %1 ..."
+    agent_deleting: "Cancello il launch agent %s ..."
     agent_deleting_error: "Impossibile cancellare launch agent."
-    agent_loading: "Avvio il launch agent %1 ..."
+    agent_loading: "Avvio il launch agent %s ..."
     agent_loading_error: "Impossibile avviare il launch agent."
-    agent_unloading: "Fermo il launch agent %1 ..."
+    agent_unloading: "Fermo il launch agent %s ..."
     agent_unloading_error: "Impossible fermare il launch agent."
-    logging_failed: "Impossibile eseguire il logging in {mark=bright}%1{/mark}. Eseguo il logging nel terminale..."
-    invalid_directory: "Impossibile scrivere sulla directory {mark=bright}%1{/mark}. Esco..."
+    logging_failed: "Impossibile eseguire il logging in {mark=bright}%s{/mark}. Eseguo il logging nel terminale..."
+    invalid_directory: "Impossibile scrivere sulla directory {mark=bright}%s{/mark}. Esco..."
     application_description: "Un piccolo server DNS per abilitare la risoluzione di domini locali."
     application_help_configuration: "Il file di configurazione da usare. Il valore predefinito è \"~/.devdnsd_config\"."
     application_help_tld: "Il TLD da gestiere. Il valore predefinito è \"dev\"."
@@ -57,7 +58,7 @@
     application_meta_addresses: "INDIRIZZI"
     application_meta_aliases: "ALIAS"
     application_meta_command: "COMANDO"
-    application_create_config: "Per eseguire devdnsd, per favore crea il file {mark=bright}%1{/mark}. Un file vuoto è sufficiente."
+    application_create_config: "Per eseguire devdnsd, per favore crea il file {mark=bright}%s{/mark}. Un file vuoto è sufficiente."
     command_start: "Avvia server."
     command_stop: "Ferma il server."
     command_restart: "Riavvia server."
@@ -68,7 +69,7 @@
     command_aliases: "Aggiunge or rimuove indirizzi dalle interfacce di rete."
     command_add: "Aggiungi indirizzi"
     command_remove: "Rimuovi indirizzi."
-    status_running: "Il server è in esecuzione con ID processo {mark=bright}%1{/mark}."
+    status_running: "Il server è in esecuzione con ID processo {mark=bright}%s{/mark}."
     status_stopped: "Il server è stato fermato."
     status_crashed: "Il server è terminato con errori. Guarda il log per maggiori informazioni."
     status_unknown: "Lo status del server è sconosciuto."
@@ -78,8 +79,8 @@
     add: "aggiungere"
     to: "all'"
     from: "dall'"
-    general_error: "Impossibile {mark=bright}%1{/mark} l'indirizzo {mark=bright}%2{/mark} %3interfaccia {mark=bright}%4{/mark}."
+    general_error: "Impossibile {mark=bright}%s{/mark} l'indirizzo {mark=bright}%s{/mark} %sinterfaccia {mark=bright}%s{/mark}."
     add_empty: "Nessun indirizzo valido da aggiungere all'interfaccia trovato."
     remove_empty: "Nessun indirizzo valido da rimuovere dall'interfaccia trovato."
-    run: "%1 {mark=bright}%2{/mark} l'indirizzo {mark=bright}%3{/mark} %4interfaccia {mark=bright}%5{/mark}..."
-    dry_run: "%1 Sto per {mark=bright}%2{/mark} l'indirizzo {mark=bright}%3{/mark} %4interfaccia {mark=bright}%5{/mark}..."
+    run: "%s {mark=bright}%s{/mark} l'indirizzo {mark=bright}%s{/mark} %sinterfaccia {mark=bright}%s{/mark}..."
+    dry_run: "%s Sto per {mark=bright}%s{/mark} l'indirizzo {mark=bright}%s{/mark} %sinterfaccia {mark=bright}%s{/mark}..."

data/spec/devdnsd/application_spec.rb

@@ -10,6 +10,7 @@ describe DevDNSd::Application do
   before(:each) do
     allow(Bovem::Logger).to receive(:default_file).and_return("/dev/null")
     allow(DevDNSd::Application).to receive(:instance).and_return(application)
+    allow(Kernel).to receive(:exit)
   end
 
   def create_application(overrides = {})
@@ -24,7 +25,7 @@ describe DevDNSd::Application do
   end
 
   let(:log_file) { "/tmp/devdnsd-test-log-#{Time.now.strftime("%Y%m%d-%H%M%S")}" }
-  let(:application){ create_application({"log_file" => log_file}) }
+  let(:application){ create_application({"log_file" => log_file, "configuration" => "/dev/null"}) }
   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")}" }
@@ -37,7 +38,7 @@ describe DevDNSd::Application do
 
     it "should fallback logger to STDOUT" do
       allow_any_instance_of(DevDNSd::Application).to receive(:read_configuration)
-      expect(Bovem::Logger).to receive(:create).with($stdout, Logger::INFO)
+      expect(Bovem::Logger).to receive(:create).with($stdout, level: Logger::INFO)
       create_application({"log_file" => "/invalid/logger"})
     end
 
@@ -53,14 +54,16 @@ describe DevDNSd::Application do
       file.write("config.port = ")
       file.close
 
-      expect { create_application({"configuration" => file.path, "log_file" => log_file}) }.to raise_error(::SystemExit)
+      expect_any_instance_of(DevDNSd::Application).to receive(:shutdown).and_call_original
+      create_application({"configuration" => file.path, "log_file" => log_file})
       ::File.unlink(path)
     end
 
     it "should abort when the log file is invalid" do
       allow_any_instance_of(Bovem::Logger).to receive(:fatal)
       allow_any_instance_of(Bovem::Logger).to receive(:warn)
-      expect { create_application({"pid_file" => "/invalid/pid", "log_file" => log_file}) }.to raise_error(::SystemExit)
+      expect_any_instance_of(DevDNSd::Application).to receive(:shutdown).and_call_original
+      create_application({"pid_file" => "/invalid/pid", "log_file" => "/dev/null"})
     end
   end
 
@@ -73,13 +76,13 @@ describe DevDNSd::Application do
 
   describe ".quit" do
     it "should quit the application" do
-      allow(EM).to receive(:add_timer).and_yield
-      expect(EM).to receive(:stop)
+      allow(application).to receive(:instance).and_call_original
       DevDNSd::Application.quit
     end
 
-    it "should not blow up in case of errors" do
-      allow(EM).to receive(:add_timer).and_raise(RuntimeError)
+    it "should return with error code 1 in case of errors" do
+      allow(application).to receive(:shutdown).and_raise(RuntimeError)
+      expect(Kernel).to receive(:exit).with(1)
       expect { DevDNSd::Application.quit }.not_to raise_error
     end
   end
@@ -126,153 +129,138 @@ describe DevDNSd::Application do
     end
   end
 
-  describe ".process_file_path" do
+  describe "#process_file_path" do
     let(:application){ create_application({"log_file" => log_file, "configuration" => sample_config}) }
 
     it "returns the default file" do
-      expect(DevDNSd::Application.process_file_path).to eq("/var/run/devdnsd.pid")
+      expect(DevDNSd::Application.instance.process_file_path).to eq("/var/run/devdnsd.pid")
     end
 
     it "return the set file" do
       DevDNSd::Application.instance.config.pid_file = "/this/is/a/daemon.pid"
-      expect(DevDNSd::Application.process_file_path).to eq("/this/is/a/daemon.pid")
+      expect(DevDNSd::Application.instance.process_file_path).to eq("/this/is/a/daemon.pid")
     end
   end
 
-  describe ".log_file_path" do
+  describe "#log_file_path" do
     let(:application){ create_application({"log_file" => log_file, "configuration" => sample_config}) }
 
     it "returns the default file" do
-      expect(DevDNSd::Application.log_file_path).to eq(log_file)
+      expect(DevDNSd::Application.instance.log_file_path).to eq(log_file)
     end
 
     it "return the set file" do
       DevDNSd::Application.instance.config.log_file = "/this/is/a/daemon.log"
-      expect(DevDNSd::Application.log_file_path).to eq("/this/is/a/daemon.log")
+      expect(DevDNSd::Application.instance.log_file_path).to eq("/this/is/a/daemon.log")
     end
   end
 
-  describe ".working_directory" do
+  describe "#working_directory" do
     let(:application){ create_application({"log_file" => log_file, "configuration" => sample_config}) }
 
     it "returns the default path" do
-      expect(DevDNSd::Application.working_directory).to eq("/var/run")
+      expect(DevDNSd::Application.instance.working_directory).to eq("/var/run")
     end
 
     it "return the set path basing on the PID file" do
       DevDNSd::Application.instance.config.pid_file = "/this/is/a/daemon.pid"
-      expect(DevDNSd::Application.working_directory).to eq("/this/is/a")
+      expect(DevDNSd::Application.instance.working_directory).to eq("/this/is/a")
     end
   end
 
-  describe ".log_directory" do
+  describe "#log_directory" do
     let(:application){ create_application({"log_file" => log_file, "configuration" => sample_config}) }
 
     it "returns the default path" do
-      expect(DevDNSd::Application.log_directory).to eq(File.dirname(log_file))
+      expect(DevDNSd::Application.instance.log_directory).to eq(File.dirname(log_file))
     end
 
     it "return the set path basing on the PID file" do
       DevDNSd::Application.instance.config.log_file = "/this/is/a/daemon.log"
-      expect(DevDNSd::Application.log_directory).to eq("/this/is/a")
+      expect(DevDNSd::Application.instance.log_directory).to eq("/this/is/a")
     end
   end
 
-  describe ".daemon_name" do
+  describe "#daemon_name" do
     let(:application){ create_application({"log_file" => log_file, "configuration" => sample_config}) }
 
     it "returns the default name" do
-      expect(DevDNSd::Application.daemon_name).to eq("devdnsd")
+      expect(DevDNSd::Application.instance.daemon_name).to eq("devdnsd")
     end
 
     it "return the set name basing on the PID file" do
       DevDNSd::Application.instance.config.pid_file = "/this/is/a/daemon.pid"
-      expect(DevDNSd::Application.daemon_name).to eq("daemon")
+      expect(DevDNSd::Application.instance.daemon_name).to eq("daemon")
     end
   end
 
   describe "#perform_server" do
-    let(:application){ create_application({"log_file" => log_file, "configuration" => sample_config, "port" => 60771}) }
-
-    def test_resolve(host = "match_1.dev", type = "ANY", nameserver = "127.0.0.1", port = 60771, logger = nil)
-      result = nil
-
-      EM.run do
-        EM.add_timer(0.01) { application.perform_server }
-        EM.add_timer(0.1) {
-          Fiber.new {
-            result = devdnsd_resolv(host, type, nameserver, port, logger)
-            EM.stop
-          }.resume
-        }
-      end
-
-      result
-    end
+    let(:application) { create_application({"log_file" => log_file, "configuration" => sample_config, "port" => 60771}) }
 
-    it "should run the server" do
-      expect(RubyDNS).to receive(:run_server)
+    it "should free resources correctly" do
       application.perform_server
+      application.shutdown
+      application.perform_server
+      application.shutdown
     end
 
     it "should setup callbacks" do
       expect_any_instance_of(RubyDNS::RuleBasedServer).to receive(:on).with(:start)
       expect_any_instance_of(RubyDNS::RuleBasedServer).to receive(:on).with(:stop)
-
-      EM.run do
-        EM.add_timer(0.01) { application.perform_server }
-        EM.add_timer(0.2) { DevDNSd::Application.quit }
-      end
-    end
-
-    it "should iterate the rules" do
-      test_resolve do
-        expect(application.config.rules).to receive(:each).at_least(1)
-        application.perform_server
-      end
-    end
-
-    it "should call process_rule" do
-      test_resolve do
-        expect(application).to receive(:process_rule).at_least(1)
-        application.perform_server
-      end
+      application.perform_server
+      application.shutdown
     end
 
-    it "should complain about wrong rules" do
-      test_resolve do
-        allow(application).to receive(:process_rule).and_raise(::Exception)
-        expect { application.perform_server }.to raise_exception
+    describe "using rules" do
+      def test_resolve(host = "match_1.dev", type = "ANY", nameserver = "127.0.0.1", port = 60771, logger = nil)
+        devdnsd_resolv(host, type, nameserver, port, logger)
       end
-    end
 
-    describe "should correctly resolve hostnames" do
-      it "basing on a exact pattern" do
-        expect(test_resolve("match_1.dev")).to eq(["10.0.1.1", :A])
-        expect(test_resolve("match_2.dev")).to eq(["10.0.2.1", :MX])
-        expect(test_resolve("match_3.dev")).to eq(["10.0.3.1", :A])
-        expect(test_resolve("match_4.dev")).to eq(["cowtech.it", :CNAME])
+      around(:each) do |example|
+        app = application
+        app.perform_server
+        example.call
+        app.shutdown
       end
 
-      it "basing on a regexp pattern" do
-        expect(test_resolve("match_5_11.dev")).to eq(["ns.cowtech.it", :NS])
-        expect(test_resolve("match_5_22.dev")).to eq(["ns.cowtech.it", :NS])
-        expect(test_resolve("match_6_33.dev")).to eq(["10.0.6.33", :PTR])
-        expect(test_resolve("match_6_44.dev")).to eq(["10.0.6.44", :PTR])
-        expect(test_resolve("match_7_55.dev")).to eq(["10.0.7.55", :A])
-        expect(test_resolve("match_7_66.dev")).to eq(["10.0.7.66", :A])
-        expect(test_resolve("match_8_77.dev")).to eq(["10.0.8.77", :PTR])
-        expect(test_resolve("match_8_88.dev")).to eq(["10.0.8.88", :PTR])
+      it "should iterate the rules" do
+        expect(application.config.rules).to receive(:each).at_least(1)
+        test_resolve
       end
 
-      it "and return multiple or only relevant answsers" do
-        expect(test_resolve("match_10.dev")).to eq([["10.0.10.1", :A], ["10.0.10.2", :MX]])
-        expect(test_resolve("match_10.dev", "MX")).to eq(["10.0.10.2", :MX])
+      it "should call process_rule" do
+        expect_any_instance_of(DevDNSd::Application).to receive(:process_rule).at_least(1)
+        test_resolve
       end
 
-      it "and reject invalid matches (with or without rules)" do
-        expect(test_resolve("match_9.dev")).to eq([])
-        expect(test_resolve("invalid.dev")).to eq([])
+      describe "should correctly resolve hostnames" do
+        it "basing on a exact pattern" do
+          expect(test_resolve("match_1.dev")).to eq(["10.0.1.1", :A])
+          expect(test_resolve("match_2.dev")).to eq(["10.0.2.1", :MX])
+          expect(test_resolve("match_3.dev")).to eq(["10.0.3.1", :A])
+          expect(test_resolve("match_4.dev")).to eq(["cowtech.it", :CNAME])
+        end
+
+        it "basing on a regexp pattern" do
+          expect(test_resolve("match_5_11.dev")).to eq(["ns.cowtech.it", :NS])
+          expect(test_resolve("match_5_22.dev")).to eq(["ns.cowtech.it", :NS])
+          expect(test_resolve("match_6_33.dev")).to eq(["10.0.6.33", :PTR])
+          expect(test_resolve("match_6_44.dev")).to eq(["10.0.6.44", :PTR])
+          expect(test_resolve("match_7_55.dev")).to eq(["10.0.7.55", :A])
+          expect(test_resolve("match_7_66.dev")).to eq(["10.0.7.66", :A])
+          expect(test_resolve("match_8_77.dev")).to eq(["10.0.8.77", :PTR])
+          expect(test_resolve("match_8_88.dev")).to eq(["10.0.8.88", :PTR])
+        end
+
+        it "and return multiple or only relevant answsers" do
+          expect(test_resolve("match_10.dev")).to eq([["10.0.10.1", :A], ["10.0.10.2", :MX]])
+          expect(test_resolve("match_10.dev", "MX")).to eq(["10.0.10.2", :MX])
+        end
+
+        it "and reject invalid matches (with or without rules)" do
+          expect(test_resolve("match_9.dev")).to eq([])
+          expect(test_resolve("invalid.dev")).to eq([])
+        end
       end
     end
   end
@@ -295,51 +283,51 @@ describe DevDNSd::Application do
 
     it "should match a valid string request" do
       rule = application.config.rules[0]
-      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_truthy
     end
 
     it "should match a valid string request with specific type" do
       rule = application.config.rules[1]
-      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_truthy
     end
 
     it "should match a valid string request with a block" do
       rule = application.config.rules[2]
-      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_truthy
     end
 
     it "should match a valid string request with a block" do
       rule = application.config.rules[3]
-      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_truthy
     end
 
     it "should match a valid regexp request" do
       rule = application.config.rules[4]
       mo = rule.match_host("match_5_12.dev")
-      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_truthy
     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")
-      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_truthy
     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")
-      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_truthy
     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")
-      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_true
+      expect(application.process_rule(rule, rule.resource_class, mo, transaction)).to be_truthy
     end
 
     it "should return false for a false block" do
       rule = application.config.rules[8]
-      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_false
+      expect(application.process_rule(rule, rule.resource_class, nil, transaction)).to be_falsey
     end
 
     it "should return nil for a nil reply" do
@@ -356,12 +344,12 @@ describe DevDNSd::Application do
     end
   end
 
-  describe "#is_osx?" do
+  describe "#osx?" do
     it "should return the correct information" do
       stub_const("RbConfig::CONFIG", {"host_os" => "darwin foo"})
-      expect(application.is_osx?).to be_true
+      expect(application.osx?).to be_truthy
       stub_const("RbConfig::CONFIG", {"host_os" => "another"})
-      expect(application.is_osx?).to be_false
+      expect(application.osx?).to be_falsey
     end
   end
 
@@ -387,22 +375,22 @@ describe DevDNSd::Application do
 
   describe "#manage_aliases" do
     it "should override configuration" do
-      allow(application).to receive(:manage_address)
+      expect_any_instance_of(DevDNSd::Application).to receive(:manage_address)
       application.manage_aliases(:add, "MESSAGE", {aliases: 10})
       expect(application.config.aliases).to eq(10)
     end
 
     it "should log an error if no interfaces are found" do
-      allow(application).to receive(:compute_addresses).and_return([])
+      expect_any_instance_of(DevDNSd::Application).to receive(:compute_addresses).and_return([])
       expect(application.logger).to receive(:error).with("MESSAGE")
-      expect(application.manage_aliases(:add, "MESSAGE", {aliases: 10})).to be_false
+      expect(application.manage_aliases(:add, "MESSAGE", {aliases: 10})).to be_falsey
     end
 
     it "should call #manage_address for each address" do
-      expect(application).to receive(:manage_address).with("OPERATION", IPAddr.new("10.0.0.1"), "DRY_RUN").and_return(true)
-      expect(application).to receive(:manage_address).with("OPERATION", IPAddr.new("10.0.0.2"), "DRY_RUN").and_return(true)
-      expect(application).to receive(:manage_address).with("OPERATION", IPAddr.new("10.0.0.3"), "DRY_RUN").and_return(true)
-      expect(application.manage_aliases("OPERATION", "MESSAGE", {aliases: 3, dry_run: "DRY_RUN"})).to be_true
+      expect_any_instance_of(DevDNSd::Application).to receive(:manage_address).with("OPERATION", IPAddr.new("10.0.0.1"), "DRY_RUN").and_return(true)
+      expect_any_instance_of(DevDNSd::Application).to receive(:manage_address).with("OPERATION", IPAddr.new("10.0.0.2"), "DRY_RUN").and_return(true)
+      expect_any_instance_of(DevDNSd::Application).to receive(:manage_address).with("OPERATION", IPAddr.new("10.0.0.3"), "DRY_RUN").and_return(true)
+      expect(application.manage_aliases("OPERATION", "MESSAGE", {aliases: 3, dry_run: "DRY_RUN"})).to be_truthy
     end
   end
 
@@ -416,24 +404,24 @@ describe DevDNSd::Application do
     end
 
     it "should call the right system command" do
-      expect(application).to receive(:execute_command).with("sudo ifconfig lo0 alias 10.0.0.3 > /dev/null 2>&1")
+      expect_any_instance_of(DevDNSd::Application).to receive(:execute_command).with("sudo ifconfig lo0 alias 10.0.0.3 > /dev/null 2>&1")
       application.manage_address(:add, "10.0.0.3")
 
-      expect(application).to receive(:execute_command).with("sudo ifconfig lo0 -alias 10.0.0.3 > /dev/null 2>&1")
+      expect_any_instance_of(DevDNSd::Application).to receive(:execute_command).with("sudo ifconfig lo0 -alias 10.0.0.3 > /dev/null 2>&1")
       application.manage_address(:remove, "10.0.0.3")
     end
 
     it "should return true if the command succeded" do
       application.config.add_command = "echo {{interface}}"
-      expect(application.manage_address(:add, "10.0.0.3")).to be_true
+      expect(application.manage_address(:add, "10.0.0.3")).to be_truthy
     end
 
     it "should return false if the command failed" do
-      expect(application.manage_address(:add, "10.0.0.256")).to be_false
+      expect(application.manage_address(:add, "10.0.0.256")).to be_falsey
     end
 
     it "should respect dry-run mode" do
-      expect(application).not_to receive(:execute_command)
+      expect_any_instance_of(DevDNSd::Application).not_to receive(:execute_command)
       expect(application.logger).to receive(:info).with(/.+.*3.*\/.*5.*.+ I will .*add.* address .*10.0.0.3.* to interface .*lo0.*/)
       expect(application.logger).to receive(:info).with(/.+.*3.*\/.*5.*.+ I will .*remove.* address .*10.0.0.3.* from interface .*lo0.*/)
 
@@ -491,39 +479,39 @@ describe DevDNSd::Application do
     end
   end
 
-  describe "#is_ipv4?" do
+  describe "#ipv4?" do
     it "correctly detects valid IPv4 address" do
-      expect(application.is_ipv4?("10.0.0.1")).to be_true
-      expect(application.is_ipv4?("255.0.0.1")).to be_true
-      expect(application.is_ipv4?("192.168.0.1")).to be_true
+      expect(application.ipv4?("10.0.0.1")).to be_truthy
+      expect(application.ipv4?("255.0.0.1")).to be_truthy
+      expect(application.ipv4?("192.168.0.1")).to be_truthy
     end
 
     it "rejects other values" do
-      expect(application.is_ipv4?("10.0.0.256")).to be_false
-      expect(application.is_ipv4?("10.0.0.-1")).to be_false
-      expect(application.is_ipv4?("::1")).to be_false
-      expect(application.is_ipv4?("INVALID")).to be_false
-      expect(application.is_ipv4?(nil)).to be_false
+      expect(application.ipv4?("10.0.0.256")).to be_falsey
+      expect(application.ipv4?("10.0.0.-1")).to be_falsey
+      expect(application.ipv4?("::1")).to be_falsey
+      expect(application.ipv4?("INVALID")).to be_falsey
+      expect(application.ipv4?(nil)).to be_falsey
     end
   end
 
-  describe "#is_ipv6?" do
+  describe "#ipv6?" do
     it "correctly detects valid IPv4 address" do
-      expect(application.is_ipv6?("2001:0db8:0000:0000:0000:1428:57ab")).to be_true
-      expect(application.is_ipv6?("2001:0db8:0:000:00:1428:57ab")).to be_true
-      expect(application.is_ipv6?("2001:0db8:0::1428:57ab")).to be_true
-      expect(application.is_ipv6?("2001::")).to be_true
-      expect(application.is_ipv6?("::1")).to be_true
-      expect(application.is_ipv6?("::2:1")).to be_true
-      expect(application.is_ipv6?("2011::10.0.0.1")).to be_true
-      expect(application.is_ipv6?("2011::0:10.0.0.1")).to be_true
+      expect(application.ipv6?("2001:0db8:0000:0000:0000:1428:57ab")).to be_truthy
+      expect(application.ipv6?("2001:0db8:0:000:00:1428:57ab")).to be_truthy
+      expect(application.ipv6?("2001:0db8:0::1428:57ab")).to be_truthy
+      expect(application.ipv6?("2001::")).to be_truthy
+      expect(application.ipv6?("::1")).to be_truthy
+      expect(application.ipv6?("::2:1")).to be_truthy
+      expect(application.ipv6?("2011::10.0.0.1")).to be_truthy
+      expect(application.ipv6?("2011::0:10.0.0.1")).to be_truthy
     end
 
     it "rejects other values" do
-      expect(application.is_ipv6?("::H")).to be_false
-      expect(application.is_ipv6?("192.168.0.256")).to be_false
-      expect(application.is_ipv6?("INVALID")).to be_false
-      expect(application.is_ipv6?(nil)).to be_false
+      expect(application.ipv6?("::H")).to be_falsey
+      expect(application.ipv6?("192.168.0.256")).to be_falsey
+      expect(application.ipv6?("INVALID")).to be_falsey
+      expect(application.ipv6?(nil)).to be_falsey
     end
   end
 
@@ -534,7 +522,7 @@ describe DevDNSd::Application do
         option :foreground, [:n, "foreground"], {default: true}
       })
 
-      expect(application).to receive(:perform_server)
+      allow_any_instance_of(DevDNSd::Application).to receive(:perform_server)
       application.action_start
     end
 
@@ -544,7 +532,7 @@ describe DevDNSd::Application do
         option :foreground, [:n, "foreground"], {default: false}
       })
 
-      expect(::RExec::Daemon::Controller).to receive(:start)
+      expect(::DevDNSd::Application).to receive(:start)
       application.action_start
     end
 
@@ -552,48 +540,48 @@ describe DevDNSd::Application do
       application.config.foreground = false
 
       allow(Process).to receive(:respond_to?).and_return(false)
-      expect(application).to receive(:perform_server)
+      allow_any_instance_of(DevDNSd::Application).to receive(:perform_server)
       expect(application.logger).to receive(:warn)
 
       application.action_start
-      expect(application.config.foreground).to be_true
+      expect(application.config.foreground).to be_truthy
     end
   end
 
   describe "#action_stop" do
     it "should stop the daemon" do
-      expect(::RExec::Daemon::Controller).to receive(:stop)
+      expect(::DevDNSd::Application).to receive(:stop)
       application.action_stop
     end
   end
 
   describe "#action_restart" do
     it "should stop and restart the server" do
-      expect(application).to receive(:action_stop)
-      expect(application).to receive(:action_start)
+      expect_any_instance_of(DevDNSd::Application).to receive(:action_stop)
+      expect_any_instance_of(DevDNSd::Application).to receive(:action_start)
       application.action_restart
     end
   end
 
   describe "#action_status" do
     it "should get the status of the daemon when running" do
-      expect(RExec::Daemon::ProcessFile).to receive(:status).and_return(:running)
-      expect(RExec::Daemon::ProcessFile).to receive(:recall).and_return(123)
+      expect(Process::Daemon::ProcessFile).to receive(:status).and_return(:running)
+      expect(DevDNSd::Application.controller).to receive(:pid).and_return(123)
 
-      expect(application.logger).to receive(:info).with("The server is running with process ID 123.")
+      expect(application.logger).to receive(:info).with("The server is running with process ID \e[1m123\e[0m.")
       application.action_status
     end
 
     it "should get the status of the daemon when stopped" do
-      expect(RExec::Daemon::ProcessFile).to receive(:status).and_return(:stopped)
-      expect(RExec::Daemon::ProcessFile).to receive(:recall).and_return(123)
+      expect(Process::Daemon::ProcessFile).to receive(:status).and_return(:stopped)
+      expect(DevDNSd::Application.controller).to receive(:pid).and_return(123)
 
       expect(application.logger).to receive(:info).with("The server is stopped.")
       application.action_status
     end
 
     it "should get the status of the daemon when crashed" do
-      expect(RExec::Daemon::ProcessFile).to receive(:status).and_return(:unknown)
+      expect(Process::Daemon::ProcessFile).to receive(:status).and_return(:unknown)
       expect(application.class).to receive(:crashed?).and_return(true)
 
       expect(application.logger).to receive(:info).with("The server crashed. See the log for more information.")
@@ -601,7 +589,7 @@ describe DevDNSd::Application do
     end
 
     it "should get the status of the daemon when unknown" do
-      expect(RExec::Daemon::ProcessFile).to receive(:status).and_return(:unknown)
+      expect(Process::Daemon::ProcessFile).to receive(:status).and_return(:unknown)
       expect(application.class).to receive(:crashed?).and_return(false)
 
       expect(application.logger).to receive(:info).with("The server status is unknown.")
@@ -611,46 +599,46 @@ describe DevDNSd::Application do
 
   describe "#action_install" do
     before(:each) do
-      allow(application).to receive(:is_osx?).and_return(true)
+      allow(application).to receive(:osx?).and_return(true)
       allow(application).to receive(:execute_command)
       expect(Kernel).to receive(:system).at_least(1)
     end
 
     it "should create the resolver" do
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
-      allow(application).to receive(:launch_agent_path).and_return(launch_agent_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
-      allow(application).to receive(:create_resolver) {|_, path| FileUtils.touch(path) }
+      allow_any_instance_of(DevDNSd::Application).to receive(:create_resolver) {|_, path| FileUtils.touch(path) }
       application.action_install
-      expect(::File.exists?(resolver_path)).to be_true
+      expect(::File.exists?(resolver_path)).to be_truthy
 
       ::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
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
-      allow(application).to receive(:launch_agent_path).and_return(launch_agent_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
       application.action_install
-      expect(::File.exists?(application.launch_agent_path)).to be_true
+      expect(::File.exists?(application.launch_agent_path)).to be_truthy
 
       ::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
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
-      allow(application).to receive(:launch_agent_path).and_return(launch_agent_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
-      expect(application).to receive(:dns_update)
+      expect_any_instance_of(DevDNSd::Application).to receive(:dns_update)
       application.action_install
 
       ::File.unlink(application.resolver_path) if ::File.exists?(application.resolver_path)
@@ -658,13 +646,13 @@ describe DevDNSd::Application do
     end
 
     it "should not create an invalid resolver" do
-      allow(application).to receive(:resolver_path).and_return("/invalid/resolver")
-      allow(application).to receive(:launch_agent_path).and_return("/invalid/agent")
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return("/invalid/resolver")
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
-      allow(application).to receive(:create_agent).and_return(true)
-      expect_any_instance_of(R18n::Translation).to receive(:resolver_creating).and_raise(ArgumentError)
+      allow_any_instance_of(DevDNSd::Application).to receive(:create_agent).and_return(true)
+      expect_any_instance_of(Bovem::I18n).to receive(:resolver_creating).and_raise(ArgumentError)
       expect(application.logger).to receive(:error).with("Cannot create the resolver file.")
       application.action_install
 
@@ -673,8 +661,8 @@ describe DevDNSd::Application do
     end
 
     it "should not create an invalid agent" do
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
-      allow(application).to receive(:launch_agent_path).and_return("/invalid/agent")
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
@@ -690,11 +678,12 @@ describe DevDNSd::Application do
         command =~ /^launchctl/ ? raise(StandardError) : true
       end
 
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
-      allow(application).to receive(:launch_agent_path).and_return(launch_agent_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
+      allow_any_instance_of(DevDNSd::Application).to receive(:create_agent).and_return(true)
       expect(application.logger).to receive(:error).with("Cannot load the launch agent.")
       application.action_install
 
@@ -703,41 +692,41 @@ describe DevDNSd::Application do
     end
 
     it "should raise an exception if not running on OSX" do
-      allow(application).to receive(:is_osx?).and_return(false)
+      allow_any_instance_of(DevDNSd::Application).to receive(:osx?).and_return(false)
       expect(application.logger).to receive(:fatal).with("Install DevDNSd as a local resolver is only available on MacOSX.")
-      expect(application.action_install).to be_false
+      expect(application.action_install).to be_falsey
     end
   end
 
   describe "#action_uninstall" do
     before(:each) do
-      allow(application).to receive(:is_osx?).and_return(true)
+      allow(application).to receive(:osx?).and_return(true)
       allow(application).to receive(:execute_command)
       expect(Kernel).to receive(:system).at_least(1)
     end
 
     it "should remove the resolver" do
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
-      allow(application).to receive(:launch_agent_path).and_return(launch_agent_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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
-      expect(::File.exists?(resolver_path)).to be_false
+      expect(::File.exists?(resolver_path)).to be_falsey
 
       ::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 remove an invalid resolver" do
-      allow(application).to receive(:resolver_path).and_return("/invalid/resolver")
-      allow(application).to receive(:launch_agent_path).and_return("/invalid/agent")
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return("/invalid/resolver")
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
       allow(application).to receive(:unload_agent).and_return(true)
-      expect_any_instance_of(R18n::Translation).to receive(:resolver_deleting).and_raise(ArgumentError)
+      expect_any_instance_of(Bovem::I18n).to receive(:resolver_deleting).and_raise(ArgumentError)
       expect(application.logger).to receive(:warn)
       expect(application.logger).to receive(:warn).with("Cannot delete the resolver file.")
 
@@ -748,15 +737,30 @@ describe DevDNSd::Application do
     end
 
     it "should remove the agent" do
-      allow(application).to receive(:resolver_path).and_return(resolver_path)
-      allow(application).to receive(:launch_agent_path).and_return(launch_agent_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
+
+      allow(Bovem::Logger).to receive(:default_file).and_return($stdout)
+      application.action_install
+      application.action_uninstall
+      expect(::File.exists?(application.launch_agent_path)).to be_falsey
+
+      ::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 fail if the agent cannot be removed" do
+      allow_any_instance_of(DevDNSd::Application).to receive(:resolver_path).and_return(resolver_path)
+      allow_any_instance_of(DevDNSd::Application).to receive(: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)
 
+      allow(File).to receive(:delete).and_raise(RuntimeError)
       allow(Bovem::Logger).to receive(:default_file).and_return($stdout)
       application.action_install
       application.action_uninstall
-      expect(::File.exists?(application.launch_agent_path)).to 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)
@@ -807,7 +811,7 @@ describe DevDNSd::Application do
       ::File.unlink(application.launch_agent_path) if ::File.exists?(application.launch_agent_path)
 
       application.action_install
-      expect(application).to receive(:dns_update)
+      expect_any_instance_of(DevDNSd::Application).to receive(:dns_update)
       application.action_uninstall
 
       ::File.unlink(application.resolver_path) if ::File.exists?(application.resolver_path)
@@ -815,22 +819,22 @@ describe DevDNSd::Application do
     end
 
     it "should raise an exception if not running on OSX" do
-      allow(application).to receive(:is_osx?).and_return(false)
+      allow_any_instance_of(DevDNSd::Application).to receive(:osx?).and_return(false)
       expect(application.logger).to receive(:fatal).with("Install DevDNSd as a local resolver is only available on MacOSX.")
-      expect(application.action_uninstall).to be_false
+      expect(application.action_uninstall).to be_falsey
     end
   end
 
   describe "#action_add" do
     it "should #manage_aliases" do
-      expect(application).to receive(:manage_aliases).with(:add, "No valid addresses to add to the interface found.", {a: 1})
+      expect_any_instance_of(DevDNSd::Application).to receive(:manage_aliases).with(:add, "No valid addresses to add to the interface found.", {a: 1})
       application.action_add({a: 1})
     end
   end
 
   describe "#action_remove" do
     it "should #manage_aliases" do
-      expect(application).to receive(:manage_aliases).with(:remove, "No valid addresses to remove from the interface found.", {a: 1})
+      expect_any_instance_of(DevDNSd::Application).to receive(:manage_aliases).with(:remove, "No valid addresses to remove from the interface found.", {a: 1})
       application.action_remove({a: 1})
     end
   end