kookaburra 1.3.1 → 2.0.0

data/lib/kookaburra/api_driver.rb

@@ -1,214 +1,65 @@
-require 'restclient'
-require 'core_ext/object/to_query'
-require 'kookaburra/exceptions'
+require 'forwardable'
 
 class Kookaburra
-  # Communicate with a Web Services API
+  # Your APIDriver subclass is used to define your testing DSL for setting up
+  # test preconditions. Unlike {Kookaburra::APIClient}, which is meant to be a
+  # simple mapping to your application's API, a method in the APIDriver may be
+  # comprised of several distinct API calls as well as access to Kookaburra's
+  # test data store via {#mental_model}.
   #
-  # You will create a subclass of {APIDriver} in your testing
-  # implementation to be used with you subclass of
-  # {Kookaburra::GivenDriver}. While the {GivenDriver} implements the
-  # "business domain" DSL for setting up your application state, the
-  # {APIDriver} maps discreet operations to your application's web
-  # service API and can (optionally) handle encoding input data and
-  # decoding response bodies to and from your preferred serialization
-  # format.
+  # @abstract Subclass and implement your Given DSL.
+  #
+  # @example APIDriver subclass
+  #   module MyApp
+  #     module Kookaburra
+  #       class APIDriver < ::Kookaburra::APIDriver
+  #         def api
+  #           @api ||= APIClient.new(configuration)
+  #         end
+  #
+  #         def a_widget(name, attributes = {})
+  #           # Set up the data that will be passed to the API by merging any
+  #           # passed attributes into the default data.
+  #           data = {:name => 'Foo', :description => 'Bar baz'}.merge(attributes)
+  #
+  #           # Call the API method and get the resulting response as Ruby data.
+  #           result = api.create_widget(data)
+  #
+  #           # Store the resulting widget data in the MentalModel object, so that
+  #           # it can be referenced in other operations.
+  #           mental_model.widgets[name] = result
+  #         end
+  #       end
+  #     end
+  #   end
   class APIDriver
-    class << self
-      # Serializes input data
-      #
-      # If specified, any input data provided to {APIDriver#post},
-      # {APIDriver#put} or {APIDriver#request} will be processed through
-      # this function prior to being sent to the HTTP server.
-      #
-      # @yieldparam data [Object] The data parameter that was passed to
-      #             the request method
-      # @yieldreturn [String] The text to be used as the request body
-      #
-      # @example
-      #   class MyAPIDriver < Kookaburra::APIDriver
-      #     encode_with { |data| JSON.dump(data) }
-      #     # ...
-      #   end
-      def encode_with(&block)
-        define_method(:encode) do |data|
-          return if data.nil?
-          block.call(data)
-        end
-      end
-
-      # Deserialize response body
-      #
-      # If specified, the response bodies of all requests made using
-      # this {APIDriver} will be processed through this function prior
-      # to being returned.
-      #
-      # @yieldparam data [String] The response body sent by the HTTP
-      #             server
-      #
-      # @yieldreturn [Object] The result of parsing the response body
-      #              through this function
-      #
-      # @example
-      #   class MyAPIDriver < Kookaburra::APIDriver
-      #     decode_with { |data| JSON.parse(data) }
-      #     # ...
-      #   end
-      def decode_with(&block)
-        define_method(:decode) do |data|
-          block.call(data)
-        end
-      end
+    extend Forwardable
 
-      # Set custom HTTP headers
-      #
-      # Can be called multiple times to set HTTP headers that will be
-      # provided with every request made by the {APIDriver}.
-      #
-      # @param [String] name The name of the header, e.g. 'Content-Type'
-      # @param [String] value The value to which the header is set
-      #
-      # @example
-      #   class MyAPIDriver < Kookaburra::APIDriver
-      #     header 'Content-Type', 'application/json'
-      #     header 'Accept', 'application/json'
-      #     # ...
-      #   end
-      def header(name, value)
-        headers[name] = value
-      end
-
-      # Used to retrieve the list of headers within the instance. Not
-      # intended to be used elsewhere.
-      #
-      # @private
-      def headers
-        @headers ||= {}
-      end
-    end
-
-    # Create a new {APIDriver} instance
+    # It is unlikely that you would call #initialize yourself; your APIDriver
+    # object is instantiated for you by {Kookaburra#given}.
     #
     # @param [Kookaburra::Configuration] configuration
