atrium 0.0.1.alpha

data/test_support/spec/rcov.opts

@@ -0,0 +1,3 @@
+--exclude "spec/*,gems/*,features/*"
+--rails
+--aggregate coverage.data

data/test_support/spec/routing/atrium/collections_routing_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe 'routing to atrium/collections' do
+  extend BeRouted
+  be_routed(:get, '/atrium/collections',
+    :controller => 'atrium/collections',
+    :action => 'index'
+  )
+  be_routed(:get, '/atrium/collections/new',
+    :controller => 'atrium/collections',
+    :action => 'new'
+  )
+  be_routed(:post, '/atrium/collections',
+    :controller => 'atrium/collections',
+    :action => 'create'
+  )
+  be_routed(:get, '/atrium/collections/2',
+    :controller => 'atrium/collections',
+    :action => 'show', :id => '2'
+  )
+  be_routed(:get, '/atrium/collections/2/edit',
+    :controller => 'atrium/collections',
+    :action => 'edit', :id => '2'
+  )
+  be_routed(:put, '/atrium/collections/2',
+    :controller => 'atrium/collections',
+    :action => 'update', :id => '2'
+  )
+  be_routed(:delete, '/atrium/collections/2',
+    :controller => 'atrium/collections',
+    :action => 'destroy', :id => '2'
+  )
+end

data/test_support/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/test_support/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+# Has been customized by Blacklight to work when application is in one place,
+# and actual spec/ stuff is in another (the blacklight gem checkout).  
+
+ENV["RAILS_ENV"] ||= 'test'
+
+#require File.expand_path("../../config/environment", __FILE__)
+# version that works with our blacklight:spec stuff that calls specs
+# in a remote directory. 
+require File.expand_path("config/environment", ENV['RAILS_ROOT'] || File.expand_path("../../../tmp/test_app", __FILE__))
+require 'rspec/rails'
+require 'rspec/autorun'
+require 'rspec/given'
+require 'rspec_on_rails_matchers'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+# Blacklight, again, make sure we're looking in the right place for em. 
+# Relative to HERE, NOT to Rails.root, which is off somewhere else. 
+#Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+Dir[Pathname.new(File.expand_path("../support/**/*.rb", __FILE__))].each {|f| require f}
+
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+#=  config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+#config.mock_with :rspec
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  def fixture(file)
+    File.new(File.join(File.dirname(__FILE__),'..', 'fixtures', file))
+  end
+
+end

data/test_support/spec/support/be_accessible_matcher.rb

@@ -0,0 +1,8 @@
+RSpec::Matchers.define :be_accessible do |attribute|
+  match do |response|
+    response.class.accessible_attributes.include?(attribute)
+  end
+  description { "be accessible :#{attribute}" }
+  failure_message_for_should { ":#{attribute} should be accessible" }
+  failure_message_for_should_not { ":#{attribute} should not be accessible" }
+end

data/test_support/spec/support/be_routed_mixin.rb

@@ -0,0 +1,7 @@
+module BeRouted
+  def be_routed(method_name,path, params)
+    it "routes #{method_name.to_s.upcase} #{path} to #{params.inspect}" do
+      {method_name.to_sym => path}.should route_to(params)
+    end
+  end
+end

data/test_support/tmp/step_definitions/catalog_index_steps.rb

@@ -0,0 +1,14 @@
+Given /^the following catalog_indices:$/ do |catalog_indices|
+  CatalogIndex.create!(catalog_indices.hashes)
+end
+
+When /^I delete the (\d+)(?:st|nd|rd|th) catalog_index$/ do |pos|
+  visit catalog_indices_url
+  within("table tr:nth-child(#{pos.to_i+1})") do
+    click_link "Destroy"
+  end
+end
+
+Then /^I should see the following catalog_indices:$/ do |expected_catalog_indices_table|
+  expected_catalog_indices_table.diff!(tableish('table tr', 'td,th'))
+end

