kookaburra 2.0.0 → 3.0.0

data/lib/kookaburra/version.rb

@@ -1,3 +1,3 @@
 class Kookaburra
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/spec/integration/test_a_rack_application_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'kookaburra/test_helpers'
 require 'kookaburra/api_client'
 require 'kookaburra/rack_app_server'
@@ -7,7 +8,7 @@ require 'uuid'
 
 require 'support/json_api_app_and_kookaburra_drivers'
 
-describe "testing a Rack application with Kookaburra" do
+describe "testing a Rack application with Kookaburra", :slow do
   include Kookaburra::TestHelpers
 
   describe "with an HTML interface" do
@@ -40,7 +41,7 @@ describe "testing a Rack application with Kookaburra" do
         api.create_widget(:widget_b, :name => 'Widget B')
       end
 
-      define_method(:widgets) { k.get_data(:widgets) }
+      define_method(:widgets) { get_data(:widgets) }
 
       it "runs the tests against the application's UI" do
         ui.sign_in(:bob)

data/spec/integration/test_multiple_applications_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'kookaburra/test_helpers'
+require 'kookaburra/rack_app_server'
+require 'capybara'
+require 'capybara/webkit'
+require 'uuid'
+
+require 'support/json_api_app_and_kookaburra_drivers'
+
+describe 'testing multiple applications', :slow do
+  include Kookaburra::TestHelpers
+
+  OtherJsonApiApp = Class.new(JsonApiApp)
+  MyOtherUIDriver = Class.new(MyUIDriver)
+  MyOtherAPIDriver = Class.new(MyAPIDriver)
+
+  app_server_1 = Kookaburra::RackAppServer.new do
+    JsonApiApp.new
+  end
+
+  app_server_2 = Kookaburra::RackAppServer.new do
+    OtherJsonApiApp.new
+  end
+
+  before(:all) do
+    app_server_1.boot
+    app_server_2.boot
+
+    Kookaburra.configure do |c|
+      c.application(:app_1) do |a|
+        a.ui_driver_class = MyUIDriver
+        a.api_driver_class = MyAPIDriver
+        a.app_host = 'http://127.0.0.1:%d' % app_server_1.port
+      end
+      c.application(:app_2) do |a|
+        a.ui_driver_class = MyOtherUIDriver
+        a.api_driver_class = MyOtherAPIDriver
+        a.app_host = 'http://127.0.0.1:%d' % app_server_2.port
+      end
+      c.browser = Capybara::Session.new(:webkit)
+      c.server_error_detection do |browser|
+        browser.has_css?('head title', :text => 'Internal Server Error', :visible => false)
+      end
+    end
+  end
+
+  after(:all) do
+    app_server_1.shutdown
+    app_server_2.shutdown
+  end
+
+  specify 'once you have defined multiple apps, the top-level #api and #ui methods raise errors' do
+    expect { api } .to raise_error( Kookaburra::AmbiguousDriverError )
+    expect { ui }  .to raise_error( Kookaburra::AmbiguousDriverError )
+  end
+
+  context "with different data in each app" do
+    before(:each) do
+      app_1.api.create_user(:bob)
+      app_2.api.create_user(:sue)
+      app_1.api.create_widget(:widget_a)
+      app_2.api.create_widget(:widget_b)
+    end
+
+    let(:widgets) { get_data(:widgets) }
+
+    it 'can speak to both application APIs' do
+      expect(app_1.api.widgets).to include widgets[:widget_a]
+      expect(app_1.api.widgets).not_to include widgets[:widget_b]
+
+      expect(app_2.api.widgets).not_to include widgets[:widget_a]
+      expect(app_2.api.widgets).to include widgets[:widget_b]
+    end
+
+    it 'can speak to both application UIs' do
+        app_1.ui.sign_in(:bob)
+        app_1.ui.view_widget_list
+        expect(app_1.ui.widget_list.widgets).to include widgets[:widget_a]
+        expect(app_1.ui.widget_list.widgets).to_not include widgets[:widget_b]
+
+        app_2.ui.sign_in(:sue)
+        app_2.ui.view_widget_list
+        expect(app_2.ui.widget_list.widgets).to_not include widgets[:widget_a]
+        expect(app_2.ui.widget_list.widgets).to include widgets[:widget_b]
+    end
+
+    it 'shares a single browser session' do
+      app_1.ui.sign_in(:bob)
+      app_1.ui.view_widget_list
+      app_2.ui.sign_in(:sue)
+      expect(app_1.ui.widget_list).to be_not_visible
+      app_1.ui.view_widget_list
+      expect(app_1.ui.widget_list).to be_visible
+    end
+  end
+end

