invoker_ruby34 2.0.0

data/spec/invoker/power/setup/osx_setup_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe Invoker::Power::OsxSetup, fakefs: true do
+  before do
+    FileUtils.mkdir_p(inv_conf_dir)
+    FileUtils.mkdir_p(Invoker::Power::OsxSetup::RESOLVER_DIR)
+  end
+
+  describe "when no setup exists" do
+    it "should create a config file with port etc" do
+      setup = Invoker::Power::OsxSetup.new('dev')
+      setup.expects(:install_resolver).returns(true)
+      setup.expects(:drop_to_normal_user).returns(true)
+      setup.expects(:install_firewall).once
+
+      setup.setup_invoker
+
+      config = Invoker::Power::Config.load_config
+      expect(config.http_port).not_to be_nil
+      expect(config.dns_port).not_to be_nil
+      expect(config.https_port).not_to be_nil
+    end
+  end
+
+  describe "when a setup file exists" do
+    it "should throw error about existing file" do
+      File.open(Invoker::Power::Config.config_file, "w") {|fl|
+        fl.write("foo test")
+      }
+      Invoker::Power::Setup.any_instance.expects(:setup_invoker).never
+      Invoker::Power::Setup.install('dev')
+    end
+  end
+
+  describe "when pow like setup exists" do
+    before {
+      File.open(File.join(Invoker::Power::OsxSetup::RESOLVER_DIR, "dev"), "w") { |fl|
+        fl.write("hello")
+      }
+      @setup = Invoker::Power::OsxSetup.new('dev')
+    }
+
+    describe "when user selects to overwrite it" do
+      it "should run setup normally" do
+        @setup.expects(:setup_resolver_file).returns(true)
+        @setup.expects(:drop_to_normal_user).returns(true)
+        @setup.expects(:install_resolver).returns(true)
+        @setup.expects(:install_firewall).once()
+
+        @setup.setup_invoker
+      end
+    end
+
+    describe "when user chose not to overwrite it" do
+      it "should abort the setup process" do
+        @setup.expects(:setup_resolver_file).returns(false)
+
+        @setup.expects(:install_resolver).never
+        @setup.expects(:install_firewall).never
+
+        @setup.setup_invoker
+      end
+    end
+  end
+
+  describe "uninstalling firewall rules" do
+    it "should uninstall firewall rules and remove all files created by setup" do
+      setup = Invoker::Power::OsxSetup.new('dev')
+
+      Invoker::CLI::Question.expects(:agree).returns(true)
+      setup.expects(:remove_resolver_file).once
+      setup.expects(:unload_firewall_rule).with(true).once
+      Invoker::Power::Config.expects(:delete).once
+
+      setup.uninstall_invoker
+    end
+  end
+
+  describe "setup on fresh osx install" do
+    context "when resolver directory does not exist" do
+      before do
+        @setup = Invoker::Power::OsxSetup.new('dev')
+        FileUtils.rm_rf(Invoker::Power::OsxSetup::RESOLVER_DIR)
+      end
+
+      it "should create the directory and install" do
+        @setup.expects(:setup_resolver_file).returns(true)
+        @setup.expects(:drop_to_normal_user).returns(true)
+        @setup.expects(:install_firewall).once()
+
+        @setup.setup_invoker
+        expect(Dir.exist?(Invoker::Power::OsxSetup::RESOLVER_DIR)).to be_truthy
+      end
+    end
+  end
+
+  describe '.resolver_file' do
+    context 'user sets up a custom top level domain' do
+      it 'should create the correct resolver file' do
+        setup = Invoker::Power::OsxSetup.new('local')
+        expect(setup.resolver_file).to eq('/etc/resolver/local')
+      end
+    end
+  end
+end

data/spec/invoker/power/setup_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe "Setup" do
+end

