aruba 0.14.14 → 1.0.0.pre.alpha.1

data/spec/aruba/platforms/unix_command_string_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::Platforms::UnixCommandString do
-  let(:command_string) { described_class.new(base_command) }
-
-  describe '#to_a' do
-    context 'with a command with a path' do
-      let(:base_command) { '/foo/bar' }
-      it { expect(command_string.to_a).to eq [base_command] }
-    end
-
-    context 'with a command with a path containing spaces' do
-      let(:base_command) { '/foo bar/baz' }
-      it { expect(command_string.to_a).to eq [base_command] }
-    end
-  end
-end

data/spec/aruba/platforms/windows_command_string_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::Platforms::WindowsCommandString do
-  let(:command_string) { described_class.new(base_command) }
-  let(:cmd_path) { 'C:\Some Path\cmd.exe' }
-
-  before do
-    allow(Aruba.platform).to receive(:which).with('cmd.exe').and_return(cmd_path)
-  end
-
-  describe '#to_a' do
-    context 'with a command with a path' do
-      let(:base_command) { 'C:\Foo\Bar' }
-      it { expect(command_string.to_a).to eq [cmd_path, '/c', base_command] }
-    end
-
-    context 'with a command with a path containing spaces' do
-      let(:base_command) { 'C:\Foo Bar\Baz' }
-      it { expect(command_string.to_a).to eq [cmd_path, '/c', base_command] }
-    end
-  end
-end

data/spec/aruba/processes/spawn_process_spec.rb

@@ -1,112 +0,0 @@
-require 'aruba/processes/spawn_process'
-
-RSpec.describe Aruba::Processes::SpawnProcess do
-  subject(:process) { described_class.new(command, exit_timeout, io_wait, working_directory, environment, main_class) }
-
-  let(:command) { 'echo "yo"' }
-  let(:exit_timeout) { 1 }
-  let(:io_wait) { 1 }
-  let(:working_directory) { Dir.getwd }
-  let(:environment) { ENV.to_hash.dup }
-  let(:main_class) { nil }
-
-  describe "#stdout" do
-    before(:each) { process.start }
-    before(:each) { process.stop }
-
-    context 'when invoked once' do
-      it { expect(process.stdout).to eq "yo\n" }
-    end
-
-    context 'when invoked twice' do
-      it { 2.times { expect(process.stdout).to eq "yo\n" } }
-    end
-  end
-
-  describe "#stderr" do
-    let(:command) { 'fixtures/spawn_process/stderr.sh yo' }
-
-    before(:each) { process.start }
-    before(:each) { process.stop }
-
-    context 'when invoked once' do
-      it { expect(process.stderr).to eq "yo\n" }
-    end
-
-    context 'when invoked twice' do
-      it { 2.times { expect(process.stderr).to eq "yo\n" } }
-    end
-  end
-
-  describe "#stop" do
-    before(:each) { process.start }
-
-    context 'when stopped successfully' do
-      it { expect { process.stop }.not_to raise_error }
-
-      it "leaves the process in the 'stopped' state" do
-        process.stop
-        aggregate_failures do
-          expect(process).to be_stopped
-          expect(process).not_to be_started
-        end
-      end
-    end
-  end
-
-  describe "#start" do
-    context "when process run succeeds" do
-      it { expect { process.start }.not_to raise_error }
-
-      it "leaves the process in the 'started' state" do
-        process.start
-        aggregate_failures do
-          expect(process).to be_started
-          expect(process).not_to be_stopped
-        end
-      end
-    end
-
-    context "when process run fails" do
-      let(:command) { 'does_not_exists' }
-
-      it { expect { process.start }.to raise_error Aruba::LaunchError }
-    end
-
-    context 'with a command with a space in the path on unix' do
-      let(:child) { instance_double(ChildProcess::AbstractProcess).as_null_object }
-      let(:io) { instance_double(ChildProcess::AbstractIO).as_null_object }
-      let(:command) { 'foo' }
-      let(:command_path) { '/path with space/foo' }
-
-      before do
-        allow(Aruba.platform).to receive(:command_string).and_return Aruba::Platforms::UnixCommandString
-        allow(Aruba.platform).to receive(:which).with(command, anything).and_return(command_path)
-        allow(ChildProcess).to receive(:build).with(command_path).and_return(child)
-        allow(child).to receive(:io).and_return io
-        allow(child).to receive(:environment).and_return({})
-      end
-
-      it { expect { process.start }.to_not raise_error }
-    end
-
-    context 'with a command with a space in the path on windows' do
-      let(:child) { instance_double(ChildProcess::AbstractProcess).as_null_object }
-      let(:io) { instance_double(ChildProcess::AbstractIO).as_null_object }
-      let(:command) { 'foo' }
-      let(:cmd_path) { 'C:\Some Path\cmd.exe' }
-      let(:command_path) { 'D:\Bar Baz\foo' }
-
-      before do
-        allow(Aruba.platform).to receive(:command_string).and_return Aruba::Platforms::WindowsCommandString
-        allow(Aruba.platform).to receive(:which).with('cmd.exe').and_return(cmd_path)
-        allow(Aruba.platform).to receive(:which).with(command, anything).and_return(command_path)
-        allow(ChildProcess).to receive(:build).with(cmd_path, '/c', command_path).and_return(child)
-        allow(child).to receive(:io).and_return io
-        allow(child).to receive(:environment).and_return({})
-      end
-
-      it { expect { process.start }.to_not raise_error }
-    end
-  end
-end