data/spec/kookaburra/api_client_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'kookaburra/api_client'
 
 describe Kookaburra::APIClient do
@@ -16,7 +17,7 @@ describe Kookaburra::APIClient do
   shared_examples_for 'any type of HTTP request' do |http_verb|
     context "(#{http_verb})" do
       before(:each) do
-        client.stub(http_verb => response)
+        allow(client).to receive(http_verb).and_return(response)
       end
 
       it 'returns the response body' do
@@ -24,8 +25,8 @@ describe Kookaburra::APIClient do
       end
 
       it 'raises an UnexpectedResponse if the request is not successful' do
-        response.stub(code: 500)
-        client.stub(http_verb).and_raise(RestClient::Exception.new(response))
+        allow(response).to receive(:code) { 500 }
+        allow(client).to receive(http_verb).and_raise(RestClient::Exception.new(response))
         expect{ api.send(http_verb, '/foo') } \
           .to raise_error(Kookaburra::UnexpectedResponse)
       end
@@ -116,7 +117,7 @@ describe Kookaburra::APIClient do
   shared_examples_for 'it encodes request data' do |http_verb|
     context "(#{http_verb})" do
       before(:each) do
-        client.stub(http_verb => response)
+        allow(client).to receive(http_verb) { response }
       end
 
       context 'when a custom encoder is specified' do
@@ -132,7 +133,7 @@ describe Kookaburra::APIClient do
 
         it "encodes input to requests" do
           expect(client).to receive(http_verb) do |_, data, _|
-            data.should == :some_encoded_data
+            expect(data).to eq :some_encoded_data
             response
           end
 

data/spec/kookaburra/api_driver_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Kookaburra::APIDriver do
+  subject {
+    klass = Class.new(described_class) do
+      def do_something
+        api
+      end
+    end
+    klass.new(configuration)
+  }
+
+  let(:configuration) { double(:configuration) }
+
+  it 'requires subclasses to implement their #api method' do
+    expect{ subject.do_something }.to raise_error(Kookaburra::ConfigurationError)
+  end
+end

data/spec/kookaburra/configuration/proxy_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Kookaburra::Configuration::Proxy do
+  subject { described_class.new(name: :foobar, basis: basis) }
+
+  let(:basis) {
+    Kookaburra::Configuration.new.tap do |c|
+      c.ui_driver_class = default_ui_driver_class
+    end
+  }
+
+  let(:default_ui_driver_class) { double(:default_ui_driver_class) }
+
+  it 'it knows the name with which it was created' do
+    expect(subject.name).to eq :foobar
+  end
+
+  it 'delegates to its basis by default' do
+    expect(subject.ui_driver_class).to equal default_ui_driver_class
+  end
+
+  it 'does not delegate attributes that are set explicitly to a value' do
+    ui_driver_class_override = double(:ui_driver_class_override)
+    subject.ui_driver_class = ui_driver_class_override
+    expect(basis.ui_driver_class).to equal default_ui_driver_class
+    expect(subject.ui_driver_class).to equal ui_driver_class_override
+  end
+
+  it 'does not delegate attributes that are set explicitly to nil' do
+    subject.ui_driver_class = nil
+    expect(basis.ui_driver_class).to equal default_ui_driver_class
+    expect(subject.ui_driver_class).to be_nil
+  end
+
+  it 'responds only to methods to which its basis also responds' do
+    expect{ subject.not_a_defined_method }.to raise_error(NameError)
+    expect{ subject.not_a_defined_method = :something }.to raise_error(NameError)
+  end
+end

