aruba-win-fix 0.14.2

data/spec/aruba/rspec_spec.rb

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,29 @@
+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/aruba/spawn_process_spec.rb

@@ -0,0 +1,60 @@
+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 { process.stop }
+    end
+  end
+
+  describe "#start" do
+    context "when process run succeeds" do
+      it { expect { process.start }.not_to raise_error }
+    end
+
+    context "when process run fails" do
+      let(:command) { 'does_not_exists' }
+
+      it { expect {process.start}.to raise_error Aruba::LaunchError }
+    end
+  end
+end

data/spec/event_bus/name_resolver_spec.rb

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,160 @@
+require 'aruba/event_bus'
+
+# rubocop:disable Style/Documentation
+module Events
+  class TestEvent; end
+  class AnotherTestEvent; end
+  module MalformedTestEvent; end
+end
+
+class MyHandler
+  def call(*); end
+end
+
+class MyMalformedHandler; end
+# rubocop:enable Style/Documentation
+
+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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+$LOAD_PATH << ::File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+SimpleCov.command_name 'rspec'
+SimpleCov.start
+
+# 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
+
+# Avoid writing "describe LocalPac::MyClass do [..]" but "describe MyClass do [..]"
+include Aruba

data/spec/support/configs/aruba.rb

@@ -0,0 +1,5 @@
+require 'aruba/rspec'
+
+Aruba.configure do |config|
+  config.activate_announcer_on_command_failure = [:stderr, :stdout, :command]
+end

data/spec/support/configs/pry.rb

@@ -0,0 +1,3 @@
+# Otherwise pry doesn't find it's RC file
+# if ENV['HOME'] is mocked
+ENV['PRYRC'] = File.expand_path('~/.pryrc')

data/spec/support/configs/rspec.rb

@@ -0,0 +1,15 @@
+require 'rspec/core'
+require 'aruba/api'
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+
+  config.run_all_when_everything_filtered = true
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.include Aruba::Api
+  config.before(:each) { setup_aruba }
+end

data/spec/support/helpers/reporting.rb

@@ -0,0 +1,44 @@
+module SpecHelpers
+  module Reporting
+    # Captures the given stream and returns it:
+    #
+    #   stream = capture(:stdout) { puts 'notice' }
+    #   stream # => "notice\n"
+    #
+    #   stream = capture(:stderr) { warn 'error' }
+    #   stream # => "error\n"
+    #
+    # even for subprocesses:
+    #
+    #   stream = capture(:stdout) { system('echo notice') }
+    #   stream # => "notice\n"
+    #
+    #   stream = capture(:stderr) { system('echo error 1>&2') }
+    #   stream # => "error\n"
+    def capture(stream)
+      stream = stream.to_s
+      captured_stream = Tempfile.new(stream)
+
+      # rubocop:disable Lint/Eval
+      stream_io = eval("$#{stream}")
+      # rubocop:enable Lint/Eval
+
+      origin_stream = stream_io.dup
+      stream_io.reopen(captured_stream)
+
+      yield
+
+      stream_io.rewind
+      return captured_stream.read
+    ensure
+      captured_stream.close
+      captured_stream.unlink
+      stream_io.reopen(origin_stream)
+    end
+    alias silence capture
+  end
+end
+
+RSpec.configure do |config|
+  config.include SpecHelpers::Reporting
+end

data/spec/support/matchers/option.rb

@@ -0,0 +1,35 @@
+RSpec::Matchers.define :be_valid_option do |_|
+  match do |actual|
+    subject.option?(actual)
+  end
+
+  failure_message do |actual|
+    format("expected that \"%s\" is a valid option", actual)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that \"%s\" is not a valid option", actual)
+  end
+end
+
+RSpec::Matchers.define :have_option_value do |expected|
+  match do |actual|
+    @old_actual = actual
+    @actual     = if RUBY_VERSION < '1.9'
+                    subject.send(actual.to_sym)
+                  else
+                    subject.public_send(actual.to_sym)
+                  end
+    values_match? expected, @actual
+  end
+
+  diffable
+
+  failure_message do |_actual|
+    format(%(expected that option "%s" has value "%s"), @old_actual, expected)
+  end
+
+  failure_message_when_negated do |_actual|
+    format(%(expected that option "%s" does not have value "%s"), @old_actual, expected)
+  end
+end