invoker_ruby34 2.0.0

data/spec/invoker/event/manager_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe Invoker::Event::Manager do
+  describe "Run scheduled events" do
+    before do
+      @event_manager = Invoker::Event::Manager.new()
+    end
+
+    it "should run matched events" do
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.trigger("foo", :exit)
+
+      @event_manager.run_scheduled_events do |event|
+        expect(event.block.call).to eq("exit foo")
+      end
+
+      expect(@event_manager.scheduled_events).to be_empty
+      expect(@event_manager.triggered_events).to be_empty
+    end
+
+    it "should remove triggrered and scheduld events on run" do
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.schedule_event("bar", :entry) { "entry bar"}
+      @event_manager.trigger("foo", :exit)
+      @event_manager.trigger("baz", :exit)
+
+      @event_manager.run_scheduled_events do |event|
+        expect(event.block.call).to eq("exit foo")
+      end
+
+      expect(@event_manager.scheduled_events).not_to be_empty
+      expect(@event_manager.triggered_events).not_to be_empty
+
+      baz_containing_event = @event_manager.triggered_events.map(&:command_label)
+      expect(baz_containing_event).to include("baz")
+
+      bar_containing_scheduled_event = @event_manager.scheduled_events.keys
+      expect(bar_containing_scheduled_event).to include("bar")
+    end
+
+    it "should handle multiple events for same command" do
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.schedule_event("foo", :entry) { "entry bar"}
+      @event_manager.trigger("foo", :exit)
+
+      @event_manager.run_scheduled_events { |event| }
+
+
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.trigger("foo", :exit)
+
+      expect(@event_manager.scheduled_events).not_to be_empty
+      expect(@event_manager.triggered_events).not_to be_empty
+    end
+
+    it "should not run unmatched events" do
+      @event_manager.schedule_event("bar", :entry) { "entry bar"}
+      @event_manager.trigger("foo", :exit)
+
+      events_ran = false
+      @event_manager.run_scheduled_events do |event|
+        events_ran = true
+      end
+      expect(events_ran).to eql false
+    end
+  end
+end

data/spec/invoker/invoker_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe "Invoker" do
+  describe "#darwin?" do
+    it "should return true on osx" do
+      Invoker.expects(:ruby_platform).returns("x86_64-darwin12.4.0")
+      expect(Invoker.darwin?).to be_truthy
+    end
+
+    it "should return false on linux" do
+      Invoker.expects(:ruby_platform).returns("i686-linux")
+      expect(Invoker.darwin?).to be_falsey
+    end
+  end
+
+  describe "#can_run_balancer?", fakefs: true do
+    before { FileUtils.mkdir_p(Invoker::Power::Config.config_dir) }
+    it "should return false if setup command was not run" do
+      expect(Invoker.can_run_balancer?).to be_falsey
+    end
+
+    it "should return true if setup was run properly" do
+      File.open(Invoker::Power::Config.config_file, "w") {|fl|
+        fl.write("hello")
+      }
+      expect(Invoker.can_run_balancer?).to be_truthy
+    end
+
+    it "should not print warning if setup is not run when flag is false" do
+      Invoker::Logger.expects(:puts).never()
+      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_truthy
+      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_truthy
+        new_config_file = File.join(@config_location, 'config')
+        expect(File.exist?(new_config_file)).to be_truthy
+        expect(File.read(new_config_file)).to match('invoker config')
+      end
+    end
+  end
+
+  describe "#home" do
+    it "should return home directory using etc module" do
+      expect(Invoker.home).to eql ENV['HOME']
+    end
+  end
+end

data/spec/invoker/ipc/client_handler_spec.rb

@@ -0,0 +1,54 @@
+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, nil)
+      client_socket.string = message_object.encoded_message
+
+     client.read_and_execute
+    end
+  end
+
+  describe "add_http command with optional ip" do
+    let(:message_object) { MM::AddHttp.new(process_name: 'foo', port: 9000, ip: '192.168.0.1')}
+    it "adds the process name, port and host ip to dns cache" do
+      invoker_dns_cache.expects(:add).with('foo', 9000, '192.168.0.1')
+      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,24 @@
+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,
+          port: 9000 },
+        { shell_command: 'bar', process_name: 'bar', dir: '/tmp', pid: 200,
+          port: 9001 }
+      ]
+    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].length).to eql 2
+      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,49 @@
+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,
+            port: 9000 },
+          { shell_command: 'bar', process_name: 'bar', dir: '/tmp', pid: 200,
+            port: 9001 }
+        ]
+      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,
+            port: 9000 },
+          { shell_command: 'bar', process_name: 'bar', dir: '/tmp', pid: 200,
+            port: 9001 }
+        ]
+
+        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/balancer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Invoker::Power::Balancer do
+  before do
+    @http_connection = mock("connection")
+    @balancer = Invoker::Power::Balancer.new(@http_connection, "http")
+  end
+
+  context "when Host field is not capitalized" do
+    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
+
+    it "should not return 400 when host is lowercase" do
+      headers = { 'host' => 'somehost.com' }
+      mock_invoker_tld_as('test')
+      @http_connection.expects(:send_data).with() { |value| value =~ /404 Not Found/i }
+      @http_connection.expects(:close_connection_after_writing)
+      @balancer.headers_received(headers)
+    end
+
+    it "should not return 400 when host is written as HoSt" do
+      headers = { 'HoSt' => 'somehost.com' }
+      mock_invoker_tld_as('test')
+      @http_connection.expects(:send_data).with() { |value| value =~ /404 Not Found/i }
+      @http_connection.expects(:close_connection_after_writing)
+      @balancer.headers_received(headers)
+    end
+  end
+
+  context "when Host field is missing in the request" do
+    it "should return 400 as response when Host is missing" do
+      headers = {}
+      @http_connection.expects(:send_data).with() { |value| value =~ /400 Bad Request/i }
+      @balancer.headers_received(headers)
+    end
+
+    it "should return 400 as response when Host is empty" do
+      headers = { 'Host' => '' }
+      @http_connection.expects(:send_data).with() { |value| value =~ /400 Bad Request/i }
+      @balancer.headers_received(headers)
+    end
+  end
+end

data/spec/invoker/power/config_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe "Invoker Power configuration", fakefs: true do
+  describe "#create" do
+    it "should create a config file given a hash" do
+      FileUtils.mkdir_p(inv_conf_dir)
+      config = Invoker::Power::Config.create(
+        dns_port: 1200, http_port: 1201, ipfw_rule_number: 010
+      )
+      expect(File.exist?(Invoker::Power::Config.config_file)).to be_truthy
+
+      config = Invoker::Power::Config.load_config()
+      expect(config.dns_port).to eq(1200)
+      expect(config.http_port).to eq(1201)
+      expect(config.ipfw_rule_number).to eq(010)
+    end
+  end
+end

data/spec/invoker/power/http_parser_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Invoker::Power::HttpParser do
+  let(:parser) { Invoker::Power::HttpParser.new('https') }
+
+  describe "complete message received" do
+    before { parser.reset }
+    it "should call header received with full header" do
+      @header = nil
+      parser.on_headers_complete { |header| @header = header }
+      parser << "HTTP/1.1 200 OK\r\n"
+      parser << "Content-Type: text/plain;charset=utf-8\r\n"
+      parser << "Content-Length: 5\r\n"
+      parser << "Connection: close\r\n\r\n"
+      parser << "hello"
+
+      expect(@header['Content-Type']).to eql "text/plain;charset=utf-8"
+    end
+
+    it "should return complete message with x_forwarded added" do
+      complete_message = nil
+      parser.on_message_complete { |message| complete_message = message }
+      parser.on_headers_complete { |header| @header = header }
+      parser << "HTTP/1.1 200 OK\r\n"
+      parser << "Content-Type: text/plain;charset=utf-8\r\n"
+      parser << "Content-Length: 5\r\n"
+      parser << "Connection: close\r\n\r\n"
+      parser << "hello"
+      expect(complete_message).to match(/X_FORWARDED_PROTO:/i)
+    end
+  end
+end