data/spec/aruba/rspec_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'RSpec Integration', :type => :aruba do
-  describe 'Configuration' do
-    subject(:config) { aruba.config }
-
-    context 'when io_wait_timeout is 0.5', :io_wait_timeout => 0.5 do
-      it { expect(config.io_wait_timeout).to eq 0.5 }
-    end
-
-    context 'when io_wait_timeout is 0.1' do
-      it { expect(config.io_wait_timeout).to eq 0.1 }
-    end
-  end
-end

data/spec/aruba/runtime_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Aruba::Runtime do
-  # describe '#fixtures_directory' do
-  #   context 'when no fixtures directories exist' do
-  #     it "should raise exception" do
-  #       expect { api.fixtures_directory }.to raise_error
-  #     end
-  #   end
-  #
-  #   context 'when "/features/fixtures"-directory exist' do
-  #     before(:each) { api.create_directory('features/fixtures') }
-  #
-  #     it { expect(api.fixtures_directory).to eq expand_path('features/fixtures') }
-  #   end
-  #
-  #   context 'when "/spec/fixtures"-directory exist' do
-  #     before(:each) { api.create_directory('spec/fixtures') }
-  #
-  #     it { expect(api.fixtures_directory).to eq expand_path('spec/fixtures') }
-  #   end
-  #
-  #   context 'when "/test/fixtures"-directory exist' do
-  #     before(:each) { api.create_directory('test/fixtures') }
-  #
-  #     it { expect(api.fixtures_directory.to_s).to eq expand_path('test/fixtures') }
-  #   end
-  # end
-end

data/spec/event_bus/name_resolver_spec.rb

@@ -1,68 +0,0 @@
-require 'aruba/event_bus/name_resolver'
-
-describe Aruba::EventBus::NameResolver do
-  subject(:resolver) { described_class.new(default_name_space) }
-  let(:default_name_space) { 'Events' }
-  let(:resolved_name) { resolver.transform(original_name) }
-
-  before :each do
-    stub_const('Events::MyEvent', Class.new)
-    stub_const('Events::MyEvent', Class.new)
-  end
-
-  describe '#transform' do
-    context 'when name is string' do
-      context 'when simple' do
-        let(:original_name) { 'Events::MyEvent' }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-
-      context 'when prefixed' do
-        let(:original_name) { '::Events::MyEvent' }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-    end
-
-    context 'when name is class' do
-      context 'when simple' do
-        let(:original_name) { Events::MyEvent }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-
-      context 'when prefixed' do
-        let(:original_name) { ::Events::MyEvent }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-    end
-
-    context 'when name is symbol' do
-      let(:original_name) { :my_event }
-      it { expect(resolved_name).to eq Events::MyEvent }
-    end
-
-    context 'when namespace ...' do
-      before :each do
-        stub_const('MyLib::Events::MyEvent', Class.new)
-      end
-
-      context 'when is string' do
-        let!(:default_name_space) { 'MyLib::Events' }
-        let!(:original_name) { :my_event }
-
-        it { expect(resolved_name).to eq MyLib::Events::MyEvent }
-      end
-
-      context 'when is module' do
-        let!(:default_name_space) { MyLib::Events }
-        let!(:original_name) { :my_event }
-
-        it { expect(resolved_name).to eq MyLib::Events::MyEvent }
-      end
-    end
-
-    context 'when invalid' do
-      let(:original_name) { 1 }
-      it { expect { resolved_name }.to raise_error Aruba::EventNameResolveError, /Transforming "1"/ }
-    end
-  end
-end

data/spec/event_bus_spec.rb