data/spec/kookaburra/configuration_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'kookaburra/configuration'
 require 'support/shared_examples/it_has_a_dependency_accessor'
 
@@ -6,7 +7,6 @@ describe Kookaburra::Configuration do
   it_behaves_like :it_has_a_dependency_accessor, :ui_driver_class
   it_behaves_like :it_has_a_dependency_accessor, :browser
   it_behaves_like :it_has_a_dependency_accessor, :app_host
-  it_behaves_like :it_has_a_dependency_accessor, :mental_model
   it_behaves_like :it_has_a_dependency_accessor, :logger
 
   describe '#server_error_detection' do
@@ -23,7 +23,7 @@ describe Kookaburra::Configuration do
         .with('http://example.com') \
         .and_return(:a_parsed_uri)
       subject.app_host = 'http://example.com'
-      subject.app_host_uri.should == :a_parsed_uri
+      expect(subject.app_host_uri).to eq :a_parsed_uri
     end
 
     it 'changes if #app_host changes' do
@@ -36,4 +36,56 @@ describe Kookaburra::Configuration do
       expect(subject.app_host_uri).to eq 'http://foo.example.com'.to_sym
     end
   end
+
+  describe '#mental_model' do
+    it 'returns an instance of MentalModel' do
+      expect(subject.mental_model).to be_kind_of Kookaburra::MentalModel
+    end
+
+    it 'always returns the same instance' do
+      expect(subject.mental_model.__id__).to eq subject.mental_model.__id__
+    end
+  end
+
+  describe '#application' do
+    let(:proxy) { double(:proxy) }
+    let(:app_kookaburra) { double(:app_kookaburra) }
+
+    before(:each) do
+      allow(Kookaburra::Configuration::Proxy).to receive(:new) { proxy }
+      allow(Kookaburra).to receive(:new) { app_kookaburra }
+    end
+
+    it 'builds a proxy configuration based on this one' do
+      expect(Kookaburra::Configuration::Proxy).to receive(:new) \
+        .with(name: :foo, basis: subject)
+      subject.application(:foo)
+    end
+
+    it 'yields the proxy configuration' do
+      expect{ |b| subject.application(:foo, &b) }.to yield_with_args(proxy)
+    end
+
+    it 'builds a new Kookaburra instance with the proxy configuration' do
+      expect(Kookaburra).to receive(:new).with(proxy)
+      subject.application(:foo)
+    end
+
+    it 'stores the new Kookaburra instance by name' do
+      expect(subject.applications.keys).to_not include(:foo)
+      subject.application(:foo)
+      expect(subject.applications[:foo]).to equal app_kookaburra
+    end
+  end
+
+  describe '#has_named_applications?' do
+    it 'is true when a named application is configured' do
+      subject.application(:foo)
+      expect(subject).to have_named_applications
+    end
+
+    it 'is false when no named applications are configured' do
+      expect(subject).to_not have_named_applications
+    end
+  end
 end

data/spec/kookaburra/mental_model_spec.rb

@@ -1,13 +1,14 @@
+require 'spec_helper'
 require 'kookaburra/mental_model'
 
 describe Kookaburra::MentalModel do
   describe '#method_missing' do
     it 'returns a Collection' do
-      subject.foo.should be_kind_of(Kookaburra::MentalModel::Collection)
+      expect(subject.foo).to be_kind_of(Kookaburra::MentalModel::Collection)
     end
 
     it 'returns different Collections for different messages' do
-      subject.foo.should_not === subject.bar
+      expect(subject.foo).to_not equal subject.bar
     end
   end
 
@@ -19,7 +20,7 @@ describe Kookaburra::MentalModel do
         collection[:foo] = 'foo'
         collection[:bar] = 'bar'
         collection[:baz] = 'baz'
-        collection.values_at(:foo, :baz).should == %w(foo baz)
+        expect(collection.values_at(:foo, :baz)).to eq %w(foo baz)
       end
     end
 