-    # @param [RestClient] http_client (optional) Generally only
-    #        overriden when testing Kookaburra itself
-    def initialize(configuration, http_client = RestClient)
+    def initialize(configuration)
       @configuration = configuration
-      @http_client = http_client
     end
 
-    # Convenience method to make a POST request
-    #
-    # @see APIDriver#request
-    def post(path, data = nil, headers = {})
-      request(:post, path, data, headers)
-    end
+    protected
 
-    # Convenience method to make a PUT request
-    #
-    # @see APIDriver#request
-    def put(path, data = nil, headers = {})
-      request(:put, path, data, headers)
-    end
+    attr_reader :configuration
 
-    # Convenience method to make a GET request
+    # Access to the shared {Kookaburra::MentalModel} instance
     #
-    # @see APIDriver#request
-    def get(path, data = nil, headers = {})
-      path = add_querystring_to_path(path, data)
-      request(:get, path, nil, headers)
-    end
+    # @attribute [rw] mental_model
+    def_delegator :configuration, :mental_model
 
-    # Convenience method to make a DELETE request
-    #
-    # @see APIDriver#request
-    def delete(path, data = nil, headers = {})
-      path = add_querystring_to_path(path, data)
-      request(:delete, path, nil, headers)
-    end
-
-    # Make an HTTP request
-    #
-    # If you need to make a request other than the typical GET, POST,
-    # PUT and DELETE, you can use this method directly.
-    #
-    # This *will* follow redirects when the server's response code is in
-    # the 3XX range. If the response is a 303, the request will be
-    # transformed into a GET request.
-    #
-    # @see APIDriver.encode_with
-    # @see APIDriver.decode_with
-    # @see APIDriver.header
-    # @see APIDriver#get
-    # @see APIDriver#post
-    # @see APIDriver#put
-    # @see APIDriver#delete
+    # Used to access your APIClient in your own APIDriver implementation
     #
-    # @param [Symbol] method The HTTP verb to use with the request
-    # @param [String] path The path to request. Will be joined with the
-    #        {Kookaburra::Configuration#app_host} setting to build the
-    #        URL unless a full URL is specified here.
-    # @param [Object] data The data to be posted in the request body. If
-    #        an encoder was specified, this can be any type of object as
-    #        long as the encoder can serialize it into a String. If no
-    #        encoder was specified, then this can be one of:
-    #
-    #        * a String - will be passed as is
-    #        * a Hash - will be encoded as normal HTTP form params
-    #        * a Hash containing references to one or more Files - will
-    #          set the content type to multipart/form-data
-    #
-    # @return [Object] The response body returned by the server. If a
-    #         decoder was specified, this will return the result of
-    #         parsing the response body through the decoder function.
-    #
-    # @raise [Kookaburra::UnexpectedResponse] Raised if the HTTP
-    #        response received is not in the 2XX-3XX range.
-    def request(method, path, data, headers)
-      data = encode(data)
-      headers = global_headers.merge(headers)
-      response = @http_client.send(method, url_for(path), *[data, headers].compact)
-      decode(response.body)
-    rescue RestClient::Exception => e
-      raise_unexpected_response(e)
-    end
-
-    private
-
-    def add_querystring_to_path(path, data)
-      return path if data.nil? || data == {}
-      "#{path}?#{data.to_query}"
-    end
-
-    def global_headers
-      self.class.headers
-    end
-
-    def url_for(path)
-      URI.join(base_url, path).to_s
-    end
-
-    def base_url
-      @configuration.app_host
-    end
-
-    def encode(data)
-      data
-    end
-
-    def decode(data)
-      data
-    end
-
-    def raise_unexpected_response(exception)
-      message = <<-END
-      Unexpected response from server: #{exception.message}
-
-      #{exception.http_body}
-      END
-      new_exception = UnexpectedResponse.new(message)
-      new_exception.set_backtrace(exception.backtrace)
-      raise new_exception
+    # @abstract
+    # @return [Kookaburra::APIClient]
+    # @raise [Kookaburra::ConfigurationError] raised if you do not provide an
+    #   implementation.
+    def api
+      raise ConfigurationError, "You must implement #api in your subclass."
     end
   end
 end