data/test_support/tmp/step_definitions/edit_document_steps.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+Then /^I should see an inline edit containing "([^"]*)"$/ do |arg1|
+  response.should have_selector(".editable-text", :content=>arg1)
+end
+
+Then /^the "([^\"]*)" inline edit should contain "([^\"]*)"$/ do |arg1, arg2|
+  response.should have_selector("dt", :content=>arg1) do |dt|
+    dt.each do |term| 
+      term.next_element.should have_selector("dd ol li.editable") do |editable|
+        editable.should have_selector(".editable-text", :content=>arg2)
+      end 
+    end
+  end
+end
+
+Then /^the "([^\"]*)" inline date edit should contain "([^\"]*)"$/ do |arg1, arg2|
+  response.should have_selector("dt", :content=>arg1) do |dt|
+    dt.each do |term| 
+      term.next_element.should have_selector("dd div.date-select") do |editable_date_picker|
+        editable_date_picker.should have_selector("input.controlled-date-part", :value=>arg2)
+      end 
+    end
+  end
+end
+
+# This was failing on some computers that displayed "selected" instead of "selected='selected'", so we made it an option in the next step definition 
+Then /^the "([^\"]*)" dropdown edit should be set to "([^\"]*)"$/ do |arg1, arg2|
+  response.should have_selector("dt", :content=>arg1) do |dt|
+    dt.each do |term| 
+      term.next_element.should have_selector("select") do |dropdown|
+        dropdown.should have_selector("option", :content=>arg2, :selected=>"selected")
+      end
+    end
+  end
+end
+
+Then /^the "([^\"]*)" dropdown edit should contain "([^\"]*)" as an option$/ do |arg1, arg2|
+  response.should have_selector("dt", :content=>arg1) do |dt|
+    dt.each do |term| 
+      term.next_element.should have_selector("select") do |dropdown|
+        dropdown.should have_selector("option", :content=>arg2)
+      end
+    end
+  end
+end
+
+Then /^the "([^\"]*)" inline textarea edit should contain "([^\"]*)"$/ do |arg1, arg2|
+  response.should have_selector("dt", :content=>arg1) do |dt|
+    dt.each do |term| 
+      term.next_element.should have_selector("dd ol li.editable_textarea") do |editable_textarea|
+        editable_textarea.should have_selector(".flc-inlineEdit-text", :content=>arg2)
+      end
+    end
+  end
+end
+
+Then /^the "([^\"]*)" inline textarea edit should be empty$/ do |arg1|
+  response.should have_selector("dt", :content=>arg1) do |dt|
+    dt.each do |term| 
+      term.next_element.should have_selector("dd ol li.editable_textarea") do |editable_textarea|
+        editable_textarea.should have_selector(".flc-inlineEdit-text", :content=>nil)
+      end
+    end
+  end
+end
+

data/test_support/tmp/step_definitions/hydra_metadata_steps.rb

@@ -0,0 +1,3 @@
+Then /^the "([^"]*)" field for the "([^"]*)" entry should contain "([^"]*)"$/ do |arg1, arg2, arg3|
+  pending # express the regexp above with the code you wish you had
+end

data/test_support/tmp/step_definitions/hydra_steps.rb

@@ -0,0 +1,8 @@
+# This is borrowed from blacklight's record_view_steps.rb
+Then /^I (should|should not) see an? "([^\"]*)" element containing "([^\"]*)"$/ do |bool,elem,content|
+  if bool == "should"
+    response.should have_selector("#{elem}",:content => content)
+  else
+    response.should_not have_selector("#{elem}",:content => content)
+  end
+end

data/test_support/tmp/step_definitions/search_steps.rb