@@ -28,7 +29,7 @@ describe Kookaburra::MentalModel do
         collection[:foo] = 'foo'
         collection[:bar] = 'bar'
         collection[:baz] = 'baz'
-        collection.slice(:foo, :baz).should == {:foo => 'foo', :baz => 'baz'}
+        expect(collection.slice(:foo, :baz)).to eq({:foo => 'foo', :baz => 'baz'})
       end
     end
 
@@ -38,25 +39,25 @@ describe Kookaburra::MentalModel do
         collection[:bar] = 'bar'
         collection[:baz] = 'baz'
         collection[:yak] = 'yak'
-        collection.except(:foo, :baz).should == {:bar => 'bar', :yak => 'yak'}
+        expect(collection.except(:foo, :baz)).to eq({:bar => 'bar', :yak => 'yak'})
       end
     end
 
     describe '#delete' do
       it 'deletes and returns the item matching the specified key' do
         collection[:baz] = 'baz'
-        collection.delete(:baz).should == 'baz'
-        lambda { collection[:baz] }.should raise_error(Kookaburra::UnknownKeyError)
+        expect(collection.delete(:baz)).to eq 'baz'
+        expect{ collection[:baz] }.to raise_error(Kookaburra::UnknownKeyError)
       end
 
       it 'persists the deleted key/value pair to the #deleted subcollection' do
         collection[:baz] = 'baz'
         collection.delete(:baz)
-        collection.deleted[:baz].should == 'baz'
+        expect(collection.deleted[:baz]).to eq 'baz'
       end
 
       it 'raises a Kookaburra::UnknownKeyError exception if trying to delete a missing key' do
-        lambda { collection.delete(:snerf) }.should \
+        expect{ collection.delete(:snerf) }.to \
           raise_error(Kookaburra::UnknownKeyError, "Can't find mental_model.widgets[:snerf]. Did you forget to set it?")
       end
     end
@@ -70,57 +71,58 @@ describe Kookaburra::MentalModel do
 
       it 'deletes all members of collection for whom given block evaluates to false' do
         collection.delete_if { |k,v| k.to_s != v }
-        collection.keys.should =~ [:foo, :baz]
+        expect(collection.keys).to match_array [:foo, :baz]
       end
 
       it 'adds deleted members of collection to #deleted subcollection' do
         collection.delete_if { |k,v| k.to_s != v }
-        collection.deleted.keys.should == [:bar]
+        expect(collection.deleted.keys).to eq [:bar]
       end
 
       it 'returns hash of items not deleted' do
-        collection.delete_if { |k,v| k.to_s != v }.should == { :foo => 'foo', :baz => 'baz' }
+        expect(collection.delete_if { |k,v| k.to_s != v }).to \
+          eq({:foo => 'foo', :baz => 'baz'})
       end
     end
 
     describe '#deleted' do
       it 'generates a new subcollection if none exists' do
         initialized_collection = collection
-        Kookaburra::MentalModel::Collection.should_receive(:new) \
+        expect(Kookaburra::MentalModel::Collection).to receive(:new) \
           .with("#{initialized_collection.name}.deleted")
         initialized_collection.deleted
       end
 
       it 'returns the deleted subcollection if already initialized' do
         deleted_collection = collection.deleted
-        collection.deleted.should === deleted_collection
+        expect(collection.deleted).to equal deleted_collection
       end
     end
 
     it 'raises a Kookaburra::UnknownKeyError exception for #[] with a missing key' do
-      lambda { collection[:foo] }.should \
+      expect{ collection[:foo] }.to \
         raise_error(Kookaburra::UnknownKeyError, "Can't find mental_model.widgets[:foo]. Did you forget to set it?")
     end
 
     describe '#dup' do
       it 'returns a different object' do
         new_collection = collection.dup
-        new_collection.__id__.should_not === collection.__id__
+        expect(new_collection).to_not equal collection
       end
 
       it 'returns an object with equal values to the original' do
         collection[:foo] = :bar
         collection[:baz] = :bam
         new_collection = collection.dup