data/lib/kookaburra/configuration.rb

@@ -7,12 +7,12 @@ class Kookaburra
   class Configuration
     extend DependencyAccessor
 
-    # The class to use as your GivenDriver
+    # The class to use as your APIDriver
     #
-    # @attribute [rw] given_driver_class
+    # @attribute [rw] api_driver_class
     # @raise [Kookaburra::ConfigurationError] if you try to read this attribute
     #   without it having been set
-    dependency_accessor :given_driver_class
+    dependency_accessor :api_driver_class
 
     # The class to use as your UIDriver
     #
@@ -39,7 +39,7 @@ class Kookaburra
     dependency_accessor :app_host
 
     # This is the {Kookaburra::MentalModel} that is shared between your
-    # GivenDriver and your UIDriver. This attribute is managed by {Kookaburra},
+    # APIDriver and your UIDriver. This attribute is managed by {Kookaburra},
     # so you shouldn't need to change it yourself.
     #
     # @attribute [rw] mental_model

data/lib/kookaburra/mental_model.rb

@@ -4,7 +4,7 @@ require 'kookaburra/exceptions'
 class Kookaburra
   # Each instance of {Kookaburra} has its own instance of MentalModel. This object
   # is used to maintain a shared understanding of the application state between
-  # your {GivenDriver} and your {UIDriver}. You can access the various test data
+  # your {APIDriver} and your {UIDriver}. You can access the various test data
   # collections in your test implementations via {Kookaburra#get_data}.
   #
   # The mental model is not intended to represent a copy of all of the data
@@ -48,11 +48,13 @@ class Kookaburra
     #   # Raises an UnknownKeyError
     #   mental_model.widgets[:bar]
     class Collection < SimpleDelegator
+      attr_reader :name
+
       # @param [String] name The name of the collection. Used to provide
       #   helpful error messages when unknown keys are accessed.
       # @param [Hash] init_data Preloads specific data into the collection
       def initialize(name, init_data = nil)
-        @name = name
+        self.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
@@ -119,7 +121,7 @@ class Kookaburra
       #
       # @return [Kookaburra::MentalModel::Collection] the deleted items subcollection
       def deleted
-        @deleted ||= self.class.new("deleted")
+        @deleted ||= self.class.new("#{name}.deleted")
       end
 
       # Deletes key/value pairs from the collection for which the given block evaluates
@@ -137,8 +139,18 @@ class Kookaburra
       def dup
         new_data = {}.merge(self)
         new_data = Marshal.load(Marshal.dump(new_data))
-        self.class.new(@name, new_data)
+        self.class.new(@name, new_data).tap do |mm|
+          mm.deleted = deleted.dup unless deleted.empty?
+        end
       end
+
+      protected
+
+      attr_writer :deleted
+
+      private
+
+      attr_writer :name
     end
   end
 end

data/lib/kookaburra/test_helpers.rb

@@ -1,6 +1,5 @@
 require 'forwardable'
 require 'kookaburra'
-require 'kookaburra/mental_model_matcher'
 
 class Kookaburra
   # This module is intended to be mixed in to your testing context to provide