@@ -0,0 +1,86 @@
+# User added
+Then /^I should see a search field$/ do
+  response.should have_tag("input#q")
+end
+
+Then /^I should see a selectable list with field choices$/ do
+  response.should have_tag("select#search_field")
+end
+
+Then /^I should see a selectable list with per page choices$/ do
+  response.should have_tag("select#per_page")
+end
+
+Then /^I should see a "([^\"]*)" button$/ do |label|
+  response.should have_tag("input[type=?][value=?]", 'submit', label)
+end
+
+Then /^I should not see the "([^\"]*)" element$/ do |id|
+  response.should_not have_tag("##{id}")
+end
+
+Then /^I should see the "([^\"]*)" element$/ do |id|
+  response.should have_tag("##{id}")
+end
+
+Given /^the application is configured to have searchable fields "([^\"]*)" with values "([^\"]*)"$/ do |fields, values|
+  labels = fields.split(", ")
+  values = values.split(", ")
+  combined = labels.zip(values)
+  Blacklight.config[:search_fields] = []
+  combined.each do |pair|
+    Blacklight.config[:search_fields] << pair
+  end
+end
+
+Then /^I should see select list "([^\"]*)" with field labels "([^\"]*)"$/ do |list_css, names|
+  response.should have_tag(list_css) do
+    labels = names.split(", ")
+    labels.each do |label|
+      with_tag('option', label)
+    end
+  end
+end
+
+Then /^I should see select list "([^\"]*)" with "([^\"]*)" selected$/ do |list_css, label|
+  response.should have_tag(list_css) do |e|
+    with_tag("[selected=selected]", {:count => 1}) do
+      with_tag("option", {:count => 1, :text => label})
+    end
+  end
+end
+
+# Results Page
+Given /^the application is configured to have sort fields "([^\"]*)" with values "([^\"]*)"$/ do |fields, values|
+  labels = fields.split(", ")
+  values = values.split(", ")
+  combined = labels.zip(values)
+  Blacklight.config[:sort_fields] = []
+  combined.each do |pair|
+    Blacklight.config[:sort_fields] << pair
+  end
+end
+
+Then /^I should get results$/ do 
+  response.should have_selector("div.document")
+end
+
+Then /^I should not get results$/ do 
+  response.should_not have_selector("div.document")
+end
+
+Then /^I should see the applied filter "([^\"]*)" with the value "([^\"]*)"$/ do |filter, text|
+  response.should have_tag("div#facets div") do |node|
+    node.should have_selector("h3", :content => filter)
+    node.should have_selector("span.selected", :content => text)
+  end
+end
+
+# Then /^I should see the applied filter "([^\"]*)" with the value
+# "([^\"]*)"$/ do |filter, text|
+#  response.should have_tag("div#facets div") do |node|
+#    node.should have_selector("h3", :content => filter)
+#    node.should have_selector("span.selected", :content => /#{text}.*/)
+#  end
+# end
+

