meepo 1.5.2

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,22 @@
+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 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/pf_migrate_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe Invoker::Power::PfMigrate do
+  before do
+    FileUtils.mkdir_p("/tmp/.invoker")
+    @old_firewall_file = Invoker::Power::OsxSetup::FIREWALL_PLIST_FILE
+    Invoker::Power::OsxSetup.const_set(:FIREWALL_PLIST_FILE, "/tmp/.invoker/firewall")
+  end
+
+  after do
+    Invoker::Power::OsxSetup.const_set(:FIREWALL_PLIST_FILE, @old_firewall_file)
+  end
+
+  let(:pf_migrator) { Invoker::Power::PfMigrate.new }
+
+  describe "#firewall_config_requires_migration?" do
+    context "for nonosx systems " do
+      it "should return false" do
+        Invoker.expects(:darwin?).returns(false)
+        expect(pf_migrator.firewall_config_requires_migration?).to eq(false)
+      end
+    end
+
+    context "for osx systems" do
+      before { Invoker.expects(:darwin?).returns(true) }
+
+      context "for osx < yosemite" do
+        it "should return false" do
+          pf_migrator.expects(:osx_version).returns(Invoker::Version.new("13.4.0"))
+          expect(pf_migrator.firewall_config_requires_migration?).to eq(false)
+        end
+      end
+
+      context "for osx > yosemite with existing ipfw rule" do
+        before do
+          write_to_firewall_file("ipfw firewall rule")
+        end
+        it "should return true" do
+          pf_migrator.expects(:osx_version).returns(Invoker::Version.new("14.0.0"))
+          expect(pf_migrator.firewall_config_requires_migration?).to eql(true)
+        end
+      end
+
+      context "for osx >= yosemite with no ipfw rule" do
+        before do
+          write_to_firewall_file("rdr pass on")
+        end
+        it "should return false" do
+          pf_migrator.expects(:osx_version).returns(Invoker::Version.new("14.0.0"))
+          expect(pf_migrator.firewall_config_requires_migration?).to eql(false)
+        end
+      end
+    end
+  end
+
+  describe "#migrate" do
+    before do
+      @original_invoker_config = Invoker.config
+      mock_config = mock()
+      mock_config.stubs(:http_port).returns(80)
+      mock_config.stubs(:https_port).returns(443)
+      mock_config.stubs(:tld).returns('dev')
+      Invoker.config = mock_config
+    end
+
+    after do
+      Invoker.config = @original_invoker_config
+    end
+
+    it "should migrate firewall to new system" do
+      pf_migrator.expects(:firewall_config_requires_migration?).returns(true)
+      pf_migrator.expects(:ask_user_for_migration).returns(true)
+      pf_migrator.expects(:sudome)
+      pf_migrator.expects(:drop_to_normal_user)
+      pf_migrator.expects(:exit)
+
+      pf_migrator.migrate
+      expect(pf_migrator.check_firewall_file?).to eql(false)
+    end
+  end
+
+  def write_to_firewall_file(content)
+    File.open(Invoker::Power::OsxSetup::FIREWALL_PLIST_FILE, "w") do |fl|
+      fl.write(content)
+    end
+  end
+end