@@ -11,12 +10,12 @@ class Kookaburra
   # @example RSpec setup
   #   # in 'spec/support/kookaburra_setup.rb'
   #   require 'kookaburra/test_helpers'
-  #   require 'my_app/kookaburra/given_driver'
+  #   require 'my_app/kookaburra/api_driver'
   #   require 'my_app/kookaburra/ui_driver'
-  #   
+  #
   #   Kookaburra.configure do |c|
-  #     c.given_driver_class = myapp::kookaburra::givendriver,
-  #     c.ui_driver_class = myapp::kookaburra::uidriver,
+  #     c.api_driver_class = MyApp::Kookaburra::APIDriver,
+  #     c.ui_driver_class = MyApp::Kookaburra::UIDriver,
   #     c.app_host = 'http://my_app.example.com:12345',
   #     c.browser = capybara,
   #     c.server_error_detection { |browser|
@@ -31,9 +30,9 @@ class Kookaburra
   #   # in 'spec/request/some_feature_spec.rb'
   #   describe "Some Feature" do
   #     example "some test script" do
-  #       given.a_widget(:foo)
-  #       given.a_widget(:bar, :hidden => true)
-  #       given.a_widget(:baz)
+  #       api.create_widget(:foo)
+  #       api.create_widget(:bar, :hidden => true)
+  #       api.create_widget(:baz)
   #
   #       ui.view_list_of_widgets
   #
@@ -48,12 +47,12 @@ class Kookaburra
   # @example Cucumber setup
   #   # in 'features/support/kookaburra_setup.rb'
   #   require 'kookaburra/test_helpers'
-  #   require 'my_app/kookaburra/given_driver'
+  #   require 'my_app/kookaburra/api_driver'
   #   require 'my_app/kookaburra/ui_driver'
-  #   
+  #
   #   Kookaburra.configure do |c|
-  #     c.given_driver_class = myapp::kookaburra::givendriver,
-  #     c.ui_driver_class = myapp::kookaburra::uidriver,
+  #     c.api_driver_class = MyApp::Kookaburra::APIDriver,
+  #     c.ui_driver_class = MyApp::Kookaburra::UIDriver,
   #     c.app_host = 'http://my_app.example.com:12345',
   #     c.browser = capybara,
   #     c.server_error_detection { |browser|
@@ -65,11 +64,11 @@ class Kookaburra
   #
   #   # in 'features/step_definitions/some_steps.rb
   #   Given /^there is a widget, "(\w+)"/ do |name|
-  #     given.a_widget(name.to_sym)
+  #     api.create_widget(name.to_sym)
   #   end
   #
   #   Given /^there is a hidden widget, "(\w+)"/ do |name|
-  #     given.a_widget(name.to_sym, :hidden => true)
+  #     api.create_widget(name.to_sym, :hidden => true)
   #   end
   #
   #   When /^I view the widget list/ do
@@ -92,33 +91,12 @@ class Kookaburra
       @k ||= Kookaburra.new
     end
 
-    # @method given
+    # @method api
     # Delegates to {#k}
-    def_delegator :k, :given
+    def_delegator :k, :api
 
     # @method ui
     # Delegates to {#k}
     def_delegator :k, :ui
-
-    # 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/lib/kookaburra/version.rb

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

data/spec/integration/test_a_rack_application_spec.rb

@@ -1,352 +1,17 @@
 require 'kookaburra/test_helpers'
-require 'kookaburra/api_driver'
+require 'kookaburra/api_client'
 require 'kookaburra/rack_app_server'
 require 'capybara'
 require 'capybara/webkit'
 require 'uuid'
 
-# These are required for the Rack app used for testing
-require 'sinatra/base'
-require 'json'
+require 'support/json_api_app_and_kookaburra_drivers'
 
 describe "testing a Rack application with Kookaburra" do
   include Kookaburra::TestHelpers
 
   describe "with an HTML interface" do
     describe "with a JSON API" do
