kookaburra 0.20.0 → 0.21.0

data/README.markdown

@@ -30,7 +30,7 @@ server could be running on the same machine, it doesn't need to be), and it is
 the responsibility of the test implementation to ensure that the server is
 running. Take a look at Kookaburra's own integration specs for one example of
 how to achieve this for a [Rack-based] [Rack] application. (Note that you cannot
-easily start the application server in a seperate thread. Because Ruby uses
+easily start the application server in a separate thread. Because Ruby uses
 green threads, the HTTP library used in the APIDriver will block while making
 its requests and prevent the application server thread from responding.)
 
@@ -284,6 +284,13 @@ called on the object. The `MentalModel::Collection` object behaves like a `Hash`
 for the most part, however it will raise a `Kookaburra::UnknownKeyError` if you
 try to access a key that has not yet been assigned a value.
 
+Deletions (via `#delete` or `#delete_if`) will actually remove the key/value
+pair from the collection, but add it to a subcollection (available at
+`MentalModel::Collection#deleted`). This reflects the fact that the user's
+mental model of the dataset would also include any intentional exceptions -
+the user will, for example,  want to verify that an item they deleted does
+not appear to be available in the system.
+
 Here's a quick example of MentalModel behavor:
 
     mental_model = MentalModel.new
@@ -292,10 +299,20 @@ Here's a quick example of MentalModel behavor:
 
     mental_model.widgets[:widget_a]
     #=> {'name' => 'Widget A'}
-    
+
     # this will raise a Kookaburra::UnknownKeyError
     mental_model.widgets[:widget_b]
 
+    mental_model.widgets.delete(:widget_a)
+    #=> {'name' => 'Widget A'}
+
+    # this will now also raise a Kookaburra::UnknownKeyError...
+    mental_model.widgets[:widget_a]
+
+    # ...but the pair is now available here:
+    mental_model.widgets.deleted[:widget_a]
+    #=> {'name' => 'Widget A'}
+
 #### Given Driver ####
 
 The `Kookaburra::GivenDriver` is used to create a particular "preexisting" state

data/VERSION

@@ -1 +1 @@
-0.20.0
+0.21.0

data/kookaburra.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "kookaburra"
-  s.version = "0.20.0"
+  s.version = "0.21.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Wilger", "Sam Livingston-Gray", "Ravi Gadad"]
-  s.date = "2012-03-22"
+  s.date = "2012-03-25"
   s.description = "Cucumber + Capybara = Kookaburra? It made sense at the time."
   s.email = "johnwilger@gmail.com"
   s.extra_rdoc_files = [

data/lib/kookaburra/mental_model.rb

@@ -1,4 +1,5 @@
 require 'delegate'
+require 'kookaburra/exceptions'
 
 class Kookaburra
   # Each instance of {Kookaburra} has its own instance of MentalModel. This object
@@ -81,6 +82,45 @@ class Kookaburra
           self[key]
         end
       end
+
+      # Deletes a key/value pair from the collection, and persists the deleted pair
+      # in a subcollection.
+      #
+      # Deleting a key/value pair from a collection on the MentalModel works just
+      # like `Hash#delete` but with a side effect - deleted members are added to
+      # a subcollection, accessible at `#deleted`.
+      #
+      # @param key the key to delete from the collection
+      #
+      # @return the value of the deleted key/value pair
+      #
+      # @raise [Kookaburra::UnknownKeyError] if the specified key has not been set
+      def delete(key, &block)
+        self[key] # simple fetch to possibly trigger UnknownKeyError
+        deleted[key] = super
+      end
+
+      # Finds or initializes, and returns, the subcollection of deleted items
+      #
+      # Key/value pairs `#delete`d from a collection on the MentalModel will be added
+      # to this subcollection.
+      #
+      # @return [Kookaburra::MentalModel::Collection] the deleted items subcollection
+      def deleted
+        @deleted ||= self.class.new("deleted")
+      end
+
+      # Deletes key/value pairs from the collection for which the given block evaluates
+      # to true, and persists all deleted pairs in a subcollection.
+      #
+      # Works just like `Hash#delete_if` but with a side effect - deleted members are
+      # added to a subcollection, accessible at `#deleted`.
+      #
+      # @return [Hash] the key/value pairs still remaining after the deletion
+      def delete_if(&block)
+        move = lambda { |k,v| deleted[k] = v; true }
+        super { |k,v| block.call(k,v) && move.call(k,v) }
+      end
     end
   end
 end

data/lib/kookaburra/null_browser.rb

@@ -1,4 +1,5 @@
 require 'basic_object'
+require 'kookaburra/exceptions'
 
 class Kookaburra
   # If you don't specify a browser in your {Kookaburra#configuration} but you

data/lib/kookaburra/ui_driver.rb

@@ -36,6 +36,25 @@ class Kookaburra
   #       end
   #     end
   #   end
+  #
+  # With larger applications, it may be beneficial to break down your business
+  # actions into multiple classes. The top-level {UIDriver} can have sub-drivers
+  # associated with it (and those can have sub-drivers, too; but let's not get
+  # carried away, eh?):
+  #
+  #   class AccountManagementDriver < Kookaburra::UIDriver
+  #     ui_component :account_list, AccountList
+  #     # ...
+  #   end
+  #
+  #   class MyUIDriver < Kookaburra::UIDriver
+  #     ui_driver :account_management, AccountManagementDriver
+  #     # ...
+  #   end
+  #
+  # In your test implementation, you can then do (among other things):
+  #
+  #   ui.account_management.account_list.should be_visible
   class UIDriver
     extend DependencyAccessor
 
@@ -48,8 +67,19 @@ class Kookaburra
       #   this component.
       def ui_component(component_name, component_class)
         define_method(component_name) do
-          component_class.new(:browser => @browser, :server_error_detection => @server_error_detection,
-                              :app_host => @app_host)
+          component_class.new(options.slice(:browser, :server_error_detection, :app_host))
+        end
+      end
+
+      # Tells the UIDriver about sub-drivers (other {UIDriver} subclasses).
+      #
+      # @param [Symbol] driver_name Will create an instance method of this
+      #   name that returns an instance of the driver_class
+      # @param [Class] driver_class The {UIDriver} subclass that defines
+      #   this driver.
+      def ui_driver(driver_name, driver_class)
+        define_method(driver_name) do
+          driver_class.new(options.slice(:browser, :server_error_detection, :app_host, :mental_model))
         end
       end
     end
@@ -66,14 +96,15 @@ class Kookaburra
     #   `:browser` object and should return `true` if the page indicates a server
     #   error has occured
     def initialize(options = {})
-      @browser = options[:browser]
-      @app_host = options[:app_host]
+      @options = options
       @mental_model = options[:mental_model]
-      @server_error_detection = options[:server_error_detection]
     end
 
     protected
 
+    # Provides access to the options with which the object was initialized
+    attr_reader :options
+
     # @attribute [r] mental_model
     dependency_accessor :mental_model
   end

data/lib/kookaburra/ui_driver/ui_component.rb

@@ -1,4 +1,5 @@
 require 'kookaburra/exceptions'
+require 'active_support/core_ext/object/try'
 
 class Kookaburra
   class UIDriver

data/spec/kookaburra/mental_model_spec.rb

@@ -23,6 +23,60 @@ describe Kookaburra::MentalModel do
       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)