@@ -1,158 +0,0 @@
-require 'aruba/event_bus'
-
-module Events
-  class TestEvent; end
-  class AnotherTestEvent; end
-  module MalformedTestEvent; end
-end
-
-class MyHandler
-  def call(*); end
-end
-
-class MyMalformedHandler; end
-
-describe Aruba::EventBus do
-  subject(:bus) { described_class.new(name_resolver) }
-
-  let(:name_resolver) { instance_double('Events::NameResolver') }
-
-  let!(:event_klass) { Events::TestEvent }
-  let!(:event_name) { event_klass }
-  let!(:event_instance) { Events::TestEvent.new }
-
-  let!(:another_event_klass) { Events::AnotherTestEvent }
-  let!(:another_event_name) { another_event_klass }
-  let!(:another_event_instance) { Events::AnotherTestEvent.new }
-
-  describe '#notify' do
-    before(:each) do
-      allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-    end
-
-    context 'when subscriber to event, the block is called and get\'s an instance of the event passed as payload' do
-      before :each do
-        bus.register(event_klass) do |event|
-          @received_payload = event
-        end
-
-        bus.notify event_instance
-      end
-
-      it { expect(@received_payload).to eq(event_instance) }
-    end
-
-    context 'when not subscriber to event' do
-      before :each do
-        @received_payload = false
-        bus.register(event_klass) { @received_payload = true }
-        bus.notify another_event_instance
-      end
-
-      it { expect(@received_payload).to eq(false) }
-    end
-
-    context 'when event is not an instance of event class' do
-      let!(:event_name) { :test_event }
-      let(:received_payload) { [] }
-
-      before :each do
-        bus.register(event_name, proc {})
-      end
-
-      it { expect { bus.notify event_klass }.to raise_error Aruba::NoEventError }
-    end
-  end
-
-  describe '#register' do
-    before(:each) do
-      allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-    end
-
-    context 'when valid subscriber' do
-      context 'when multiple instances are given' do
-        let(:received_events) { [] }
-
-        before :each do
-          bus.register(Events::TestEvent) do |event|
-            received_events << event
-          end
-          bus.register(Events::TestEvent) do |event|
-            received_events << event
-          end
-
-          bus.notify event_instance
-        end
-
-        it { expect(received_events.length).to eq 2 }
-        it { expect(received_events).to all eq event_instance }
-      end
-
-      context 'when is string' do
-        let!(:event_name) { event_klass.to_s }
-        let(:received_payload) { [] }
-
-        before :each do
-          bus.register(event_klass.to_s) do |event|
-            received_payload << event
-          end
-
-          bus.notify event_instance
-        end
-
-        it { expect(received_payload).to include event_instance }
-      end
-
-      context 'when is symbol and event is defined in the default namespace given to NameResolver.new' do
-        let!(:event_name) { :test_event }
-        let(:received_payload) { [] }
-
-        before :each do
-          bus.register(event_name) do |event|
-            received_payload << event
-          end
-
-          bus.notify event_instance
-        end
-
-        it { expect(received_payload).to include event_instance }
-      end
-    end
-
-    context 'when valid custom handler' do
-      context 'when single event class' do
-        before(:each) do
-          allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-        end
-
-        before :each do
-          bus.register(event_klass, MyHandler.new)
-        end
-
-        it { expect { bus.notify event_instance }.not_to raise_error }
-      end
-
-      context 'when list of event classes' do
-        before(:each) do
-          allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-          allow(name_resolver).to receive(:transform).with(another_event_name).and_return(another_event_klass)
-        end
-
-        before :each do
-          bus.register([event_klass, another_event_klass], MyHandler.new)
-        end
-
-        it { expect { bus.notify event_instance }.not_to raise_error }
-        it { expect { bus.notify another_event_instance }.not_to raise_error }
-      end
-    end
-
-    context 'when malformed custom handler' do
-      it { expect { bus.register(event_klass, MyMalformedHandler.new) }.to raise_error ArgumentError }
-    end
-
-    context 'when no handler is given' do
-      it { expect { bus.register(event_klass) }.to raise_error ArgumentError }
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-$LOAD_PATH << ::File.expand_path('../../lib', __FILE__)
-
-unless RUBY_PLATFORM.include?('java')
-  require 'simplecov'
-  SimpleCov.command_name 'rspec'
-  SimpleCov.start
-end
-
-# Pull in all of the gems including those in the `test` group
-require 'bundler'
-Bundler.require
-
-# Loading support files
-if RUBY_VERSION < '1.9'
-  Dir.glob(::File.expand_path('../support/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
-  Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
-else
-  Dir.glob(::File.expand_path('../support/*.rb', __FILE__)).each { |f| require_relative f }
-  Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require_relative f }
-end