data/spec/invoker/power/url_rewriter_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Invoker::Power::UrlRewriter do
+  let(:rewriter) { Invoker::Power::UrlRewriter.new }
+
+  before(:all) do
+    @original_invoker_config = Invoker.config
+  end
+
+  def mock_invoker_tld_as(domain)
+    Invoker.config = mock
+    Invoker.config.stubs(:tld).returns(domain)
+  end
+
+  after(:all) do
+    Invoker.config = @original_invoker_config
+  end
+
+  context "matching domain part of incoming request" do
+    before(:each) do
+      mock_invoker_tld_as("test")
+    end
+
+    it "should match foo.test" do
+      match = rewriter.extract_host_from_domain("foo.test")
+      expect(match).to_not be_empty
+
+      matching_string = match[0]
+      expect(matching_string).to eq("foo")
+    end
+
+    it "should match foo.test:1080" do
+      match = rewriter.extract_host_from_domain("foo.test:1080")
+      expect(match).to_not be_empty
+
+      matching_string = match[0]
+      expect(matching_string).to eq("foo")
+    end
+
+    it "should match emacs.bar.test" do
+      match = rewriter.extract_host_from_domain("emacs.bar.test")
+      expect(match).to_not be_empty
+
+      expect(match[0]).to eq("emacs.bar")
+      expect(match[1]).to eq("bar")
+    end
+
+    it "should match hello-world.test" do
+      match = rewriter.extract_host_from_domain("hello-world.test")
+      expect(match).to_not be_nil
+
+      expect(match[0]).to eq("hello-world")
+    end
+
+    context 'user sets up a custom top level domain' do
+      before(:each) do
+        mock_invoker_tld_as("local")
+      end
+
+      it 'should match domain part of incoming request correctly' do
+        match = rewriter.extract_host_from_domain("foo.local")
+        expect(match).to_not be_empty
+
+        matching_string = match[0]
+        expect(matching_string).to eq("foo")
+      end
+    end
+  end
+end

data/spec/invoker/power/web_sockets_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+# Full integration test. Start a server, and client. Let client interact with
+# server do a ping-pong. Client checks whether ping pong is successful or not.
+# Also, mock rewriter so that it returns valid port for request proxying.
+# - Server will run on port 28080.
+# - Balancer will run on port 28081 proxying to 28080
+# - Client will connect to 28081 performing ping-pong
+
+def websocket_server
+  require 'websocket-eventmachine-server'
+
+  EM.run do
+    WebSocket::EventMachine::Server.start(host: "0.0.0.0", port: 28080) do |ws|
+      ws.onerror { |e| p e }
+      ws.onmessage { ws.send "pong" }
+    end
+
+    EM.add_timer(2) { EM.stop }
+  end
+end
+
+def websocket_client
+  require 'websocket-eventmachine-client'
+
+  @message = ""
+
+  EM.run do
+    ws = WebSocket::EventMachine::Client.connect(uri: 'ws://0.0.0.0:28081')
+    ws.onerror { |e| p e }
+    ws.onopen { ws.send("ping") }
+    ws.onmessage { |m, _| @message = m }
+
+    EM.add_timer(2) do
+      expect(@message).to eq "pong"
+      EM.stop
+    end
+  end
+end
+
+
+describe 'Web sockets support' do
+  it 'can ping pong via balancer' do
+    dns_response = Struct.new(:port, :ip).new(28080, "0.0.0.0")
+    Invoker::Power::UrlRewriter.any_instance
+      .stubs(:select_backend_config)
+      .returns(dns_response)
+
+    EM.run do
+      EM.start_server("0.0.0.0", 28081, EM::ProxyServer::Connection, {}) do |conn|
+        Invoker::Power::Balancer.new(conn, "http").install_callbacks
+      end
+
+      fork { websocket_server }
+      fork { websocket_client }
+      EM.add_timer(3) { EM.stop }
+    end
+
+    Process.waitall
+  end
+end

data/spec/invoker/process_manager_spec.rb

@@ -0,0 +1,130 @@
+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
+      @original_invoker_config = Invoker.config
+      Invoker.config = mock
+
+      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")
+
+      Invoker.config = @original_invoker_config
+    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_falsey
+    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_truthy
+        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_truthy
+        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
+
+    it "should load .local.env file if it exists" 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
+
+        local_env_file = File.new("#{dir}/.env.local", "w")
+        local_env_data =<<-EOD
+FOO=emacs
+        EOD
+        local_env_file.write(local_env_data)
+        local_env_file.close
+
+        env_options = process_manager.load_env(dir)
+        expect(env_options).to include("FOO" => "emacs", "BAR" => "bar")
+      ensure
+        File.delete(env_file.path)
+        File.delete(local_env_file.path)
+      end
+    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

@@ -0,0 +1,43 @@
+require "simplecov"
+require 'coveralls'
+require 'fakefs/spec_helpers'
+
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require "invoker"
+require "invoker/power/power"
+MM = Invoker::IPC::Message
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.mock_with :mocha
+  config.include FakeFS::SpecHelpers, fakefs: true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+ENV["INVOKER_TESTS"] = "true"
+
+def invoker_commander
+  Invoker.commander ||= mock
+end
+
+def invoker_dns_cache
+  Invoker.dns_cache ||= mock
+end
+
+def inv_conf_dir
+  File.join(ENV['HOME'], '.invoker')
+end
+
+def inv_conf_file
+  File.join(inv_conf_dir, 'config')
+end