+      end
+
+      it 'persists the deleted key/value pair to the #deleted subcollection' do
+        collection[:baz] = 'baz'
+        collection.delete(:baz)
+        collection.deleted[:baz].should == 'baz'
+      end
+
+      it 'raises a Kookaburra::UnknownKeyError exception if trying to delete a missing key' do
+        lambda { collection.delete(:snerf) }.should \
+          raise_error(Kookaburra::UnknownKeyError, "Can't find mental_model.widgets[:snerf]. Did you forget to set it?")
+      end
+    end
+
+    describe '#delete_if' do
+      before(:each) do
+        collection[:foo] = 'foo'
+        collection[:bar] = 'spoon'
+        collection[:baz] = 'baz'
+      end
+
+      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]
+      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]
+      end
+
+      it 'returns hash of items not deleted' do
+        collection.delete_if { |k,v| k.to_s != v }.should == { :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).with("deleted")
+        initialized_collection.deleted
+      end
+
+      it 'returns the deleted subcollection if already initialized' do
+        deleted_collection = collection.deleted
+        collection.deleted.should === deleted_collection
+      end
+    end
+
     it 'raises a Kookaburra::UnknownKeyError exception for #[] with a missing key' do
       lambda { collection[:foo] }.should \
         raise_error(Kookaburra::UnknownKeyError, "Can't find mental_model.widgets[:foo]. Did you forget to set it?")

data/spec/kookaburra/ui_driver_spec.rb

@@ -20,6 +20,24 @@ describe Kookaburra::UIDriver do
     end
   end
 
+  describe '.ui_driver' do
+    it 'adds an accessor method for the named driver that defaults to an instance of the specified class' do
+      foo_driver_class = mock(Class)
+      foo_driver_class.should_receive(:new) \
+        .with(:browser => :a_browser, :server_error_detection => :server_error_detection,
+              :app_host => :a_url, :mental_model => :a_mental_model) \
+        .and_return(:a_foo_driver)
+
+      ui_driver_class = Class.new(Kookaburra::UIDriver) do
+        ui_driver :foo, foo_driver_class
+      end
+
+      ui = ui_driver_class.new(:browser => :a_browser, :server_error_detection => :server_error_detection,
+                               :app_host => :a_url, :mental_model => :a_mental_model)
+      ui.foo.should == :a_foo_driver
+    end
+  end
+
   describe 'dependency accessors' do
     let(:subject_class) { Kookaburra::UIDriver }
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kookaburra
 version: !ruby/object:Gem::Version 
-  hash: 79
+  hash: 75
   prerelease: 
   segments: 
   - 0
-  - 20
+  - 21
   - 0
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors: 
 - John Wilger
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-22 00:00:00 Z
+date: 2012-03-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement