zombees 0.0.1

data/spec/integration/worker_spec.rb

@@ -0,0 +1,43 @@
+require 'integration_spec_helper'
+require 'zombees'
+require 'zombees/honey_comb'
+
+module Zombees
+  describe Worker, integration: true do
+    before(:each) { Fog.mock! }
+    let(:config) {{
+      provider: 'AWS',
+      aws_access_key_id: 'asdf',
+      aws_secret_access_key: 'ghi'
+    }}
+    let(:worker) { HoneyComb.new(config).worker }
+
+    it 'creates a worker instance' do
+      expect(worker).to be_a(described_class)
+    end
+
+    it 'prepares a worker on bootstrap' do 
+      worker.bootstrap
+      expect(worker).to be_ready
+    end
+
+    it 'should destroy the server if its ready', focus: true do 
+      worker.bootstrap
+      worker.server.should_receive(:destroy)
+      worker.shutdown
+    end
+
+    it 'should not destroy the server if ts not ready to shutdown', focus: true do 
+      worker.bootstrap
+      worker.server.stub(:ready?, false)
+      worker.server.should_not_receive(:destroy)
+      worker.shutdown
+    end
+
+    it 'runs the command request on a worker' do
+      worker.bootstrap
+      stdout = worker.run_command('ls')
+      stdout.should_not be_nil
+    end
+  end
+end

data/spec/integration_spec_helper.rb

@@ -0,0 +1,3 @@
+require 'spec_helper'
+require 'fog'
+Fog.mock!

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'zombees'
+require 'pry'
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+
+  config.filter_run_excluding :integration
+  if ENV['CI']
+    config.filter_run_excluding :local
+    require 'coveralls'
+    Coveralls.wear!('test_frameworks')
+  elsif ENV['COVERAGE']
+    require 'simplecov'
+    SimpleCov.start('test_frameworks')
+  end
+
+  config.before(:each) do
+    #TODO Pull request to yell to expose level
+    require 'yell'
+    module Yell
+      class Logger
+        attr_accessor :level
+      end
+    end
+    Yell[Object].level = Yell.level.gt(:error)
+  end
+end

data/spec/zombees/ab_adapter_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'fog'
+require 'zombees/ab_adapter'
+
+module Zombees
+  describe AbAdapter do
+
+
+    it 'prepares the worker supplied' do
+      worker = mock('worker')
+      worker.should_receive(:run_command).with(/apt-get -y update.*apt-get -y install/)
+      subject.prepare(worker)
+    end
+
+    it 'runs a command on a command object' do
+      worker = stub('worker')
+      mock_command = mock('command') 
+      subject.command_source = ->(config) { mock_command }
+
+      mock_command.should_receive(:run).with(worker)
+
+      subject.run(worker)
+    end
+
+    it 'runs a command with specified config' do
+      expected_config = { hello: 'world' }
+      subject = described_class.new(expected_config)
+      worker = stub('worker')
+
+      subject.command_source = ->(config) { 
+        config.should == expected_config
+        stub('command').as_null_object 
+      }
+
+      subject.run(worker)
+    end
+
+    it 'parsers the command result' do
+      mock_parser = mock('parser')
+      AbAdapter::Parser.stub(:new).with(hello: 'world').and_return(mock_parser)
+      mock_parser.should_receive(:parse)
+
+      described_class.new.parse(hello: 'world')
+    end
+
+    it 'parses and aggregates the result' do
+      mock_parser = mock('parser')
+      mock_aggregator = mock('aggregator')
+      AbAdapter::Parser.stub(:new).with(hello: 'world').and_return(mock_parser)
+      AbAdapter::Aggregator.stub(:new).with(command: 'results').and_return(mock_aggregator)
+      mock_parser.should_receive(:parse).and_return(command: 'results')
+      mock_aggregator.should_receive(:aggregate)
+
+      described_class.new.aggregate(hello: 'world')
+    end
+  end
+
+  describe AbAdapter::Command do
+    context 'command generation' do
+      subject { described_class.new(requests: 1000, concurrency: 5, url: 'http://a.co', ab_options: '--foo').command }
+      it { should match '^ab' }
+      it("doesn't exit on socket receive") { should match '-r' }
+      it('should specify number of requests') { should match '-n 1000' }
+      it('should specify concurrency') { should match '-c 5' }
+      it('should set a dummy session id') { should match '-C "sessionid=fake"' }
+      it('should send extra options to ab') { should match '--foo' }
+      it('should pass the url') { should match '"http://a.co"$' }
+    end
+
+    it 'generate a valid ab command', integration: true, local: true do
+      command = described_class.new(requests: 1, concurrency: 1, url: 'http://www.google.com/').command + "> /dev/null"
+      result = system(command)
+      result.should be_true
+    end
+
+    it 'executes a command on a worker' do
+      subject.stub(:command).and_return('ab')
+      worker = mock('Worker')
+      worker.should_receive(:run_command).with('ab')
+      subject.run(worker)
+    end
+  end
+
+  describe AbAdapter::Parser do
+    let(:output) { IO.read File.expand_path("../../fixtures/ab.txt", __FILE__) }
+
+    it 'transforms results of the ab command into a hash of data' do
+      data = described_class.parse(output)
+      data.should have_key(:requests_per_second)
+      data[:requests_per_second].should eq 120.06
+      data[:time_per_request].should eq 83.295
+      data[:time_per_request_concurrent].should eq 8.329
+    end
+
+    it 'transforms results of the run command' do
+      command_results = 3.downto(1).map do |i|
+        [ stub(:command, stdout: output) ]
+      end
+      parser = described_class.new(command_results)
+      data = parser.parse
+      data.should have(3).results
+    end
+  end
+  describe AbAdapter::Aggregator do
+    it 'doesnt have any keys if input doesnt have any' do
+      input = [{foo: :bar},{baz: :bat}]
+      subject = described_class.new(input)
+      result = subject.aggregate
+      result.should_not have_key(:time_per_request)
+      result.should_not have_key(:complete_requests)
+    end
+    it 'totalize number of completed requests' do
+      input = [{complete_requests: 10}, {complete_requests: 15}]
+      subject = described_class.new(input)
+      result = subject.aggregate
+      result.should have_key(:complete_requests)
+      result[:complete_requests].should == 25
+    end
+    it 'totalize number of completed requests' do
+      input = [{failed_requests: 2}, {failed_requests: 1}]
+      subject = described_class.new(input)
+      result = subject.aggregate
+      result.should have_key(:failed_requests)
+      result[:failed_requests].should == 3
+    end
+    it 'averages time per request' do
+      input = [{time_per_request: 1.2}, {time_per_request: 1.6}]
+      subject = described_class.new(input)
+      result = subject.aggregate
+      result.should have_key(:time_per_request)
+      result[:time_per_request].should == 1.4
+    end
+  end
+end
+
+
+describe Fog::SSH::Result do
+  it { described_class.instance_methods.should include :stdout }
+end

