invoker 1.0.4 → 1.1.0

data/spec/invoker/config_spec.rb

@@ -146,4 +146,25 @@ web: bundle exec rails s -p $PORT
       end
     end
   end
+
+  describe "Copy of DNS information" do
+    it "should allow copy of DNS information" do
+      begin
+        File.open("/tmp/Procfile", "w") {|fl| 
+          fl.write <<-EOD
+web: bundle exec rails s -p $PORT
+          EOD
+        }
+        Invoker.load_invoker_config("/tmp/Procfile", 9000)
+        dns_cache = Invoker::DNSCache.new(Invoker.config)
+
+        expect(dns_cache.dns_data).to_not be_empty
+        expect(dns_cache.dns_data['web']).to_not be_empty
+        expect(dns_cache.dns_data['web']['port']).to eql 9001
+      ensure
+        File.delete("/tmp/Procfile")
+      end
+    end
+  end
+
 end

data/spec/invoker/daemon_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Invoker::Daemon do
+  let(:daemon) { Invoker::Daemon.new}
+
+  describe "#start" do
+    context "when daemon is aleady running" do
+      it "exits without any error" do
+        daemon.expects(:running?).returns(true)
+        begin
+          daemon.start
+        rescue SystemExit => e
+          expect(e.status).to be(0)
+        end
+      end
+    end
+
+    context "when daemon is not running" do
+      it "starts the daemon" do
+        daemon.expects(:dead?).returns(false)
+        daemon.expects(:running?).returns(false)
+        daemon.expects(:daemonize)
+        daemon.start
+      end
+    end
+  end
+
+  describe "#stop" do
+    it "stops the daemon" do
+      daemon.expects(:kill_process)
+      daemon.stop
+    end
+  end
+end

data/spec/invoker/invoker_spec.rb

@@ -49,5 +49,36 @@ describe "Invoker" do
       Invoker.can_run_balancer?(false)
     end
   end
+
+  describe "#setup_config_location" do
+    before do
+      Dir.stubs(:home).returns('/tmp')
+      @config_location = File.join('/tmp', '.invoker')
+      FileUtils.rm_rf(@config_location)
+    end
+
+    context "when the old config file does not exist" do
+      it "creates the new config directory" do
+        Invoker.setup_config_location
+        expect(Dir.exist?(@config_location)).to be_true
+      end
+    end
+
+    context "when the old config file exists" do
+      before do
+        File.open(@config_location, 'w') do |file|
+          file.write('invoker config')
+        end
+      end
+
+      it "moves the file to the new directory" do
+        Invoker.setup_config_location
+        expect(Dir.exist?(@config_location)).to be_true
+        new_config_file = File.join(@config_location, 'config')
+        expect(File.exist?(new_config_file)).to be_true
+        expect(File.read(new_config_file)).to match('invoker config')
+      end
+    end
+  end
 end
 

data/spec/invoker/ipc/client_handler_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Invoker::IPC::ClientHandler do
+  let(:client_socket) { StringIO.new }
+  let(:client) { Invoker::IPC::ClientHandler.new(client_socket) }
+
+  describe "add command" do
+    let(:message_object) { MM::Add.new(process_name: 'foo') }
+    it "should run if read from socket" do
+      invoker_commander.expects(:on_next_tick).with("foo")
+      client_socket.string = message_object.encoded_message
+
+      client.read_and_execute
+    end
+  end
+
+  describe "remove command" do
+    it "with specific signal" do
+      message_object = MM::Remove.new(process_name: 'foo', signal: 'INT')
+      invoker_commander.expects(:on_next_tick)
+      client_socket.string = message_object.encoded_message
+
+      client.read_and_execute
+    end
+
+    it "with default signal" do
+      message_object = MM::Remove.new(process_name: 'foo')
+      invoker_commander.expects(:on_next_tick)
+      client_socket.string = message_object.encoded_message
+
+      client.read_and_execute
+    end
+  end
+
+  describe "add_http command" do
+    let(:message_object) { MM::AddHttp.new(process_name: 'foo', port: 9000)}
+    it "adds the process name and port to dns cache" do
+      invoker_dns_cache.expects(:add).with('foo', 9000)
+      client_socket.string = message_object.encoded_message
+
+     client.read_and_execute
+    end
+  end
+end