-      # This is the fixture Rack application against which the integration
-      # test will run. It uses class variables to persist data, because
-      # Sinatra will instantiate a new instance of TestRackApp for each
-      # request.
-      class JsonApiApp < Sinatra::Base
-        enable :sessions
-        disable :show_exceptions
-
-        def parse_json_req_body
-          request.body.rewind
-          JSON.parse(request.body.read, :symbolize_names => true)
-        end
-
-        post '/users' do
-          user_data = parse_json_req_body
-          @@users ||= {}
-          @@users[user_data[:email]] = user_data
-          status 201
-          headers 'Content-Type' => 'application/json'
-          body user_data.to_json
-        end
-
-        post '/session' do
-          user = @@users[params[:email]]
-          if user && user[:password] == params[:password]
-            session[:logged_in] = true
-            status 200
-            body 'You are logged in!'
-          else
-            session[:logged_in] = false
-            status 403
-            body 'Log in failed!'
-          end
-        end
-
-        get '/session/new' do
-          body <<-EOF
-            <html>
-              <head>
-                <title>Sign In</title>
-              </head>
-              <body>
-                <div id="sign_in_screen">
-                  <form action="/session" method="POST">
-                    <label for="email">Email:</label>
-                    <input id="email" name="email" type="text" />
-
-                    <label for="password">Password:</label>
-                    <input id="password" name="password" type="password" />
-
-                    <input type="submit" value="Sign In" />
-                  </form>
-                </div>
-              </body>
-            </html>
-          EOF
-        end
-
-        post '/widgets/:widget_id' do
-          @@widgets.delete_if do |w|
-            w[:id] == params['widget_id']
-          end
-          redirect to('/widgets')
-        end
-
-        get '/widgets/new' do
-          body <<-EOF
-            <html>
-              <head>
-                <title>New Widget</title>
-              </head>
-              <body>
-                <div id="widget_form">
-                  <form action="/widgets" method="POST">
-                    <label for="name">Name:</label>
-                    <input id="name" name="name" type="text" />
-
-                    <input type="submit" value="Save" />
-                  </form>
-                </div>
-              </body>
-            </html>
-          EOF
-        end
-
-        post '/widgets' do
-          @@widgets ||= []
-          widget_data = if request.media_type == 'application/json'
-                          parse_json_req_body
-                        else
-                          {:name => params['name']}
-                        end
-          widget_data[:id] = UUID.new.generate
-          @@widgets << widget_data
-          @@last_widget_created = widget_data
-          request.accept.each do |type|
-            case type.to_s
-            when 'application/json'
-              status 201
-              headers 'Content-Type' => 'application/json'
-              halt widget_data.to_json
-            else
-              halt redirect to('/widgets')
-            end
-          end
-        end
-
-        get '/widgets' do
-          raise "Not logged in!" unless session[:logged_in]
-          @@widgets ||= []
-          last_widget_created, @@last_widget_created = @@last_widget_created, nil
-          content = ''
-          content << <<-EOF
-          <html>
-            <head>
-              <title>Widgets</title>
-            </head>
-            <body>
-              <div id="widget_list">
-          EOF
-          if last_widget_created
-            content << <<-EOF
-                  <div class="last_widget created">
-                    <span class="id">#{last_widget_created[:id]}</span>
-                    <span class="name">#{last_widget_created[:name]}</span>
-                  </div>
-            EOF
-          end
-          content << <<-EOF
-                <ul>
-          EOF
-          @@widgets.each do |w|
-            content << <<-EOF
-                  <li class="widget_summary">
-                    <span class="id">#{w[:id]}</span>
-                    <span class="name">#{w[:name]}</span>
-                    <form id="delete_#{w[:id]}" action="/widgets/#{w[:id]}" method="POST">
-                      <button type="submit" value="Delete" />
-                    </form>
-                  </li>
-            EOF
-          end
-          content << <<-EOF
-                </ul>
-                <a href="/widgets/new">New Widget</a>
-              </div>
-            </body>
-          </html>
-          EOF
-          body content
-        end
-
-        get '/error_page' do
-          content = <<-EOF
-            <html>
-              <head>
-                <title>Internal Server Error</title>
-              </head>
-              <body>
-                <p>A Purposeful Error</p>
-              </body>
-            </html>
-          EOF
-          body content
-        end
-
-        error do
-          e = request.env['sinatra.error']
-          body << <<-EOF
-          <html>
-            <head>
-              <title>Internal Server Error</title>
-            </head>
-            <body>
-              <pre>
-          #{e.to_s}\n#{e.backtrace.join("\n")}
-              </pre>
-            </body>
-          </html>
-          EOF
-        end
-      end
-
-      class MyAPIDriver < Kookaburra::APIDriver
-        encode_with { |data| JSON.dump(data) }
-        decode_with { |data| JSON.parse(data) }
-        header 'Content-Type', 'application/json'
-        header 'Accept', 'application/json'
-
-        def create_user(user_data)
-          post '/users', user_data
-        end
-
-        def create_widget(widget_data)
-          post '/widgets', widget_data
-        end
-      end
-
-      class MyGivenDriver < Kookaburra::GivenDriver
-        def api
-          MyAPIDriver.new(configuration)
-        end
-
-        def a_user(name)
-          user = {'email' => 'bob@example.com', 'password' => '12345'}
-          result = api.create_user(user)
-          mental_model.users[name] = result
-        end
-
-        def a_widget(name, attributes = {})
-          widget = {'name' => 'Foo'}.merge(attributes)
-          result = api.create_widget(widget)
-          mental_model.widgets[name] = result
-        end
-      end
-
-      class SignInScreen < Kookaburra::UIDriver::UIComponent
-        def component_path
-          '/session/new'
-        end
-
-        # Use default component locator value
-        #
-        # def component_locator
-        #   '#sign_in_screen'
-        # end
-
-        def sign_in(user_data)
-          fill_in 'Email:', :with => user_data['email']
-          fill_in 'Password:', :with => user_data['password']
-          click_button 'Sign In'
-        end
-      end
-
-      class ErrorPage < Kookaburra::UIDriver::UIComponent
-        def component_path
-          '/error_page'
-        end
-      end
-
-      class WidgetDataContainer
-        def initialize(element)
-          @element = element
-        end
-
-        def to_hash
-          {
-            'id' => @element.find('.id').text,
-            'name' => @element.find('.name').text
-          }
-        end
-      end
-
-      class LastWidgetCreated < Kookaburra::UIDriver::UIComponent
-        def component_locator
-          @options[:component_locator]
-        end
-
-        def data
-          raise "Foo" unless visible?
-          WidgetDataContainer.new(self).to_hash
-        end
-      end
-
-      class WidgetList < Kookaburra::UIDriver::UIComponent
-        ui_component :last_widget_created, LastWidgetCreated, :component_locator => '#widget_list .last_widget.created'
-
-        def component_path
-          '/widgets'
-        end
-
-        def component_locator
-          '#widget_list'
-        end
-
-        def widgets
-          all('.widget_summary').map do |el|
-            WidgetDataContainer.new(el).to_hash
-          end
-        end
-
-        def choose_to_create_new_widget
-          click_on 'New Widget'
-        end
-
-        def choose_to_delete_widget(widget_data)
-          find("#delete_#{widget_data['id']}").click_button('Delete')
-        end
-      end
-
-      class WidgetForm < Kookaburra::UIDriver::UIComponent
-        def component_locator
-          '#widget_form'
-        end
-
-        def submit(widget_data)
-          fill_in 'Name:', :with => widget_data['name']
-          click_on 'Save'
-        end
-      end
-
-      class MyUIDriver < Kookaburra::UIDriver
-        ui_component :error_page, ErrorPage
-        ui_component :sign_in_screen, SignInScreen
-        ui_component :widget_list, WidgetList
-        ui_component :widget_form, WidgetForm
-
-        def sign_in(name)
-          address_bar.go_to sign_in_screen
-          sign_in_screen.sign_in(mental_model.users[name])
-        end
-
-        def error_on_purpose
-          address_bar.go_to error_page
-        end
-
-        def view_widget_list
-          address_bar.go_to widget_list
-        end
-
-        def create_new_widget(name, attributes = {})
-          assert widget_list.visible?, "Widget list is not visible!"
-          widget_list.choose_to_create_new_widget
-          widget_form.submit('name' => 'My Widget')
-          mental_model.widgets[name] = widget_list.last_widget_created.data
-        end
-
-        def delete_widget(name)
-          assert widget_list.visible?, "Widget list is not visible!"
-          widget_list.choose_to_delete_widget(mental_model.widgets.delete(name))
-        end
-      end
-
       app_server = Kookaburra::RackAppServer.new do
         JsonApiApp.new
       end