data/spec/zombees/command_role_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module CommandRoleSpecs
+  describe 'CommandRole' do 
+    it 'should contain a command class' do
+
+    end
+  end
+end

data/spec/zombees/connection_spec.rb

@@ -0,0 +1,47 @@
+require 'zombees/connection'
+require 'celluloid/pmap'
+require 'spec_helper'
+
+module Zombees
+  describe Connection do
+    describe '#instance' do
+      before do
+        Fog::Compute.stub(:new).and_return(stub(key_pairs: stub(get: true)))
+      end
+
+#      it 'creates a single instance for the same config' do
+#        config = {foo: 'bar'}
+#        first_connection = Connection.instance(config)
+#        second_connection = Connection.instance(config)
+#
+#        first_connection.should_not be_nil
+#        first_connection.object_id.should == second_connection.object_id
+#      end
+#
+#      it 'creates a multiple instances for different config' do
+#        first_connection = Connection.instance(foo: :bar)
+#        second_connection = Connection.instance(baz: :bat)
+#
+#        first_connection.should_not be_nil
+#        first_connection.object_id.should_not == second_connection.object_id
+#      end
+#
+#      it 'creates a single instance for the same config when instantiated from multiple threads', focus: true do
+#        # Faking wait on fog instantiation
+#        Fog::Compute.stub(:new) do
+#          sleep(rand(0.1..0.3))
+#          stub(key_pairs: stub(get: true))
+#        end
+#        config = {some_key: rand(1..10)}
+#        connections = 10.downto(1).pmap do
+#          Connection.instance(config)
+#        end
+#
+#        connections.each_cons(2) do |first, second|
+#          first.should_not be_nil
+#          first.object_id.should == second.object_id
+#        end
+#      end
+    end
+  end
+end

data/spec/zombees/honey_comb_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Zombees
+  describe HoneyComb do
+    before do
+      Connection.stub(:import_key_pair)
+    end
+    it 'stores a configuration' do
+      honeycomb = described_class.new(foo: :bar)
+      expect(honeycomb.config[:foo]).to eq :bar
+    end
+    it 'imports key pair' do
+      Connection.should_receive(:import_key_pair).with(foo: :bar)
+      honeycomb = described_class.new(foo: :bar)
+    end
+  end
+end