data/spec/invoker/ipc/dns_check_command_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Invoker::IPC::DnsCheckCommand do
+  let(:client_socket) { StringIO.new }
+  let(:client) { Invoker::IPC::ClientHandler.new(client_socket) }
+
+  describe "dns check for valid process" do
+    let(:message_object) { MM::DnsCheck.new(process_name: 'lolbro') }
+    it "should response with dns check response" do
+      invoker_dns_cache.expects(:[]).returns('port' => 9000)
+      client_socket.string = message_object.encoded_message
+
+      client.read_and_execute
+
+      dns_check_response = client_socket.string
+      expect(dns_check_response).to match(/9000/)
+    end
+  end
+
+  describe "dns check for invalid process" do
+    let(:message_object) { MM::DnsCheck.new(process_name: 'foo') }
+    it "should response with dns check response" do
+      invoker_dns_cache.expects(:[]).returns('port' => nil)
+      client_socket.string = message_object.encoded_message
+
+      client.read_and_execute
+
+      dns_check_response = client_socket.string
+      expect(dns_check_response).to match(/null/)
+    end
+  end
+end

data/spec/invoker/ipc/message/list_response_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe MM::ListResponse do
+  context "serializing a response" do
+    let(:process_array) do
+      [
+        { shell_command: 'foo', process_name: 'foo', dir: '/tmp', pid: 100 },
+        { shell_command: 'bar', process_name: 'bar', dir: '/tmp', pid: 200 }
+      ]
+    end
+
+    let(:message) { MM::ListResponse.new(processes: process_array) }
+
+    it "should prepare proper json" do
+      json_hash = message.as_json
+      expect(json_hash[:type]).to eql "list_response"
+      expect(json_hash[:processes]).to have(2).elements
+      expect(json_hash[:processes][0]).to be_a(Hash)
+      expect(json_hash[:processes][1]).to be_a(Hash)
+    end
+  end
+end

data/spec/invoker/ipc/message_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Invoker::IPC::Message do
+  describe "test equality of objects" do
+    context "for simple messages" do
+      let(:message) { MM::Add.new(process_name: 'foo') }
+
+      it "object should be reported same if same value" do
+        m2 = MM::Add.new(process_name: 'foo')
+        expect(message).to eql m2
+      end
+
+      it "should report objects to be not eql if differnt value" do
+        m2 = MM::Add.new(process_name: 'bar')
+        expect(message).to_not eql m2
+      end
+    end
+
+    context "for nested messages" do
+      let(:process_array) do
+        [
+          { shell_command: 'foo', process_name: 'foo', dir: '/tmp', pid: 100 },
+          { shell_command: 'bar', process_name: 'bar', dir: '/tmp', pid: 200 }
+        ]
+      end
+
+      let(:message) { MM::ListResponse.new(processes: process_array) }
+
+      it "should report eql for eql objects" do
+        m2 = MM::ListResponse.new(processes: process_array)
+        expect(message).to eql m2
+      end
+
+      it "should report not equal for different objects" do
+        another_process_array = [
+          { shell_command: 'baz', process_name: 'foo', dir: '/tmp', pid: 100 },
+          { shell_command: 'bar', process_name: 'bar', dir: '/tmp', pid: 200 }
+        ]
+
+        m2 = MM::ListResponse.new(processes: another_process_array)
+        expect(message).to_not eql m2
+      end
+    end
+  end
+end

data/spec/invoker/ipc/unix_client_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Invoker::IPC::UnixClient do
+  let(:unix_client) { described_class.new }
+  let(:socket) { StringIO.new }
+
+  describe "serializing a " do
+    it "list request should work" do
+      unix_client.expects(:open_client_socket).yields(socket)
+      unix_client.send_command("list")
+
+      expect(socket.string).to match(/list/)
+    end
+
+    it "add request should work" do
+      unix_client.expects(:open_client_socket).yields(socket)
+      unix_client.send_command("add", process_name: "hello")
+
+      expect(socket.string).to match(/hello/)
+    end
+  end
+
+  describe ".send_command" do
+    it "calls the send_command instance method" do
+      Invoker::IPC::UnixClient.any_instance.expects(:send_command).once
+      Invoker::IPC::UnixClient.send_command("list")
+    end
+  end
+end

data/spec/invoker/power/setup_spec.rb

@@ -72,7 +72,7 @@ describe "Setup" do
     it "should uninstall firewall rules and remove all files created by setup" do
       setup = Invoker::Power::Setup.new
 
-      HighLine.any_instance.expects(:agree).returns(true)
+      Invoker::CLI::Question.expects(:agree).returns(true)
       setup.expects(:remove_resolver_file).once
       setup.expects(:unload_firewall_rule).with(true).once
       setup.expects(:flush_dns_rules).once

