kookaburra 0.22.3 → 0.23.0

data/README.markdown

@@ -165,29 +165,34 @@ your own UIComponents. This method exists to verify preconditions and provide
 more informative error messages; it is not intended to be used for test
 verifications.
 
+`Kookaburra::TestHelpers` provides a convenient way to make assertions about the
+mental model.  If you are using Test::Unit, see
+`Kookaburra::TestHelpers#assert_mental_model_of`; for RSpec, see
+`Kookaburra::TestHelpers#match_mental_model_of`.
+
 Given the Cucumber scenario above, here is how the test implementation layer
 might look:
 
     # step_definitions/various_steps.rb
 
     Given "I have an existing account" do
-      given.existing_account(:my_account)
+      given.existing_account
     end
 
     Given "I have previously specified default payment options" do
-      given.default_payment_options_specified_for(:my_account)
+      given.default_payment_options_specified
     end
 
     Given "I have previously specified default shipping options" do
-      given.default_shipping_options_specified_for(:my_account)
+      given.default_shipping_options_specified
     end
 
     Given "I have an item in my shopping cart" do
-      given.an_item_in_my_shopping_cart(:my_account)
+      given.an_item_in_my_shopping_cart
     end
 
     When "I sign in to my account" do
-      ui.sign_in(:my_account)
+      ui.sign_in
     end
 
     When "I choose to check out" do
@@ -199,11 +204,13 @@ might look:
     end
 
     Then "I see that my default payment options will be used" do
-      ui.order_summary.payment_options.should == k.get_data(:default_payment_options)[:my_account]
+      ui.order_summary.payment_options.should match_mental_model_of(:default_payment_options)
+      # Or if you prefer Test::Unit style assertions...
+      # assert_mental_model_matches(:default_payment_options, ui.order_summary.payment_options)
     end
 
     Then "I see that my default shipping options will be used" do