data/spec/zombees/queen_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'zombees/queen'
+
+module Zombees
+  describe Queen do
+    let(:swarm) { mock('Swarm') }
+    let(:queen) {described_class.new(config: {}, worker_count: 3, command: "ls", swarm: swarm)}
+
+    before do
+      Connection.stub(:import_key_pair)
+    end
+    describe '#run' do
+      it 'runs the swarm' do
+        swarm.should_receive(:run)
+        queen.swarm_source = ->(options) { swarm }
+        queen.run
+      end
+    end
+
+    it 'creates a swarm with default options' do
+      queen = described_class.new(config: {foo: :bar}, worker_count: 3, command: 'ls')
+      queen.swarm_source = ->(options) do
+        options.honey_comb.config[:foo].should eq :bar
+        stub(run: true)
+      end
+      queen.run
+    end
+  end
+end

data/spec/zombees/swarm_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'zombees/swarm'
+require 'zombees/ab_adapter'
+
+module Zombees
+  module NoopAdapter
+    def self.prepare(worker)
+
+    end
+    def self.run(worker)
+
+    end
+    def self.aggregate(whatever)
+
+    end
+    class Command
+
+    end
+  end
+  class NoopWorker
+    def bootstrap; self end
+  end
+  describe Swarm do
+    def generate_swarm(population)
+      described_class.new(options, population)
+    end
+    let(:swarm) { generate_swarm(nil) }
+    let(:options) { SwarmOptions.new(worker_count: 3, command: noop_adapter, honey_comb: honey_comb) }
+    let(:honey_comb) { stub(worker: worker) }
+    let(:worker) { NoopWorker.new }
+    let(:noop_adapter) { NoopAdapter }
+
+    it 'bootstraps requested number of servers' do
+      worker.should_receive(:bootstrap).exactly(3).times
+
+      swarm.breed
+    end
+
+    it 'attempts shutdown if bootstrap fails' do
+      e = RuntimeError.new
+      worker.stub(:bootstrap).and_raise(e)
+      worker.should_receive(:shutdown).exactly(3).times.with(e)
+
+      swarm.breed
+    end
+
+    it 'adds command-specific configuration to workers' do
+      noop_adapter.should_receive(:prepare).with(worker).exactly(3).times
+
+      swarm.breed
+    end
+
+    it 'does not breed when already populated' do
+      worker.should_receive(:bootstrap).exactly(3).times.and_return(stub(run_command: true))
+
+      swarm.breed
+      swarm.breed
+    end
+
+
+    it 'distributes a command to the population of workers' do
+      workers = (1..3).map { |i| mock("Worker#{i}", shutdown: true) }
+
+      NoopAdapter.should_receive(:run).exactly(workers.size).times.and_return(true)
+      NoopAdapter.should_receive(:aggregate).with([true, true, true]).once.and_return(true)
+      swarm = generate_swarm(workers)
+      swarm.run
+    end
+
+    it 'attempts to shutdown worker if run fails' do
+      worker = mock('Worker')
+
+      e = RuntimeError.new
+      NoopAdapter.stub(:run).and_raise(e)
+      swarm = generate_swarm([worker])
+      worker.should_receive(:shutdown)
+      swarm.run
+    end
+
+    it 'attempts to shutdown worker if run fails' do
+      worker = mock('Worker')
+
+      e = RuntimeError.new
+      NoopAdapter.stub(:aggregate).and_return(true)
+      swarm = generate_swarm([worker])
+      worker.should_receive(:shutdown)
+      swarm.run
+    end
+  end
+end

data/tourfleet

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEA2BRbCBTnbp++xa/VfI3cygPgBStFvqtKYatrq0BOjOwO/xMt
+de1xf9z693ZZkpSb3arCeh/6eBU6dLDPMXLkYvRaOhbgFbwR78jUR5mZQYwOB6WY
+SFc81YgKyrVGHHZQN+48xnaNHuYCR3RBdMnBSY/tRsKtMWSTgaCwSpVH5rTtEwYe
+k0jy7cmIw6i/RecnmCkmhoEupW3780aj0uLEWML7w6/ID0JALVUyObemhjN1H/6q
+3QoncfH1UvRqfEthMVSiQD8sp9ECK9JaMtCXEgPjXdlVatENsDHYCrHuHsACiGQm
+W+j2JOdWrCXTE3FH7FHwNmraHH0EI4zj6kdK7QIDAQABAoIBACO9ejEkBAOwOIXK
+R62KaXKgoXU5axfWjT8Kc4yn3lZA1VoreeF/nL5hdsFnufkcy4smq3Q3xd4G5NxY
+Qm0Ta+NSN3pUPkxaBz16ImKVbVwCJm/tW/rbMxy+m8pboXUjvLEDntnU0hLCSK44
+9Hq0xFu+iqihmrQIxr0yLvanKnVmOeEJLOeU8L/O/opxxG0uaaQSQzjJRw5WjhIc
+ZMCJ+VYNqe3tZMHNHtXRaNqp2hlSgeoNEq0XubxRCO4MuW8iFi8SywevbWYdOCj4
+yhgp6Q4wr92qgtonn2j2UBJTYFgn9i9cr1ryk2msnA2vkmrAeOOKyMO4jKTm7RY4
+tLLAlgECgYEA7e9boFVEL+qwIAb1lAMezbjzZ5ElUBWK9sSlFz63PsSlUWUUexlW
+NWuqvGTM+sA1E/Ei9FV5yahM8fGTmmP/94SJXGinbhg98i517qbi2O56SuPS23db
+5dmJnyCZxu8MVoNqhGtJ+dM3aw+5ghj1QP5yoLJ4gjDFdt+sYX2gIPECgYEA6Hwz
+tHJ/XpQDuJ7XeF58/vAfF049E9lv25oS7xVtmlw3XEG3Y0X75agnkC+KA+2/xHPX
+ceWYI+EyBRo0/kqn3OUScyB2Lwg9I967YSIIir9dDddM71ruyh2PQliJcqzEJeUq
+yN4/zb3xiF5eVUTayK0r6hhqHcphiq//PHBOib0CgYBd4dsSeXJtQbn6+SP/IfgO
+jlKkY9YIMmfhlJfbgyiEwMzGQA8Dv2yPqYr1yQREUIDg/H2hUPS8CAdMU9i8y4Zd
+INOePcEKpNAUdhaccwcBN5/TWu+BHyiImfw+aHukzf/dRv9Jfpfy1k+Ak/TLi5OB
+8KREGgeIvzu6+uimkw4S0QKBgDSDEV652gEv56NE5aB/nzYqYKtv9aXNIFH2/D3a
+ljYejDafdV/MB/i4wa70vfTjN8SU8d39IR9Bl33FjKC/lijz6PXuKCO5da3remGX
+QVytmsQslGkgHf2zLY+r1ef8FBYHLGHQqZK8S5kkz6Ps+IoJa3jl6Novw1aDKGCr
+cWH1AoGBAJz8/QJ+Dnmav70cX7faOlzTvzaNjqgWnZNAHXo/xxEG3MeIq5Oo6ae6
+ADXnkU42kxs5FjnlTzpBZ/cYueHylDZydatUKsVngnnnm9drdnHinvatBctpQAbE
+t2NOTCaWbsHRhRvZhUPCxYcrpEBAeOIrctf1hqnNFEWRN1vzpE58
+-----END RSA PRIVATE KEY-----

data/tourfleet.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDYFFsIFOdun77Fr9V8jdzKA+AFK0W+q0phq2urQE6M7A7/Ey117XF/3Pr3dlmSlJvdqsJ6H/p4FTp0sM8xcuRi9Fo6FuAVvBHvyNRHmZlBjA4HpZhIVzzViArKtUYcdlA37jzGdo0e5gJHdEF0ycFJj+1Gwq0xZJOBoLBKlUfmtO0TBh6TSPLtyYjDqL9F5yeYKSaGgS6lbfvzRqPS4sRYwvvDr8gPQkAtVTI5t6aGM3Uf/qrdCidx8fVS9Gp8S2ExVKJAPyyn0QIr0loy0JcSA+Nd2VVq0Q2wMdgKse4ewAKIZCZb6PYk51asJdMTcUfsUfA2atocfQQjjOPqR0rt solomon@G10205.local

data/zombees.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zombees/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zombees"
+  spec.version       = Zombees::VERSION
+  spec.authors       = ["Maxim Filimonov","Solomon White"]
+  spec.email         = ["tpaktopsp@gmail.com", "rubysolo@gmail.com"]
+  spec.description   = %q{Zombees}
+  spec.summary       = %q{Distributed load testing in Ruby}
+  spec.homepage      = "http://github.com/zombees/zombees"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'celluloid-pmap'
+  spec.add_dependency 'celluloid', '~>0.13.0'
+  spec.add_dependency 'fog', '~>1.8.0'
+  spec.add_dependency 'net-ssh','~>2.5.0'
+  spec.add_dependency 'yell'
+  spec.add_dependency 'colorize'
+
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency 'emoji-rspec'
+  spec.add_development_dependency 'coveralls'
+end