kookaburra 1.3.1 → 2.0.0

data/spec/kookaburra/{api_driver_spec.rb → api_client_spec.rb}

@@ -1,13 +1,13 @@
-require 'kookaburra/api_driver'
+require 'kookaburra/api_client'
 
-describe Kookaburra::APIDriver do
+describe Kookaburra::APIClient do
   def url_for(uri)
     URI.join('http://example.com', uri).to_s
   end
 
   let(:configuration) { double('Configuration', :app_host => 'http://example.com') }
 
-  let(:api) { Kookaburra::APIDriver.new(configuration, client) }
+  let(:api) { Kookaburra::APIClient.new(configuration, client) }
 
   let(:response) { double('RestClient::Response', body: 'foo', code: 200) }
 
@@ -20,20 +20,20 @@ describe Kookaburra::APIDriver do
       end
 
       it 'returns the response body' do
-        api.send(http_verb, '/foo').should == 'foo'
+        expect(api.send(http_verb, '/foo')).to eq 'foo'
       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))
-        lambda { api.send(http_verb, '/foo') } \
-          .should raise_error(Kookaburra::UnexpectedResponse)
+        expect{ api.send(http_verb, '/foo') } \
+          .to raise_error(Kookaburra::UnexpectedResponse)
       end
 
       let(:expect_client_to_receive_headers) { ->(expected_headers) {
         # Some HTTP verb methods pass data, some don't, and their arity
         # is different
-        client.should_receive(http_verb) do |path, data_or_headers, headers|
+        allow(client).to receive(http_verb) do |path, data_or_headers, headers|
           headers ||= data_or_headers
           expect(headers).to eq(expected_headers)
           response
@@ -42,7 +42,7 @@ describe Kookaburra::APIDriver do
 
       context 'when custom global headers are specified' do
         let(:api) {
-          klass = Class.new(Kookaburra::APIDriver) do
+          klass = Class.new(Kookaburra::APIClient) do
             header 'Header-Foo', 'Baz'
             header 'Header-Bar', 'Bam'
           end
@@ -100,14 +100,14 @@ describe Kookaburra::APIDriver do
 
       context 'when a custom decoder is specified' do
         let(:api) {
-          klass = Class.new(Kookaburra::APIDriver) do
+          klass = Class.new(Kookaburra::APIClient) do
           decode_with { |data| :some_decoded_data }
           end
         klass.new(configuration, client)
         }
 
         it "decodes response bodies from requests" do
-          api.send(http_verb, '/foo').should == :some_decoded_data
+          expect(api.send(http_verb, '/foo')).to eq :some_decoded_data
         end
       end
     end
@@ -121,9 +121,9 @@ describe Kookaburra::APIDriver do
 
       context 'when a custom encoder is specified' do
         let(:api) {
-          klass = Class.new(Kookaburra::APIDriver) do
+          klass = Class.new(Kookaburra::APIClient) do
             encode_with { |data|
-              data.should == :some_ruby_data
+              raise "Wrong data!" unless data == :some_ruby_data
               :some_encoded_data
             }
           end
@@ -131,7 +131,7 @@ describe Kookaburra::APIDriver do
         }
 
         it "encodes input to requests" do
-          client.should_receive(http_verb) do |_, data, _|
+          expect(client).to receive(http_verb) do |_, data, _|
             data.should == :some_encoded_data
             response
           end
@@ -145,7 +145,7 @@ describe Kookaburra::APIDriver do
   shared_examples_for 'it encodes data as a querystring' do |http_verb|
     context "(#{http_verb})" do
       it 'adds data as querystirng params' do
-        client.should_receive(http_verb).with(url_for('/foo?bar=baz&yak=shaved'), {}) \
+        expect(client).to receive(http_verb).with(url_for('/foo?bar=baz&yak=shaved'), {}) \
           .and_return(response)
         api.send(http_verb, '/foo', bar: 'baz', yak: 'shaved')
       end

data/spec/kookaburra/configuration_spec.rb

@@ -2,7 +2,7 @@ require 'kookaburra/configuration'
 require 'support/shared_examples/it_has_a_dependency_accessor'
 
 describe Kookaburra::Configuration do
-  it_behaves_like :it_has_a_dependency_accessor, :given_driver_class
+  it_behaves_like :it_has_a_dependency_accessor, :api_driver_class
   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
@@ -13,13 +13,13 @@ describe Kookaburra::Configuration do
     it 'returns the block that it was last given' do
       block = lambda { 'foo' }
       subject.server_error_detection(&block)
-      subject.server_error_detection.should == block
+      expect(subject.server_error_detection).to eq 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) \
+      expect(URI).to receive(:parse) \
         .with('http://example.com') \
         .and_return(:a_parsed_uri)
       subject.app_host = 'http://example.com'
@@ -27,13 +27,13 @@ describe Kookaburra::Configuration do
     end
 
     it 'changes if #app_host changes' do
-      URI.stub(:parse) do |url|
+      allow(URI).to receive(:parse) do |url|
         url.to_sym
       end
       subject.app_host = 'http://example.com'
-      subject.app_host_uri.should == 'http://example.com'.to_sym
+      expect(subject.app_host_uri).to eq 'http://example.com'.to_sym
       subject.app_host = 'http://foo.example.com'
-      subject.app_host_uri.should == 'http://foo.example.com'.to_sym
+      expect(subject.app_host_uri).to eq 'http://foo.example.com'.to_sym
     end
   end
 end

data/spec/kookaburra/mental_model_spec.rb

@@ -86,7 +86,8 @@ describe Kookaburra::MentalModel do
     describe '#deleted' do
       it 'generates a new subcollection if none exists' do
         initialized_collection = collection
-        Kookaburra::MentalModel::Collection.should_receive(:new).with("deleted")
+        Kookaburra::MentalModel::Collection.should_receive(:new) \
+          .with("#{initialized_collection.name}.deleted")
         initialized_collection.deleted
       end
 
@@ -121,6 +122,17 @@ describe Kookaburra::MentalModel do
         new_collection[:foo][:bar].should == 'baz'
         new_collection[:foo][:bar].__id__.should_not === collection[:foo][:bar].__id__
       end
+
+      context 'when there are deleted items present' do
+        it 'also dupes the deleted items' do
+          collection[:foo] = 'foo'
+          collection[:bar] = 'bar'
+          deleted = collection.delete(:bar)
+          new_collection = collection.dup
+          expect(new_collection.deleted[:bar]).to eq deleted
+          expect(new_collection.deleted[:bar]).to_not equal deleted
+        end
+      end
     end
   end
 end

data/spec/kookaburra/test_helpers_spec.rb

@@ -5,14 +5,14 @@ describe Kookaburra::TestHelpers do
 
   before(:all) do
     Kookaburra.configure do |c|
-      c.given_driver_class = Kookaburra::GivenDriver
+      c.api_driver_class = Kookaburra::APIDriver
       c.ui_driver_class    = Kookaburra::UIDriver
     end
   end
 
   after(:all) do
     Kookaburra.configure do |c|
-      c.given_driver_class = nil
+      c.api_driver_class = nil
       c.ui_driver_class    = nil
     end
   end
@@ -29,9 +29,9 @@ describe Kookaburra::TestHelpers do
   end
 
   describe "methods delegated to #k" do
-    it "includes #given" do
-      k.should_receive(:given)
-      given
+    it "includes #api" do
+      k.should_receive(:api)
+      api
     end
 
     it "includes #ui" do
@@ -39,43 +39,4 @@ describe Kookaburra::TestHelpers do
       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

@@ -7,14 +7,14 @@ describe Kookaburra do
 
   let(:k) { Kookaburra.new(configuration) }
 
-  describe '#given' do
-    it 'returns an instance of the configured GivenDriver' do
-      my_given_driver_class = double(Class)
-      my_given_driver_class.should_receive(:new) \
+  describe '#api' do
+    it 'returns an instance of the configured APIDriver' do
+      my_api_driver_class = double(Class)
+      my_api_driver_class.should_receive(:new) \
         .with(configuration) \
-        .and_return(:a_given_driver)
-      configuration.stub(:given_driver_class => my_given_driver_class)
-      k.given.should == :a_given_driver
+        .and_return(:an_api_driver)
+      configuration.stub(:api_driver_class => my_api_driver_class)
+      k.api.should == :an_api_driver
     end
   end
 

data/spec/support/json_api_app_and_kookaburra_drivers.rb

@@ -0,0 +1,372 @@
+require 'sinatra/base'
+require 'json'
+
+# 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
+
+  def delete_widget(id)
+    @@widgets.delete_if do |w|
+      w[:id] == id
+    end
+  end
+
+  post '/widgets/:widget_id' do
+    delete_widget(params['widget_id'])
+    redirect to('/widgets')
+  end
+
+  delete '/widgets/:widget_id' do
+    result = delete_widget(params['widget_id'])
+    status 200
+    body result.to_json
+  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
+    @@widgets ||= []
+    if request.media_type == 'application/json'
+      status 200
+      headers 'Content-Type' => 'application/json'
+      halt @@widgets.to_json
+    else
+      raise "Not logged in!" unless session[:logged_in]
+      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
+  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 MyAPIClient < Kookaburra::APIClient
+  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
+
+  def delete_widget(id)
+    delete "/widgets/#{id}"
+  end
+
+  def widgets
+    get '/widgets'
+  end
+end
+
+class MyAPIDriver < Kookaburra::APIDriver
+  def api
+    MyAPIClient.new(configuration)
+  end
+
+  def create_user(name)
+    mental_model.users.fetch(name) { |name|
+      user = {'email' => 'bob@example.com', 'password' => '12345'}
+      result = api.create_user(user)
+      mental_model.users[name] = result
+    }
+  end
+
+  def create_widget(name, attributes = {})
+    mental_model.widgets.fetch(name) { |name|
+      widget = {'name' => name}.merge(attributes)
+      result = api.create_widget(widget)
+      mental_model.widgets[name] = result
+    }
+  end
+
+  def delete_widget(name)
+    widget = mental_model.widgets.delete(name)
+    api.delete_widget(widget['id'])
+  end
+
+  def widgets
+    api.widgets
+  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_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