-      ui.order_summary.shipping_options.should == k.get_data(:default_shipping_options)[:my_account]
+      ui.order_summary.shipping_options.should match_mental_model_of(:default_shipping_options)
     end
 
 The step definitions contain neither explicitly shared state (instance
@@ -281,17 +288,17 @@ share a `MentalModel` instance, which is available to both of them via their
 
 The `MentalModel` instance will return a `MentalModel::Collection` for any method
 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
+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
+pair from the collection, but add it to a sub-collection (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
+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:
+Here's an example of MentalModel behavior:
 
     mental_model = MentalModel.new
 

data/VERSION

@@ -1 +1 @@
-0.22.3
+0.23.0

data/kookaburra.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "kookaburra"
-  s.version = "0.22.3"
+  s.version = "0.23.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-26"
+  s.date = "2012-04-02"
   s.description = "Cucumber + Capybara = Kookaburra? It made sense at the time."
   s.email = "johnwilger@gmail.com"
   s.extra_rdoc_files = [
@@ -37,6 +37,7 @@ Gem::Specification.new do |s|
     "lib/kookaburra/given_driver.rb",
     "lib/kookaburra/json_api_driver.rb",
     "lib/kookaburra/mental_model.rb",
+    "lib/kookaburra/mental_model_matcher.rb",
     "lib/kookaburra/test_helpers.rb",
     "lib/kookaburra/ui_driver.rb",
     "lib/kookaburra/ui_driver/ui_component.rb",
@@ -45,7 +46,9 @@ Gem::Specification.new do |s|
     "spec/kookaburra/api_driver_spec.rb",
     "spec/kookaburra/configuration_spec.rb",
     "spec/kookaburra/json_api_driver_spec.rb",
+    "spec/kookaburra/mental_model_matcher_spec.rb",
     "spec/kookaburra/mental_model_spec.rb",
+    "spec/kookaburra/test_helpers_spec.rb",
     "spec/kookaburra/ui_driver/ui_component/address_bar_spec.rb",
     "spec/kookaburra/ui_driver/ui_component_spec.rb",
     "spec/kookaburra/ui_driver_spec.rb",

data/lib/kookaburra.rb

@@ -62,10 +62,7 @@ class Kookaburra
     @ui ||= @ui_driver_class.new(@configuration)
   end
 
-  # Returns a frozen copy of the specified {MentalModel::Collection}.
-  # However, this is neither a deep copy nor a deep freeze, so it is possible
-  # that you could modify data outside of your GivenDriver or UIDriver. Just
-  # don't do that. Trust me.
+  # Returns a deep-dup of the specified {MentalModel::Collection}.
   #
   # This access is provided so that you can reference the current mental model
   # within your test implementation and make assertions about the state
@@ -74,10 +71,16 @@ class Kookaburra
   # @example
   #   given.a_widget(:foo)
   #   ui.create_a_new_widget(:bar)
-  #   ui.widget_list.widgets.should == k.get_data(:widgets).slice(:foo, :bar)
+  #   ui.widget_list.widgets.should == k.get_data(:widgets).values_at(:foo, :bar)
   #
   # @return [Kookaburra::MentalModel::Collection]
   def get_data(collection_name)
-    @configuration.mental_model.send(collection_name).dup.freeze
+    @configuration.mental_model.send(collection_name).dup
+  end
+
+  private
+
+  def __mental_model__
+    @configuration.mental_model
   end
 end

data/lib/kookaburra/configuration.rb

@@ -66,5 +66,16 @@ class Kookaburra
         @server_error_detection
       end
     end
+
+    # The parsed version of the {#app_host}
+    #
+    # This is useful if, for example, you are testing a multi-host application
+    # and need to change the hostname that will be accessed but want to keep the
+    # originally-specified port
+    #
+    # @return [URI] A URI object created from the {#app_host} string
+    def app_host_uri
+      URI.parse(app_host)
+    end
   end
 end

data/lib/kookaburra/mental_model.rb

@@ -1,5 +1,6 @@
 require 'delegate'
 require 'kookaburra/exceptions'
+require 'active_support/core_ext/hash'
 
 class Kookaburra
   # Each instance of {Kookaburra} has its own instance of MentalModel. This object
@@ -50,11 +51,13 @@ class Kookaburra
     class Collection < SimpleDelegator
       # @param [String] name The name of the collection. Used to provide
       #   helpful error messages when unknown keys are accessed.
-      def initialize(name)
+      # @param [Hash] init_data Preloads specific data into the collection
+      def initialize(name, init_data = nil)
         @name = name
         data = Hash.new do |hash, key|
           raise UnknownKeyError, "Can't find mental_model.#{@name}[#{key.inspect}]. Did you forget to set it?"
         end
+        data.merge!(init_data) unless init_data.nil?
         super(data)
       end
 
@@ -66,23 +69,6 @@ class Kookaburra
         self.object_id == other.object_id
       end
 
-      # Returns the values of multiple keys from the collection.
-      #
-      # Unlike the `Hash#slice` implementation provided by ActiveSupport, this
-      # method returns an array of the values rather than a Hash.
-      #
-      # @param keys a list of keys to fetch from the collection.
-      #
-      # @return [Array] the values matching the specified index keys
-      #
-      # @raise [Kookaburra::UnknownKeyError] if any of the specified keys have
-      #   not been set
-      def slice(*keys)
-        results = keys.map do |key|
-          self[key]
-        end
-      end
-
       # Deletes a key/value pair from the collection, and persists the deleted pair
       # in a subcollection.
       #
@@ -121,6 +107,12 @@ class Kookaburra
         move = lambda { |k,v| deleted[k] = v; true }
         super { |k,v| block.call(k,v) && move.call(k,v) }
       end
+
+      def dup
+        new_data = {}.merge(self)
+        new_data = Marshal.load(Marshal.dump(new_data))
+        self.class.new(@name, new_data)
+      end
     end
   end
 end

data/lib/kookaburra/mental_model_matcher.rb

@@ -0,0 +1,130 @@
+require 'kookaburra/mental_model'
+
+class Kookaburra
+  class MentalModel
+    # This is a custom matcher that matches the RSpec matcher API.
+    #
+    # @see Kookaburra::TestHelpers#match_mental_model_of
+    # @see Kookaburra::TestHelpers#assert_mental_model_of
+    class Matcher
+      def initialize(mental_model, collection_key)
+        @collection_key = collection_key
+
+        mental_model.send(collection_key).tap do |collection|
+          @expected   = collection
+          @unexpected = collection.deleted
+        end
+      end
+
+      # Specifies that result should be limited to the given keys from the
+      # mental model.
+      #
+      # Useful if you are looking at a filtered result. That is, your mental
+      # model contains elements { A, B, C }, but you only expect to see element
+      # A.
+      #
+      # @param [Array] collection_keys The keys used in your mental model to
+      #   reference the data
+      # @return [self]
+      def only(*collection_keys)
+        keepers = @expected.slice(*collection_keys)
+        tossers = @expected.except(*collection_keys)
+
+        @expected = keepers
+        @unexpected.merge! tossers
+
+        self
+      end
+
+      # Reads better than {#only} with no args
+      #
+      # @return [self]
+      def expecting_nothing
+        only
+      end
+
+      # The result contains everything that was expected to be found and nothing
+      # that was unexpected.
+      #
+      # (Part of the RSpec protocol for custom matchers.)
+      #
+      # @param [Array] actual This is the data observed that you are attempting
+      #   to match against the mental model.
+      # @return Boolean
+      def matches?(actual)
+        @actual = actual
+        expected_items_not_found.empty? && unexpected_items_found.empty?
+      end
+
+      # Message to be printed when observed reality does not conform to
+      # mental model.
+      #
+      # (Part of the RSpec protocol for custom matchers.)
+      #
+      # @return String
+      def failure_message_for_should
+        message = "expected #{@collection_key} to match the user's mental model, but:\n"
+        if expected_items_not_found.present?
+          message += "expected to be present:         #{pp_array(expected_items)}\n"
+          message += "the missing elements were:      #{pp_array(expected_items_not_found)}\n"
+        end
+        if unexpected_items_found.present?
+          message += "expected to not be present:     #{pp_array(unexpected_items)}\n"
+          message += "the unexpected extra elements:  #{pp_array(unexpected_items_found)}\n"
+        end
+        message
+      end
+
+      # Message to be printed when observed reality does conform to mental
+      # model, but you did not expect it to.  (To be honest, we can't think of
+      # why you would want this, but it is included for the sake of RSpec
+      # compatibility.)
+      #
+      # (Part of the RSpec protocol for custom matchers.)
+      #
+      # @return String
+      def failure_message_for_should_not
+        "expected #{@collection_key} not to match the user's mental model"
+      end
+
+      # (Part of the RSpec protocol for custom matchers.)
+      #
+      # @return String
+      def description
+        "match the user's mental model of #{@collection_key}"
+      end
+
+      private
+
+      def expected_items;   @expected.values;   end
+      def unexpected_items; @unexpected.values; end
+
+      def expected_items_not_found
+        difference_between_arrays(expected_items, @actual)
+      end
+
+      def unexpected_items_found
+        unexpected_items_not_found = difference_between_arrays(unexpected_items, @actual)
+        difference_between_arrays(unexpected_items, unexpected_items_not_found)
+      end
+
+      # (Swiped from RSpec's array matcher)
+      # Returns the difference of arrays, accounting for duplicates.
+      # e.g., difference_between_arrays([1, 2, 3, 3], [1, 2, 3]) # => [3]
+      def difference_between_arrays(array_1, array_2)
+        difference = array_1.dup
+        array_2.each do |element|
+          if index = difference.index(element)
+            difference.delete_at(index)
+          end
+        end
+        difference
+      end
+
+      def pp_array(array)
+        array = array.sort if array.all? { |e| e.respond_to?(:<=>) }
+        array.inspect
+      end
+    end
+  end
+end

data/lib/kookaburra/test_helpers.rb

@@ -1,4 +1,5 @@
 require 'kookaburra'
+require 'kookaburra/mental_model_matcher'
 require 'active_support/core_ext/module/delegation'
 
 class Kookaburra
@@ -96,5 +97,26 @@ class Kookaburra
     # @method ui
     # Delegates to {#k}
     delegate :ui, :to => :k
+
+    # RSpec-style custom matcher that compares a given array with
+    # the current state of one named collection in the mental model
+    #
+    # @see Kookaburra::MentalModel::Matcher
+    def match_mental_model_of(collection_key)
+      MentalModel::Matcher.new(k.send(:__mental_model__), collection_key)
+    end
+
+    # Custom assertion for Test::Unit-style tests
+    # (really, anything that uses #assert(predicate, message = nil))
+    #
+    # @see Kookaburra::MentalModel::Matcher
+    def assert_mental_model_matches(collection_key, actual, message = nil)
+      matcher = match_mental_model_of(collection_key)
+      result = matcher.matches?(actual)
+      return if !!result  # don't even bother
+
+      message ||= matcher.failure_message_for_should
+      assert result, message
+    end
   end
 end

data/spec/integration/test_a_rack_application_spec.rb

@@ -294,7 +294,7 @@ describe "testing a Rack application with Kookaburra" do
 
         def delete_widget(name)
           assert widget_list.visible?, "Widget list is not visible!"
-          widget_list.choose_to_delete_widget(mental_model.widgets[name])
+          widget_list.choose_to_delete_widget(mental_model.widgets.delete(name))
         end
       end
 
@@ -336,13 +336,24 @@ describe "testing a Rack application with Kookaburra" do
 
         ui.sign_in(:bob)
         ui.view_widget_list
-        ui.widget_list.widgets.should == k.get_data(:widgets).slice(:widget_a, :widget_b)
+
+        # The following two lines are two different ways to shave the yak, but
+        # the second one does more to match against the full state of the mental
+        # model, provides better failure messages, and is shorter.
+        ui.widget_list.widgets.should == k.get_data(:widgets).values_at(:widget_a, :widget_b)
+        ui.widget_list.widgets.should match_mental_model_of(:widgets)
 
         ui.create_new_widget(:widget_c, :name => 'Bar')
-        ui.widget_list.widgets.should == k.get_data(:widgets).slice(:widget_a, :widget_b, :widget_c)
+
+        # As above, these are equivalent, but the second line is preferred.
+        ui.widget_list.widgets.should == k.get_data(:widgets).values_at(:widget_a, :widget_b, :widget_c)
+        ui.widget_list.widgets.should match_mental_model_of(:widgets)
 
         ui.delete_widget(:widget_b)
-        ui.widget_list.widgets.should == k.get_data(:widgets).slice(:widget_a, :widget_c)
+
+        # As above, these are equivalent, but the second line is preferred.
+        ui.widget_list.widgets.should == k.get_data(:widgets).values_at(:widget_a, :widget_c)
+        ui.widget_list.widgets.should match_mental_model_of(:widgets)
       end
     end
   end

data/spec/kookaburra/configuration_spec.rb

@@ -15,4 +15,24 @@ describe Kookaburra::Configuration do
       subject.server_error_detection.should == block
     end
   end
+
+  describe '#app_host_uri' do
+    it 'returns a URI version of the #app_host attribute via URI.parse' do
+      URI.should_receive(:parse) \
+        .with('http://example.com') \
+        .and_return(:a_parsed_uri)
+      subject.app_host = 'http://example.com'
+      subject.app_host_uri.should == :a_parsed_uri
+    end
+
+    it 'changes if #app_host changes' do
+      URI.stub!(:parse) do |url|
+        url.to_sym
+      end
+      subject.app_host = 'http://example.com'
+      subject.app_host_uri.should == 'http://example.com'.to_sym
+      subject.app_host = 'http://foo.example.com'
+      subject.app_host_uri.should == 'http://foo.example.com'.to_sym
+    end
+  end
 end

data/spec/kookaburra/mental_model_matcher_spec.rb

@@ -0,0 +1,234 @@
+require 'kookaburra/mental_model_matcher'
+
+# Makes the specs themselves a bit less verbose. You should probably read the
+# specs first, though.
+module MentalModelMatcherMacros
+  def self.included(receiver)
+    receiver.extend ClassMethods
+  end
+
+  module ClassMethods
+    def pp_array(array)
+      array = array.sort if array.all? { |e| e.respond_to?(:<=>) }
+      array.inspect
+    end
+
+    def it_matches
+      it "matches" do
+        matcher.matches?(target).should be_true
+      end
+    end
+
+    def it_doesnt_match
+      it "doesn't match" do
+        matcher.matches?(target).should be_false
+      end
+    end
+
+    def from_line
+      '(line %d)' % caller(2).first.split(':').last
+    end
+
+    def it_complains_about_missing(missing, options)
+      expected = options[:expected]
+      it "complains about a mismatch #{from_line}" do
+        failure_msg.should include("expected widgets to match the user's mental model, but:")
+      end
+      it "says what it expected to be present #{from_line}" do
+        failure_msg.should include("expected to be present:         #{pp_array(expected)}")
+      end
+      it "complains about missing items #{from_line}" do
+        failure_msg.should include("the missing elements were:      #{pp_array(missing)}")
+      end
+    end
+
+    def it_complains_about_extra(extra, options)
+      unexpected = options[:unexpected]
+      it "complains about a mismatch #{from_line}" do
+        failure_msg.should include("expected widgets to match the user's mental model, but:")
+      end
+      it "says what it expected not to find #{from_line}" do
+        failure_msg.should include("expected to not be present:     #{pp_array(unexpected)}")
+      end
+      it "complains about extra items #{from_line}" do
+        failure_msg.should include("the unexpected extra elements:  #{pp_array(extra)}")
+      end
+    end
+  end
+
+  def matcher_for(collection_key)
+    Kookaburra::MentalModel::Matcher.new(mm, collection_key).tap do |m|
+      m.matches?(target)
+    end
+  end
+
+  def pp_array(array)
+    self.class.pp_array(array)
+  end
+end
+
+describe Kookaburra::MentalModel::Matcher do
+  include MentalModelMatcherMacros
+
+  let(:mm) { Kookaburra::MentalModel.new }
+  let(:matcher) { matcher_for(:widgets) }
+  let(:failure_msg) { matcher.failure_message_for_should }
+
+  def self.foo; 'FOO' ; end
+  def self.bar; 'BAR' ; end
+  def self.yak; 'YAK' ; end
+  let(:foo) { self.class.foo }
+  let(:bar) { self.class.bar }
+  let(:yak) { self.class.yak }
+
+  context "when mental model is [foo];" do
+    before(:each) do
+      mm.widgets[:foo] = foo
+    end
+
+    context "for [] (foo missing)" do
+      let(:target) { [] }
+      it_doesnt_match
+      it_complains_about_missing [foo], :expected => [foo]
+    end
+
+    context "for [foo] (OK: exact match)" do
+      let(:target) { [foo] }
+      it_matches
+    end
+
+    context "for [foo, bar] (OK: bar ignored)" do
+      let(:target) { [foo, bar] }
+      it_matches
+    end
+  end
+
+  context "when mental model is [];" do
+    context "for [] (OK)" do
+      let(:target) { [] }
+      it_matches
+    end
+
+    context "for [foo] (OK: foo ignored)" do
+      let(:target) { [foo] }
+      it_matches
+    end
+  end
+
+  context "when mental model is [foo, bar];" do
+    before(:each) do
+      mm.widgets[:foo] = foo
+      mm.widgets[:bar] = bar
+    end
+
+    context "for [] (foo, bar missing)" do
+      let(:target) { [] }
+      it_doesnt_match
+      it_complains_about_missing [foo, bar], :expected => [foo, bar]
+    end
+
+    context "for [foo] (bar missing)" do
+      let(:target) { [foo] }
+      it_doesnt_match
+      it_complains_about_missing [bar], :expected => [foo, bar]
+    end
+
+    context "for [foo, bar] (OK: exact match)" do
+      let(:target) { [foo, bar] }
+      it_matches
+    end
+
+    context "for [foo, bar, yak] (OK: foo, bar expected; yak ignored)" do
+      let(:target) { [foo, bar, yak] }
+      it_matches
+    end
+  end
+
+  context "when mental model is [foo], not expecting [bar];" do
+    before(:each) do
+      mm.widgets[:foo] = foo
+      mm.widgets[:bar] = bar
+      mm.widgets.delete(:bar)
+    end
+
+    context "for [] (foo missing)" do
+      let(:target) { [] }
+      it_doesnt_match
+      it_complains_about_missing [foo], :expected => [foo]
+    end
+
+    context "for [bar] (foo missing, bar deleted)" do
+      let(:target) { [bar] }
+      it_doesnt_match
+      it_complains_about_missing [foo], :expected => [foo]
+      it_complains_about_extra [bar], :unexpected => [bar]
+    end
+
+    context "for [foo, bar] (bar deleted)" do
+      let(:target) { [foo, bar] }
+      it_doesnt_match
+      it_complains_about_extra [bar], :unexpected => [bar]
+    end
+
+    context "for [foo] (OK: foo expected, bar not found)" do
+      let(:target) { [foo] }
+      it_matches
+    end
+
+    context "for [foo, yak] (OK: foo expected; yak ignored)" do
+      let(:target) { [foo, yak] }
+      it_matches
+    end
+  end
+
+  describe "postfix scoping methods" do
+    context "when mental model is [foo, bar];" do
+      before(:each) do
+        mm.widgets[:foo] = foo
+        mm.widgets[:bar] = bar
+      end
+
+      context "but scoped to .only(:foo)" do
+        let(:matcher) { matcher_for(:widgets).only(:foo) }
+
+        context "for [foo] (OK)" do
+          let(:target) { [foo] }
+          it_matches
+        end
+
+        context "for [foo, bar] (not expecting [bar])" do
+          let(:target) { [foo, bar] }
+          it_doesnt_match
+          it_complains_about_extra [bar], :unexpected => [bar]
+        end
+      end
+    end
+
+    context "when mental model is [foo];" do
+      before(:each) do
+        mm.widgets[:foo] = foo
+      end
+
+      context "but scoped with .expecting_nothing" do
+        let(:matcher) { matcher_for(:widgets).expecting_nothing }
+
+        context "for [] (OK)" do
+          let(:target) { [] }
+          it_matches
+        end
+
+        context "for [foo] (unexpected foo)" do
+          let(:target) { [foo] }
+          it_doesnt_match
+          it_complains_about_extra [foo], :unexpected => [foo]
+        end
+
+        context "for [foo, bar] (unexpected [foo]; bar ignored)" do
+          let(:target) { [foo, bar] }
+          it_doesnt_match
+          it_complains_about_extra [foo], :unexpected => [foo]
+        end
+      end
+    end
+  end
+end

data/spec/kookaburra/mental_model_spec.rb

@@ -14,12 +14,21 @@ describe Kookaburra::MentalModel do
   describe Kookaburra::MentalModel::Collection do
     let(:collection) { Kookaburra::MentalModel::Collection.new('widgets') }
 
-    describe '#slice' do
+    describe '#values_at' do
       it 'returns an array of items matching the specified keys' do
         collection[:foo] = 'foo'
         collection[:bar] = 'bar'
         collection[:baz] = 'baz'
-        collection.slice(:foo, :baz).should == %w(foo baz)
+        collection.values_at(:foo, :baz).should == %w(foo baz)
+      end
+    end
+
+    describe '#slice' do
+      it 'returns a hash of items matching the specified keys' do
+        collection[:foo] = 'foo'
+        collection[:bar] = 'bar'
+        collection[:baz] = 'baz'
+        collection.slice(:foo, :baz).should == { :foo => 'foo', :baz => 'baz' }
       end
     end
 
@@ -81,5 +90,27 @@ describe Kookaburra::MentalModel do
       lambda { collection[:foo] }.should \
         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__
+      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
+      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__
+      end
+    end
   end
 end

data/spec/kookaburra/test_helpers_spec.rb

@@ -0,0 +1,81 @@
+require 'kookaburra/test_helpers'
+
+describe Kookaburra::TestHelpers do
+  include Kookaburra::TestHelpers
+
+  before(:all) do
+    Kookaburra.configure do |c|
+      c.given_driver_class = Kookaburra::GivenDriver
+      c.ui_driver_class    = Kookaburra::UIDriver
+    end
+  end
+
+  after(:all) do
+    Kookaburra.configure do |c|
+      c.given_driver_class = nil
+      c.ui_driver_class    = nil
+    end
+  end
+
+  describe "#k" do
+    it "returns an instance of Kookaburra" do
+      k.should be_kind_of(Kookaburra)
+    end
+
+    it "memoizes" do
+      a = k; b = k
+      a.should equal(b)
+    end
+  end
+
+  describe "methods delegated to #k" do
+    it "includes #given" do
+      k.should_receive(:given)
+      given
+    end
+
+    it "includes #ui" do
+      k.should_receive(:ui)
+      ui
+    end
+  end
+
+  describe "methods related to the mental model" do
+    before(:each) do
+      mm = k.send(:__mental_model__)
+      mm.widgets[:foo] = 'FOO'
+    end
+
+    describe "#match_mental_model_of" do
+      it "does a positive match" do
+        ['FOO'].should match_mental_model_of(:widgets)
+      end
+
+      it "does a negative match" do
+        ['BAR'].should_not match_mental_model_of(:widgets)
+      end
+    end
+
+    describe "#assert_mental_model_matches" do
+      it "does a positive assertion" do
+        actual = ['FOO']
+        actual.should match_mental_model_of(:widgets) # Sanity check
+        self.should_receive(:assert).never
+        self.assert_mental_model_matches(:widgets, actual)
+      end
+
+      it "does a negative assertion" do
+        actual = ['BAR']
+        self.should_receive(:assert).with(false, kind_of(String))
+        self.assert_mental_model_matches(:widgets, actual)
+      end
+
+      it "does a negative assertion with a custom message" do
+        actual = ['YAK']
+        psa = 'Put the razor down and step away!'
+        self.should_receive(:assert).with(false, psa)
+        self.assert_mental_model_matches(:widgets, actual, psa)
+      end
+    end
+  end
+end

data/spec/kookaburra_spec.rb

@@ -30,18 +30,12 @@ describe Kookaburra do
   end
 
   describe '#get_data' do
-    it 'returns a equivalent copy of the test data collection specified' do
-      foos = {:spam => 'ham'}
-      configuration.stub!(:mental_model => stub(:foos => foos))
-      k.get_data(:foos).should == foos
-    end
-
-    it 'does not return the same object that is the test data collection' do
-      k.get_data(:foos).should_not === k.get_data(:foos)
-    end
-
-    it 'returns a frozen object' do
-      k.get_data(:foos).should be_frozen
+    it 'returns a dup of the specified MentalModel::Collection' do
+      collection = stub('MentalModel::Collection')
+      collection.should_receive(:dup) \
+        .and_return(:mental_model_collection_dup)
+      configuration.stub!(:mental_model => stub(:foos => collection))
+      k.get_data(:foos).should == :mental_model_collection_dup
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kookaburra
 version: !ruby/object:Gem::Version 
-  hash: 65
+  hash: 67
   prerelease: 
   segments: 
   - 0
-  - 22
-  - 3
-  version: 0.22.3
+  - 23
+  - 0
+  version: 0.23.0
 platform: ruby
 authors: 
 - John Wilger
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-26 00:00:00 Z
+date: 2012-04-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -205,6 +205,7 @@ files:
 - lib/kookaburra/given_driver.rb
 - lib/kookaburra/json_api_driver.rb
 - lib/kookaburra/mental_model.rb
+- lib/kookaburra/mental_model_matcher.rb
 - lib/kookaburra/test_helpers.rb
 - lib/kookaburra/ui_driver.rb
 - lib/kookaburra/ui_driver/ui_component.rb
@@ -213,7 +214,9 @@ files:
 - spec/kookaburra/api_driver_spec.rb
 - spec/kookaburra/configuration_spec.rb
 - spec/kookaburra/json_api_driver_spec.rb
+- spec/kookaburra/mental_model_matcher_spec.rb
 - spec/kookaburra/mental_model_spec.rb
+- spec/kookaburra/test_helpers_spec.rb
 - spec/kookaburra/ui_driver/ui_component/address_bar_spec.rb
 - spec/kookaburra/ui_driver/ui_component_spec.rb
 - spec/kookaburra/ui_driver_spec.rb