@@ -356,7 +21,7 @@ describe "testing a Rack application with Kookaburra" do
 
         Kookaburra.configure do |c|
           c.ui_driver_class = MyUIDriver
-          c.given_driver_class = MyGivenDriver
+          c.api_driver_class = MyAPIDriver
           c.app_host = 'http://127.0.0.1:%d' % app_server.port
           c.browser = Capybara::Session.new(:webkit)
           c.server_error_detection do |browser|
@@ -369,32 +34,45 @@ describe "testing a Rack application with Kookaburra" do
         app_server.shutdown
       end
 
-      it "runs the tests against the app" do
-        given.a_user(:bob)
-        given.a_widget(:widget_a)
-        given.a_widget(:widget_b, :name => 'Foo')
+      before(:each) do
+        api.create_user(:bob)
+        api.create_widget(:widget_a)
+        api.create_widget(:widget_b, :name => 'Widget B')
+      end
+
+      define_method(:widgets) { k.get_data(:widgets) }
 
+      it "runs the tests against the application's UI" do
         ui.sign_in(:bob)
-        ui.view_widget_list
 
-        # 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.view_widget_list
+        expect(ui.widget_list.widgets).to include widgets[:widget_a]
+        expect(ui.widget_list.widgets).to include widgets[:widget_b]
 