-        new_collection[:foo].should == :bar
-        new_collection[:baz].should == :bam
+        expect(new_collection[:foo]).to eq :bar
+        expect(new_collection[:baz]).to eq :bam
       end
 
       it 'is a deep copy' do
         collection[:foo] = {:bar => 'baz'}
         new_collection = collection.dup
-        new_collection[:foo][:bar].should == 'baz'
-        new_collection[:foo][:bar].__id__.should_not === collection[:foo][:bar].__id__
+        expect(new_collection[:foo][:bar]).to eq 'baz'
+        expect(new_collection[:foo][:bar]).to_not equal collection[:foo][:bar]
       end
 
       context 'when there are deleted items present' do

data/spec/kookaburra/test_helpers_spec.rb

@@ -1,42 +1,78 @@
+require 'spec_helper'
 require 'kookaburra/test_helpers'
 
 describe Kookaburra::TestHelpers do
-  include Kookaburra::TestHelpers
-
-  before(:all) do
-    Kookaburra.configure do |c|
-      c.api_driver_class = Kookaburra::APIDriver
-      c.ui_driver_class    = Kookaburra::UIDriver
+  subject {
+    Object.new.tap do |o|
+      o.extend Kookaburra::TestHelpers
     end
+  }
+
+  let(:k_kookaburra) {
+    double(:k_kookaburra, api: k_api, ui: k_ui, get_data: k_data)
+  }
+  let(:k_api) { double(:k_api) }
+  let(:k_ui) { double(:k_ui) }
+  let(:k_data) { double(:k_data) }
+
+  before(:each) do
+    allow(Kookaburra).to receive(:new) { k_kookaburra }
   end
 
-  after(:all) do
-    Kookaburra.configure do |c|
-      c.api_driver_class = nil
-      c.ui_driver_class    = nil
+  shared_examples_for 'it has no individual applications configured' do
+    it 'forwards #api to the main Kookaburra instance' do
+      expect(subject.api).to equal k_api
     end
-  end
 
-  describe "#k" do
-    it "returns an instance of Kookaburra" do
-      k.should be_kind_of(Kookaburra)
+    it 'forwards #ui to the main Kookaburra instance' do
+      expect(subject.ui).to equal k_ui
     end
 
-    it "memoizes" do
-      a = k; b = k
-      a.should equal(b)
+    it 'forwards #get_data to the main Kookaburra instance' do
+      expect(subject.get_data).to equal k_data
     end
   end
 
-  describe "methods delegated to #k" do
-    it "includes #api" do
-      k.should_receive(:api)
-      api
+  context "when no individual applications are configured" do
+    it_behaves_like 'it has no individual applications configured'
+  end
+
+  context "when individual applications are configured" do
+    before(:each) do
+      Kookaburra.configure do |c|
+        c.application(:foo)
+        c.application(:bar)
+      end
+    end
+
+    specify '#api raises an AmbiguousDriverError' do
+      expect{ subject.api }.to raise_error Kookaburra::AmbiguousDriverError
     end
 
-    it "includes #ui" do
-      k.should_receive(:ui)
-      ui
+    specify '#ui raises an AmbiguousDriverError' do
+      expect{ subject.api }.to raise_error Kookaburra::AmbiguousDriverError
+    end
+
+    specify '#get_data is forwarded to the main Kookaburra instance' do
+      expect(subject.get_data).to equal k_data
+    end
+
+    it 'has a helper method for each configured application' do
+      expect(subject.foo).to equal Kookaburra.configuration.applications[:foo]
+      expect(subject.bar).to equal Kookaburra.configuration.applications[:bar]
+    end
+
+    context "and then Kookaburra is reconfigured" do
+      before(:each) do
+        Kookaburra.configure {}
+      end
+      
+      it_behaves_like 'it has no individual applications configured'
+
+      it 'does not have helper methods for the previously configured applications' do
+        expect{ subject.foo }.to raise_error(NameError)
+        expect{ subject.bar }.to raise_error(NameError)
+      end
     end
   end
 end