data/spec/invoker/power/http_response_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "tempfile"
+
+describe Invoker::Power::HttpResponse do
+  before do
+    @http_response = Invoker::Power::HttpResponse.new()
+  end
+
+  it "should allow user to send a file" do
+    begin
+      file = Tempfile.new("error.html")
+      file_content = "Error message"
+      file.write(file_content)
+      file.close
+
+      @http_response.use_file_as_body(file.path)
+      expect(@http_response.body).to eq(file_content)
+      expect(@http_response.http_string).to include(file_content)
+    ensure
+      file.unlink
+    end
+  end
+
+  it "should allow user to set headers" do
+    @http_response["Content-Type"] = "text/html"
+    expect(@http_response.header["Content-Type"]).to eq("text/html")
+    expect(@http_response.http_string).to include("Content-Type")
+  end
+
+  it "should allow user to set status" do
+    @http_response.status = 503
+    expect(@http_response.http_string).to include(Invoker::Power::HttpResponse::STATUS_MAPS[503])
+  end
+end

data/spec/invoker/power/port_finder_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe "PortFinder" do
+  before do
+    @port_finder = Invoker::Power::PortFinder.new()
+    @port_finder.find_ports
+  end
+
+  it "should find a http port" do
+    expect(@port_finder.http_port).not_to be_nil
+  end
+
+  it "should find a dns port" do
+    expect(@port_finder.dns_port).not_to be_nil
+  end
+end

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