data/test_support/tmp/step_definitions/searching_steps.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+# Gives a way to test how many items are on a given page either gallery or list
+Then /^I should see (\d+) (gallery|list) results$/ do |number,type|
+  if type == "gallery"
+    results_num = response.body.scan(/<div class=\"document thumbnail\">/).length
+  elsif type == "list"
+    results_num = response.body.scan(/<tr class=\"document (odd|even)\">/).length
+  else
+    results_num = -1
+  end
+  results_num.should == number.to_i
+end
+
+# simple way to check for elements in the dom (needed for per_page bug check)
+Then /^I (should not|should) see an? "([^\"]*)" tag with an? "([^\"]*)" attribute of "([^\"]*)"$/ do |bool,tag,attribute,value|
+  if bool == "should not"
+    response.should_not have_tag("#{tag}[#{attribute}*=?]", /^.*#{value}.*$/)
+  else
+    response.should have_tag("#{tag}[#{attribute}*=?]", /^.*#{value}.*$/)
+  end
+end

data/test_support/tmp/step_definitions/select_steps.rb

@@ -0,0 +1,8 @@
+Then /^I should not see select list "([^\"]*)" with field labels "([^\"]*)"$/ do |list_css, names|
+  response.should have_tag(list_css) do
+    labels = names.split(", ")
+    labels.each do |label|
+      without_tag('option', label)
+    end
+  end
+end

data/test_support/tmp/step_definitions/show_document_steps.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+# Terms (dt / dd pairs)
+
+Then /^I should see the "([^\"]*)" term$/ do |arg1|
+  response.should have_selector("dt", :content=>arg1) 
+end
+
+Then /^I should not see the "([^\"]*)" term$/ do |arg1|
+  response.should_not have_selector("dt", :content=>arg1) 
+end
+
+Then /^the "([^\"]*)" term should contain "([^\"]*)"$/ do |arg1, arg2|
+  response.should have_selector("dt", :content=>arg1) do |dt|
+    dt.each do |term| 
+      term.next.should have_selector("dd", :content=>arg2) 
+    end
+  end
+end
+
+Then /^I should see the "([^\"]*)" value$/ do |arg1|
+  pending
+end
+
+Then /^I should see a link to "([^\"]*)"$/ do |arg1|
+  response.should have_selector("a", :href=>path_to(arg1))
+end
+
+Then /^I should see a link to the "([^\"]*)" page$/ do |arg1|
+  response.should have_selector("a", :href=>path_to(arg1))
+end
+
+Then /^I should see a link to "([^\"]*)" with label "([^\"]*)"$/ do |arg1,arg2|
+  response.should have_selector("a", :href=>path_to(arg1), :content=>arg2)
+end
+
+Then /^I should not see a link to "([^\"]*)"$/ do |arg1|
+  response.should_not have_selector("a", :href=>path_to(arg1))
+end
+
+Then /^I should not see a link to the "([^\"]*)" page$/ do |arg1|
+  response.should_not have_selector("a", :href=>path_to(arg1))
+end
+
+Then /^related links are displayed as urls$/ do
+  pending
+end
+
+Then /^I (should|should not) see a delete (field|contributor) button for "([^\"]*)"$/ do |bool,type,target|
+  if bool == "should"
+    response.should have_selector("a.destructive", :href=>path_to(target))
+  else
+    response.should_not have_selector("a", :class=>"destructive #{type}", :href=>path_to(target))
+  end
+end
+
+Then /^I (should|should not) see a button to delete "([^\"]*)" from "([^\"]*)"$/ do |bool,target,container|
+  path_name = "#{target} with #{container} as its container"
+  if bool == "should"
+    response.should have_selector("a", :class=>"destroy_file_asset", :href=>path_to(path_name))
+  else
+    response.should_not have_selector("a", :class=>"destroy_file_asset", :href=>path_to(path_name))
+  end
+end
+
+Then /^I (should|should not) see a delete button for "([^\"]*)"$/ do |bool,target|
+  if bool == "should"
+    response.should have_selector("a", :class=>"destructive", :href=>path_to(target))
+  else
+    response.should_not have_selector("a", :class=>"destructive", :href=>path_to(target))
+  end
+end
+

data/test_support/tmp/step_definitions/user_steps.rb

@@ -0,0 +1,15 @@
+Given /^I am logged in as "([^\"]*)"$/ do |login|
+  email = "#{login}@#{login}.com"
+  user = User.create(:login => login, :email => email, :password => "password", :password_confirmation => "password")
+  visit user_sessions_path(:user_session => {:login => login, :password => "password"}), :post
+  User.find(user.id).should_not be_nil
+end
+
+Given /^I am a superuser$/ do
+  login = "BigWig"
+  email = "bigwig@bigwig.com"
+  user = User.create(:login => login, :email => email, :password => "password", :password_confirmation => "password")
+  superuser = Superuser.create(:id => 20, :user_id => user.id)
+  visit user_sessions_path(:user_session => {:login => login, :password => "password"}), :post
+  visit superuser_path
+end

data/test_support/tmp/step_definitions/web_steps.rb

@@ -0,0 +1,273 @@
+# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a 
+# newer version of cucumber-rails. Consider adding your own code to a new file 
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+
+require 'uri'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+# Commonly used webrat steps
+# http://github.com/brynary/webrat
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^\"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^\"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )follow "([^\"]*)" within "([^\"]*)"$/ do |link, parent|
+  click_link_within(parent, link)
+end
+
+When /^(?:|I )fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^\"]*)" for "([^\"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^\"]*)" from "([^\"]*)"$/ do |value, field|
+  select(value, :from => field)
+end
+
+# Use this step in conjunction with Rail's datetime_select helper. For example:
+# When I select "December 25, 2008 10:00" as the date and time
+When /^(?:|I )select "([^\"]*)" as the date and time$/ do |time|
+  select_datetime(time)
+end
+
+# Use this step when using multiple datetime_select helpers on a page or
+# you want to specify which datetime to select. Given the following view:
+#   <%= f.label :preferred %><br />
+#   <%= f.datetime_select :preferred %>
+#   <%= f.label :alternative %><br />
+#   <%= f.datetime_select :alternative %>
+# The following steps would fill out the form:
+# When I select "November 23, 2004 11:20" as the "Preferred" date and time
+# And I select "November 25, 2004 10:30" as the "Alternative" date and time
+When /^(?:|I )select "([^\"]*)" as the "([^\"]*)" date and time$/ do |datetime, datetime_label|
+  select_datetime(datetime, :from => datetime_label)
+end
+
+# Use this step in conjunction with Rail's time_select helper. For example:
+# When I select "2:20PM" as the time
+# Note: Rail's default time helper provides 24-hour time-- not 12 hour time. Webrat
+# will convert the 2:20PM to 14:20 and then select it.
+When /^(?:|I )select "([^\"]*)" as the time$/ do |time|
+  select_time(time)
+end
+
+# Use this step when using multiple time_select helpers on a page or you want to
+# specify the name of the time on the form.  For example:
+# When I select "7:30AM" as the "Gym" time
+When /^(?:|I )select "([^\"]*)" as the "([^\"]*)" time$/ do |time, time_label|
+  select_time(time, :from => time_label)
+end
+
+# Use this step in conjunction with Rail's date_select helper.  For example:
+# When I select "February 20, 1981" as the date
+When /^(?:|I )select "([^\"]*)" as the date$/ do |date|
+  select_date(date)
+end
+
+# Use this step when using multiple date_select helpers on one page or
+# you want to specify the name of the date on the form. For example:
+# When I select "April 26, 1982" as the "Date of Birth" date
+When /^(?:|I )select "([^\"]*)" as the "([^\"]*)" date$/ do |date, date_label|
+  select_date(date, :from => date_label)
+end
+
+When /^(?:|I )check "([^\"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^\"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^\"]*)"$/ do |field|
+  choose(field)
+end
+
+# Adds support for validates_attachment_content_type. Without the mime-type getting
+# passed to attach_file() you will get a "Photo file is not one of the allowed file types."
+# error message 
+When /^(?:|I )attach the file "([^\"]*)" to "([^\"]*)"$/ do |path, field|
+  type = path.split(".")[1]
+
+  case type
+  when "jpg"
+    type = "image/jpg" 
+  when "jpeg"
+    type = "image/jpeg" 
+  when "png"
+    type = "image/png" 
+  when "gif"
+    type = "image/gif"
+  end
+  
+  attach_file(field, path, type)
+end
+
+Then /^(?:|I )should see "([^\"]*)"$/ do |text|
+  if defined?(Spec::Rails::Matchers)
+    response.should contain(text)
+  else
+    assert_contain text
+  end
+end
+
+Then /^(?:|I )should see "([^\"]*)" within "([^\"]*)"$/ do |text, selector|
+  within(selector) do |content|
+    if defined?(Spec::Rails::Matchers)
+      content.should contain(text)
+    else
+      hc = Webrat::Matchers::HasContent.new(text)
+      assert hc.matches?(content), hc.failure_message
+    end
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+  if defined?(Spec::Rails::Matchers)
+    response.should contain(regexp)
+  else
+    assert_match(regexp, response_body)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/ within "([^\"]*)"$/ do |regexp, selector|
+  within(selector) do |content|
+    regexp = Regexp.new(regexp)
+    if defined?(Spec::Rails::Matchers)
+      content.should contain(regexp)
+    else
+      assert_match(regexp, content)
+    end
+  end
+end
+
+Then /^(?:|I )should not see "([^\"]*)"$/ do |text|
+  if defined?(Spec::Rails::Matchers)
+    response.should_not contain(text)
+  else
+    assert_not_contain(text)
+  end
+end
+
+Then /^(?:|I )should not see "([^\"]*)" within "([^\"]*)"$/ do |text, selector|
+  within(selector) do |content|
+    if defined?(Spec::Rails::Matchers)
+      content.should_not contain(text)
+    else
+      hc = Webrat::Matchers::HasContent.new(text)
+      assert !hc.matches?(content), hc.negative_failure_message
+    end
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+  if defined?(Spec::Rails::Matchers)
+    response.should_not contain(regexp)
+  else
+    assert_not_contain(regexp)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/ within "([^\"]*)"$/ do |regexp, selector|
+  within(selector) do |content|
+    regexp = Regexp.new(regexp)
+    if defined?(Spec::Rails::Matchers)
+      content.should_not contain(regexp)
+    else
+      assert_no_match(regexp, content)
+    end
+  end
+end
+
+Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(field).value.should =~ /#{value}/
+  else
+    assert_match(/#{value}/, field_labeled(field).value)
+  end
+end
+
+Then /^the "([^\"]*)" field should not contain "([^\"]*)"$/ do |field, value|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(field).value.should_not =~ /#{value}/
+  else
+    assert_no_match(/#{value}/, field_labeled(field).value)
+  end
+end
+
+Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(label).should be_checked
+  else
+    assert field_labeled(label).checked?
+  end
+end
+
+Then /^the "([^\"]*)" checkbox should not be checked$/ do |label|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(label).should_not be_checked
+  else
+    assert !field_labeled(label).checked?
+  end
+end
+
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  if defined?(Spec::Rails::Matchers)
+    URI.parse(current_url).path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), URI.parse(current_url).path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  actual_params   = CGI.parse(URI.parse(current_url).query)
+  expected_params = Hash[expected_pairs.rows_hash.map{|k,v| [k,[v]]}]
+ 
+  if defined?(Spec::Rails::Matchers)
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end