-        ui.create_new_widget(:widget_c, :name => 'Bar')
+        ui.create_widget(:widget_c, :name => 'Bar')
+        expect(ui.widget_list.widgets).to include widgets[:widget_a]
+        expect(ui.widget_list.widgets).to include widgets[:widget_b]
+        expect(ui.widget_list.widgets).to include widgets[:widget_c]
 
+        ui.delete_widget(:widget_b)
+        expect(ui.widget_list.widgets).to include widgets[:widget_a]
+        expect(ui.widget_list.widgets).to include widgets[:widget_c]
+        expect(ui.widget_list.widgets).to_not include widgets.deleted[:widget_b]
+      end
 
-        # 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)
+      it "runs the tests against the applications's API" do
+        expect(api.widgets).to include widgets[:widget_a]
+        expect(api.widgets).to include widgets[:widget_b]
 
-        ui.delete_widget(:widget_b)
+        api.create_widget(:widget_c, :name => 'Bar')
+        expect(api.widgets).to include widgets[:widget_a]
+        expect(api.widgets).to include widgets[:widget_b]
+        expect(api.widgets).to include widgets[: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)
+        api.delete_widget(:widget_b)
+        expect(api.widgets).to include widgets[:widget_a]
+        expect(api.widgets).to include widgets[:widget_c]
+        expect(api.widgets).to_not include widgets.deleted[:widget_b]
       end
 
       it "catches errors based on the server error detection handler" do