@@ -0,0 +1,166 @@
+require "spec_helper"
+require "invoker/power/setup/distro/ubuntu"
+require "invoker/power/setup/distro/opensuse"
+
+def mock_socat_scripts
+  FakeFS.deactivate!
+  socat_content = File.read(invoker_setup.forwarder_script)
+  socat_systemd = File.read(invoker_setup.socat_unit)
+  FakeFS.activate!
+  FileUtils.mkdir_p(File.dirname(invoker_setup.forwarder_script))
+  FileUtils.mkdir_p(File.dirname(invoker_setup.socat_unit))
+  File.open(invoker_setup.socat_unit, "w") do |fl|
+    fl.write(socat_systemd)
+  end
+  File.open(invoker_setup.forwarder_script, "w") do |fl|
+    fl.write(socat_content)
+  end
+  FileUtils.mkdir_p("/usr/bin")
+  FileUtils.mkdir_p("/etc/systemd/system")
+end
+
+describe Invoker::Power::LinuxSetup, fakefs: true do
+  before do
+    FileUtils.mkdir_p(inv_conf_dir)
+    FileUtils.mkdir_p(Invoker::Power::Distro::Base::RESOLVER_DIR)
+    Invoker.config = mock
+  end
+
+  let(:invoker_setup) { Invoker::Power::LinuxSetup.new('test') }
+  let(:distro_installer) { Invoker::Power::Distro::Ubuntu.new('test') }
+
+  before do
+    invoker_setup.distro_installer = distro_installer
+  end
+
+  it "should only proceed after user confirmation" do
+    distro_installer.expects(:get_user_confirmation?).returns(false)
+
+    invoker_setup.setup_invoker
+
+    expect { Invoker::Power::Config.load_config }.to raise_error(Errno::ENOENT)
+  end
+
+  it "should create config file with http(s) ports" do
+    invoker_setup.expects(:initialize_distro_installer).returns(true)
+    invoker_setup.expects(:install_resolver).returns(true)
+    invoker_setup.expects(:install_port_forwarder).returns(true)
+    invoker_setup.expects(:drop_to_normal_user).returns(true)
+
+    distro_installer.expects(:get_user_confirmation?).returns(true)
+    distro_installer.expects(:install_required_software)
+    distro_installer.expects(:restart_services)
+
+    invoker_setup.setup_invoker
+
+    config = Invoker::Power::Config.load_config
+    expect(config.tld).to eq('test')
+    expect(config.http_port).not_to be_nil
+    expect(config.dns_port).to be_nil
+    expect(config.https_port).not_to be_nil
+  end
+
+  describe "configuring services" do
+    let(:config) { Invoker::Power::Config.load_config }
+
+    before(:all) do
+      @original_invoker_config = Invoker.config
+    end
+
+    after(:all) do
+      Invoker.config = @original_invoker_config
+    end
+
+    before(:each) do
+      mock_socat_scripts
+    end
+
+    def run_setup
+      invoker_setup.expects(:initialize_distro_installer).returns(true)
+      invoker_setup.expects(:drop_to_normal_user).returns(true)
+
+      distro_installer.expects(:get_user_confirmation?).returns(true)
+      distro_installer.expects(:install_required_software)
+      distro_installer.expects(:restart_services)
+
+      invoker_setup.setup_invoker
+    end
+
+    def test_socat_config
+      socat_content = File.read(Invoker::Power::Distro::Base::SOCAT_SHELLSCRIPT)
+      expect(socat_content.strip).to_not be_empty
+      expect(socat_content.strip).to match(/#{config.https_port}/)
+      expect(socat_content.strip).to match(/#{config.http_port}/)
+
+      service_file = File.read(Invoker::Power::Distro::Base::SOCAT_SYSTEMD)
+      expect(service_file.strip).to_not be_empty
+    end
+
+    context 'on ubuntu with systemd-resolved' do
+      it "should create socat config & set tld to localhost" do
+        distro_installer.expects(:using_systemd_resolved?).at_least_once.returns(true)
+        run_setup
+        expect(distro_installer.resolver_file).to be_nil
+        test_socat_config
+        expect(config.tld).to eq('localhost')
+      end
+    end
+
+    context 'on non-systemd-resolved distro' do
+      it "should create dnsmasq & socat configs" do
+        run_setup
+        dnsmasq_content = File.read(distro_installer.resolver_file)
+        expect(dnsmasq_content.strip).to_not be_empty
+        expect(dnsmasq_content).to match(/test/)
+
+        test_socat_config
+      end
+    end
+  end
+
+  describe 'resolver file' do
+    context 'user sets up a custom top level domain' do
+      let(:tld) { 'local' }
+      let(:linux_setup) { Invoker::Power::LinuxSetup.new(tld) }
+
+      context 'on ubuntu with systemd-resolved' do
+        it 'should not create a resolver file' do
+          ubuntu_installer = Invoker::Power::Distro::Ubuntu.new(tld)
+          linux_setup.distro_installer = ubuntu_installer
+          ubuntu_installer.expects(:using_systemd_resolved?).at_least_once.returns(true)
+          expect(linux_setup.resolver_file).to eq(nil)
+        end
+      end
+
+      context 'on non-systemd-resolved distro' do
+        it 'should create the correct resolver file' do
+          suse_installer = Invoker::Power::Distro::Opensuse.new(tld)
+          linux_setup.distro_installer = suse_installer
+          expect(linux_setup.resolver_file).to eq("/etc/dnsmasq.d/#{tld}-tld")
+        end
+      end
+    end
+  end
+end
+
+describe Invoker::Power::Distro::Base, docker: true do
+  describe '.distro_installer' do
+    it 'correctly recognizes the current distro' do
+      case ENV['DISTRO']
+      when 'archlinux', 'manjarolinux/base'
+        expect(described_class.distro_installer('')).to be_a Invoker::Power::Distro::Arch
+      when 'debian'
+        expect(described_class.distro_installer('')).to be_a Invoker::Power::Distro::Debian
+      when 'fedora'
+        expect(described_class.distro_installer('')).to be_a Invoker::Power::Distro::Redhat
+      when 'linuxmintd/mint20-amd64', 'ubuntu'
+        expect(described_class.distro_installer('')).to be_a Invoker::Power::Distro::Ubuntu
+      when 'opensuse/leap', 'opensuse/tumbleweed'
+        expect(described_class.distro_installer('')).to be_a Invoker::Power::Distro::Opensuse
+      when nil
+      else
+        raise 'Unrecognized Linux distro. Please add the appropriate docker image to the travis build matrix, update the described method, and add a case here.'
+      end
+    end
+  end
+end