data/spec/invoker/process_manager_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+describe Invoker::ProcessManager do
+  let(:process_manager) { Invoker::ProcessManager.new }
+  describe "#start_process_by_name" do
+    it "should find command by label and start it, if found" do
+      invoker_config.stubs(:processes).returns([OpenStruct.new(:label => "resque", :cmd => "foo", :dir => "bar")])
+      invoker_config.expects(:process).returns(OpenStruct.new(:label => "resque", :cmd => "foo", :dir => "bar"))
+      process_manager.expects(:start_process).returns(true)
+
+      process_manager.start_process_by_name("resque")
+    end
+
+    it "should not start already running process" do
+      process_manager.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
+      expect(process_manager.start_process_by_name("resque")).to be_false
+    end
+  end
+
+  describe "#stop_process" do
+    let(:message) { MM::Remove.new(options) }
+    describe "when a worker is found" do
+      before do
+        process_manager.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
+      end
+
+      describe "if a signal is specified" do
+        let(:options) { { process_name: 'bogus', signal: 'HUP' } }
+        it "should use that signal to kill the worker" do
+          process_manager.expects(:process_kill).with("bogus", "HUP").returns(true)
+          expect(process_manager.stop_process(message)).to be_true
+        end
+      end
+
+      describe "if no signal is specified" do
+        let(:options) { { process_name: 'bogus' } }
+        it "should use INT signal" do
+          process_manager.expects(:process_kill).with("bogus", "INT").returns(true)
+          expect(process_manager.stop_process(message)).to be_true
+        end
+      end
+    end
+
+    describe "when no worker is found" do
+      let(:options) { { process_name: 'bogus', signal: 'HUP' } }
+      before do
+        process_manager.workers.expects(:[]).returns(nil)
+      end
+
+      it "should not kill anything" do
+        process_manager.expects(:process_kill).never
+        process_manager.stop_process(message)
+      end
+    end
+  end
+
+  describe "#load_env" do
+    it "should load .env file from the specified directory" do
+      dir = "/tmp"
+      begin
+        env_file = File.new("#{dir}/.env", "w")
+        env_data =<<-EOD
+FOO=foo
+BAR=bar
+        EOD
+        env_file.write(env_data)
+        env_file.close
+        env_options = process_manager.load_env(dir)
+        expect(env_options).to include("FOO" => "foo", "BAR" => "bar")
+      ensure
+        File.delete(env_file.path)
+      end
+    end
+
+    it "should default to current directory if no directory is specified" do
+      dir = ENV["HOME"]
+      ENV.stubs(:[]).with("PWD").returns(dir)
+      begin
+        env_file = File.new("#{dir}/.env", "w")
+        env_data =<<-EOD
+FOO=bar
+BAR=foo
+        EOD
+        env_file.write(env_data)
+        env_file.close
+        env_options = process_manager.load_env
+        expect(env_options).to include("FOO" => "bar", "BAR" => "foo")
+      ensure
+        File.delete(env_file.path)
+      end
+    end
+
+    it "should return empty hash if there is no .env file" do
+      dir = "/tmp"
+      expect(process_manager.load_env(dir)).to eq({})
+    end
+  end
+end

data/spec/invoker/reactor_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe Invoker::Reactor do
+  describe "writing to socket" do
+  end
+end

data/spec/spec_helper.rb

@@ -1,19 +1,15 @@
 require "pry"
-require 'coveralls'
-Coveralls.wear!
+require "simplecov"
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
 
 require "invoker"
+require "invoker/power/power"
+MM = Invoker::IPC::Message
 
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
@@ -23,7 +19,8 @@ RSpec.configure do |config|
     @original_verbosity = $VERBOSE
     $VERBOSE = nil
     @old_config = Invoker::Power::Config::CONFIG_LOCATION
-    Invoker::Power::Config.const_set(:CONFIG_LOCATION, "/tmp/.invoker")
+    Invoker::Power::Config.const_set(:CONFIG_LOCATION, "/tmp/.invoker/config")
+    FileUtils.mkdir("/tmp/.invoker") unless Dir.exist?("/tmp/.invoker")
 
     File.exists?(Invoker::Power::Config::CONFIG_LOCATION) &&
       File.delete(Invoker::Power::Config::CONFIG_LOCATION)
@@ -65,19 +62,13 @@ end
 ENV["INVOKER_TESTS"] = "true"
 
 def invoker_config
-  if Invoker.const_defined?(:CONFIG)
-    Invoker::CONFIG
-  else
-    Invoker.const_set(:CONFIG, mock())
-    Invoker::CONFIG
-  end
+  Invoker.config ||= mock
 end
 
 def invoker_commander
-  if Invoker.const_defined?(:COMMANDER)
-    Invoker::COMMANDER
-  else
-    Invoker.const_set(:COMMANDER, mock())
-    Invoker::COMMANDER
-  end
+  Invoker.commander ||= mock
+end
+
+def invoker_dns_cache
+  Invoker.dns_cache ||= mock
 end