locomotivecms 3.0.0.rc3 → 3.0.0.rc4

data/features/step_definitions/backoffice_steps.rb

@@ -1,47 +0,0 @@
-### Authentication
-
-Given /^I am not authenticated$/ do
-  visit('/locomotive/sign_out')
-end
-
-Given /^I am an authenticated "([^"]*)"$/ do |role|
-  @member = Locomotive::Site.first.memberships.where(:role => role.downcase).first || FactoryGirl.create(role.downcase.to_sym, :site => Locomotive::Site.first)
-
-  step %{I go to login}
-  step %{I fill in "Email" with "#{@member.account.email}"}
-  step %{I fill in "Password" with "easyone"}
-  step %{I press "Log in"}
-end
-
-Given /^I am an authenticated user$/ do
-  step %{I am an authenticated "admin"}
-end
-
-Then /^I should see the access denied message$/ do
-  page.body.include?("You are not authorized to access this page").should be_true
-end
-
-Then /^I am redirected to "([^\"]*)"$/ do |url|
-  assert [301, 302].include?(@integration_session.status), "Expected status to be 301 or 302, got #{@integration_session.status}"
-  location = @integration_session.headers["Location"]
-  assert_equal url, location
-  visit location
-end
-
-### Cross-domain authentication
-
-When /^I forget to press the button on the cross-domain notice page$/ do
-  @admin.updated_at = 2.minutes.ago
-  Mongoid::Persistence::Update.new(@admin).send(:update)
-end
-
-### Common
-
-When(/^I change the number of items to display per page to (\d+)$/) do |per_page|
-  Locomotive.config.ui[:per_page] = per_page
-end
-
-Then /^I debug$/ do
-  debugger
-  0
-end

data/features/step_definitions/content_assets_steps.rb

@@ -1,12 +0,0 @@
-
-Given /^I have the following content assets:$/ do |table|
-  site = Locomotive::Site.first
-  table.hashes.each do |asset_hash|
-    asset_hash['site'] = site
-    asset_hash['source'] = FixturedAsset.open(asset_hash['file'])
-    asset_hash.delete('file')
-
-    asset = FactoryGirl.build(:asset, asset_hash)
-    asset.save.should be_true
-  end
-end

data/features/step_definitions/content_types_steps.rb

@@ -1,135 +0,0 @@
-def build_content_type(name)
-  site = Locomotive::Site.first
-  FactoryGirl.build(:content_type, site: site, name: name, order_by: '_position')
-end
-
-def set_custom_fields_from_table(content_type, fields)
-  fields.hashes.each do |field|
-    # found a belongs_to association
-    if field['type'] == 'belongs_to'
-      target_name   = field.delete('target')
-      target_model  = @site.content_types.where(name: target_name).first
-
-      field['class_name'] = target_model.entries_class_name
-    end
-
-    content_type.entries_custom_fields.build field
-  end
-end
-
-Given %r{^I have a custom model named "([^"]*)" with id "([^"]*)" and$} do |name, id, fields|
-  content_type = build_content_type(name)
-  content_type.id = BSON::ObjectId(id)
-  set_custom_fields_from_table(content_type, fields)
-  content_type.valid?
-  content_type.save.should be_true
-end
-
-Given(/^the "(.*?)" model was created by another thread$/) do |name|
-  content_type = Locomotive::ContentType.where(name: name).first
-  Locomotive.send(:remove_const, :"ContentEntry#{content_type._id}")
-  "Locomotive::ContentEntry#{content_type._id}".constantize
-end
-
-Given %r{^I have a custom model named "([^"]*)" with$} do |name, fields|
-  content_type = build_content_type(name)
-  set_custom_fields_from_table(content_type, fields)
-  content_type.valid?
-  content_type.save.should be_true
-end
-
-Given %r{^I have "([^"]*)" as "([^"]*)" values of the "([^"]*)" model$} do |values, field, name|
-  content_type = Locomotive::ContentType.where(name: name).first
-  field = content_type.entries_custom_fields.detect { |f| f.label == field }
-  field.should_not be_nil
-
-  if field.type == 'select'
-    values.split(',').collect(&:strip).each do |name|
-      field.select_options.build name: name
-    end
-    content_type.save.should be_true
-  else
-    raise "#{field.type} field is not supported"
-  end
-end
-
-Given %r{^I have entries for "([^"]*)" with$} do |name, entries|
-  content_type = Locomotive::ContentType.where(name: name).first
-  entries.hashes.each do |attributes|
-    entry_id  = attributes.delete('id')
-    entry     = content_type.entries.build(attributes)
-    entry.id  = entry_id if entry_id
-    entry.save!
-  end
-  content_type.save.should be_true
-end
-
-When(/^the custom model named "(.*?)" is ordered by "(.*?)"$/) do |name, order_by|
-  content_type = Locomotive::ContentType.where(name: name).first
-  content_type.update_attribute :order_by, order_by
-end
-
-#the "client" "Alpha, Inc" has "Fun project" as one of its "projects"
-Given(/^the "(.*?)" "(.*?)" has "(.*?)" as one of its "(.*?)"$/) do |source, source_label, target_label, target|
-  source_model = Locomotive::ContentType.where(name: source.classify.pluralize).first
-  source_entry = source_model.entries.where(source_model.label_field_name => source_label).first
-  target_model = Locomotive::ContentType.where(name: target.classify.pluralize).first
-  target_entry = target_model.entries.where(target_model.label_field_name => target_label).first
-
-  source_entry.send("#{target}").send("<<", target_entry)
-end
-
-When(/^I choose "(.*?)" in the list$/) do |name|
-  within('#content') do
-    click_link(name)
-  end
-end
-
-When(/^I delete the first content entry$/) do
-  within('#content ul.list li:first') do
-    click_link 'Delete'
-  end
-end
-
-Given %r{^I (enable|disable) the public submission of the "([^"]*)" model$} do |action, name|
-  enabled = action == 'enable'
-  content_type = Locomotive::ContentType.where(name: name).first
-  content_type.public_submission_enabled  = enabled
-  content_type.public_submission_accounts = enabled ? [Locomotive::Account.first._id] : []
-  content_type.save.should be_true
-end
-
-When %r{^I change the presentation of the "([^"]*)" model by grouping items by "([^"]*)"$} do |name, field|
-  content_type = Locomotive::ContentType.where(name: name).first
-  field = content_type.entries_custom_fields.detect { |f| f.label == field }
-  content_type.group_by_field_id = field._id
-  content_type.save.should be_true
-end
-
-Then %r{^I should not see (\d+) times the "([^"]*)" field$} do |n, field|
-  page.all(:css, "#content_#{field.underscore.downcase}_input").size.should_not == n.to_i
-end
-
-When %r{^I unselect the notified accounts$} do
-  page.evaluate_script "window.application_view.view.model.set({ 'public_submission_accounts': null });"
-
-  click_button 'Save'
-
-  page.find('.notice').visible?
-end
-
-Then %r{^there should not be any notified accounts on the "([^"]*)" model$} do |name|
-  content_type = Locomotive::ContentType.where(name: name).first
-  content_type.reload.public_submission_accounts.should eq([])
-end
-
-Given(/^I click on the (\d+)[a-z]+ required flag$/) do |nth|
-  find(".custom-field:nth-child(#{nth}) .required-input .switchHandle").click
-  sleep(0.1)
-end
-
-Given(/^I have the "(.*?)" entries ordered by the "(.*?)" field$/) do |name, field|
-  content_type = Locomotive::ContentType.where(name: name).first
-  field = content_type.entries_custom_fields.detect { |f| f.label == field }
-  content_type.update_attribute :order_by, field.name
-end

data/features/step_definitions/current_site_steps.rb

@@ -1,43 +0,0 @@
-Then /^I should see the role dropdown on the "([^"]*)"$/ do |user|
-  find(:css, "#site_memberships_input div.entry[data-role=#{user}] select").should be_present
-end
-
-Then /^I should see the role dropdown on the "([^"]*)" without the "([^"]*)" option$/ do |user, option|
-  find(:css, "#site_memberships_input div.entry[data-role=#{user}] select").text.should_not include option
-end
-
-Then /^I should see the role dropdown on myself$/ do
-  step %{I should see the role dropdown on the "#{@member.role}"}
-end
-
-Then /^I should not see the role dropdown on the "([^"]*)"$/ do |user|
-  page.has_css?("#site_memberships_input div.entry[data-role=#{user}] select").should be_false
-end
-
-Then /^I should not see the role dropdown on myself$/ do
-  step %{I should not see the role dropdown on the "#{@member.role}"}
-end
-
-Then /^I should not see any role dropdowns$/ do
-  page.has_css?('#site_memberships_input div.entry select').should be_false
-end
-
-Then /^I should see delete on the "([^"]*)"$/ do |role|
-  page.has_css?("#site_memberships_input div.entry[data-role=#{role}] .actions a.remove").should be_true
-end
-
-Then /^I should not see delete on the "([^"]*)"$/ do |role|
-  page.has_css?("#site_memberships_input div.entry[data-role=#{role}] .actions a.remove").should be_false
-end
-
-Then /^I should not see delete on myself$/ do
-  step %{I should not see delete on the "#{@member.role}"}
-end
-
-Then /^I should not see any delete buttons$/ do
- page.has_css?('#site_memberships_input div.entry .actions a.remove').should be_false
-end
-
-When /^I select the "([^"]*)" role for the "author" user/ do |role|
-  step %{I select "#{role}" from "site[memberships_attributes][2][role]"}
-end

data/features/step_definitions/editable_elements_steps.rb

@@ -1,24 +0,0 @@
-# modify an editable element
-Given /^the editable element "([^"]*)" in the "([^"]*)" page with the content "([^"]*)"$/ do |slug, page_slug, content|
-  page = @site.pages.where(:slug => page_slug).first
-  page.find_editable_element(nil, slug).content = content
-  page.save!
-end
-
-# modify an editable element
-Given /^the editable element "([^"]*)" for the "([^"]*)" block in the "([^"]*)" page with the content "([^"]*)"$/ do |slug, block, page_slug, content|
-  page = @site.pages.where(:slug => page_slug).first
-  page.find_editable_element(block, slug).content = content
-  page.save!
-end
-
-When /^I type the content "([^"]*)" into the first editable field$/ do |content|
-  page.execute_script %{
-    $(document).ready(function() {
-      editable = GENTICS.Aloha.editables[0];
-      editable.obj.text('#{content}');
-      editable.blur();
-    });
-  }
-end
-

data/features/step_definitions/membership_steps.rb

@@ -1,19 +0,0 @@
-
-Given /^I have accounts:$/ do |accounts_table|
-  accounts_table.hashes.each do |account_hash|
-    FactoryGirl.create(:account, account_hash)
-  end
-end
-
-Given /^I have memberships:$/ do |members_table|
-  members_table.hashes.each do |member_hash|
-    email = member_hash[:email]
-    account = Locomotive::Account.where(:email => email).first \
-      || FactoryGirl.create(:account, :email => email)
-
-    member_hash.delete(:email)
-    member_hash.merge!({ :account => account, :site => @site })
-
-    FactoryGirl.create(:membership, member_hash)
-  end
-end

data/features/step_definitions/more_web_steps.rb

@@ -1,131 +0,0 @@
-When(/^the locale of the current ruby thread changes to "(.*?)"$/) do |locale|
-  ::I18n.locale = ::Mongoid::Fields::I18n.locale = 'fr'
-end
-
-When /^I follow image link "([^"]*)"$/ do |img_alt|
-  find(:xpath, "//img[@alt = '#{img_alt}']/parent::a").click()
-end
-
-When /^I click on the "([^"]*)" folder$/ do |name|
-  find('fieldset.foldable legend span', text: name).click
-end
-
-Then /^I should get a download with the filename "([^\"]*)"$/ do |filename|
-  page.response_headers['Content-Disposition'].should include("filename=#{filename}")
-end
-
-When /^I wait until "([^"]*)" is visible$/ do |selector|
-  page.has_css?("#{selector}", visible: true)
-end
-
-When /^I wait until ([^"]*) is visible$/ do |locator|
-  page.has_css?(selector_for(locator), visible: true)
-end
-
-When /^I sync my form with my backbone model because of Firefox$/ do
-  page.execute_script("$(':input').trigger('change')")
-end
-
-When /^I fill in "(.*?)" with the tags "(.*?)"$/ do |field, tags|
-  input = field_labeled(field)
-  tags.split(',').each do |tag|
-    _tag = tag.strip
-    page.execute_script("$('input[name=\"#{input[:name]}\"]').tagit('createTag', '#{_tag}')")
-  end
-end
-
-Then /^"([^"]*)" should not be visible$/ do |text|
-  begin
-    assert page.find(text).visible? != true
-  rescue Capybara::ElementNotFound
-  end
-end
-
-Then(/^I should see "(.*?)" in the html code$/) do |content|
-  page.body.include?(content).should be_true
-end
-
-Then(/^I should not see "(.*?)" in the html code$/) do |content|
-  page.body.include?(content).should be_false
-end
-
-Then /^"([^"]*)" should( not)? be an option for "([^"]*)"(?: within "([^\"]*)")?$/ do |value, negate, field, selector|
-  with_scope(selector) do
-    expectation = negate ? :should_not : :should
-    field_labeled(field).first(:xpath, ".//option[text() = '#{value}']").send(expectation, be_present)
-  end
-end
-
-Then /^"([^"]*)" should be selected for "([^"]*)"$/ do |value, field|
-  assert page.has_xpath?("//select[@name='#{field}' and option[@selected and contains(text(), '#{value}')]]")
-end
-
-When /^I reload the page$/ do
-  visit current_path
-end
-
-When(/^I switch the locale to "(.*?)"$/) do |locale|
-  click_on 'content-locale-picker-link'
-  within '#content-locale-picker' do
-    find("[data-locale='#{locale}']").click
-  end
-end
-
-Then(/^I should see a "(.*?)" link to "(.*?)"$/) do |text, path|
-  page.should have_link(text, href: path)
-end
-
-Given /^I enable the CSRF protection for public submission requests$/ do
-  Locomotive.config.csrf_protection = true
-  Locomotive::Public::ContentEntriesController.any_instance.stubs(:protect_against_forgery?).returns(true)
-end
-
-Given /^I disable the CSRF protection for public submission requests$/ do
-  Locomotive.config.csrf_protection = false
-  # pending # express the regexp above with the code you wish you had
-end
-
-Then /^the response status should be (\d+)$/ do |status|
-  page.status_code.should == status.to_i
-end
-
-Then /^it returns a (\d+) error page$/ do |code|
-  page.status_code.should == code.to_i
-end
-
-Then /^I should see the following xml output:$/ do |xml_output|
-  xml_output.gsub!(':now', Time.now.utc.to_date.to_s)
-  response = Hash.from_xml(page.source)
-  expected = Hash.from_xml(xml_output)
-  expected.diff(response).should == {}
-end
-
-When /^I take a screenshot$/ do
-  page.save_screenshot('/Users/didier/Desktop/cucumber.png', full: true)
-end
-
-def wait_for_ajax(&block)
-  start_time = Time.now
-  while Time.now < start_time + Capybara.default_wait_time
-    begin
-      block.call
-      break
-    rescue RSpec::Expectations::ExpectationNotMetError => e
-      raise e
-    rescue
-      # Try again
-    end
-  end
-end
-
-Then /^after the AJAX finishes, (.*)$/ do |*args|
-  step_str = args[0]
-  step_arg = args[1]
-  wait_for_ajax do
-    step(step_str, step_arg)
-  end
-end
-
-When(/^I wait (\d+)ms$/) do |delay|
-  sleep(delay.to_i / 1000.0)
-end

data/features/step_definitions/page_steps.rb

@@ -1,133 +0,0 @@
-### Pages
-
-# helps create a simple content page (parent: "index") with a slug and template
-def create_content_page(slug, template = nil)
-  new_content_page(slug, template).tap do |page|
-    page.save!.should be_true
-  end
-  # page = new_content_page(slug, page_contents, template)
-  # raise "Invalid page: #{page.errors.full_messages}" unless page.valid?
-  # page.should be_valid
-  # page.save!
-  # page
-end
-
-# build page without saving
-def new_content_page(slug, template = nil)
-  @home = @site.pages.where(slug: 'index').first || FactoryGirl.create(:page)
-  title = slug.gsub(/-/, '_').humanize
-  @site.pages.new(title: title, slug: slug, parent: @home, published: true, raw_template: template)
-end
-
-# creates a page
-# Given /^a simple page named "([^"]*)" with the body:$/ do |page_slug, page_contents|
-#   @page = create_content_page(page_slug, page_contents)
-# end
-
-Given /^a page named "([^"]*)" with the template:$/ do |slug, template|
-  @page = create_content_page(slug, template)
-end
-
-Given /^a page named "([^"]*)" with id "([^"]*)"$/ do |slug, id|
-  @page = new_content_page(slug, '')
-  @page.id = BSON::ObjectId(id)
-  @page.save!
-end
-
-Given /^a page named "([^"]*)" with id "([^"]*)" and template:$/ do |slug, id, template|
-  @page = new_content_page(slug, template)
-  @page.id = BSON::ObjectId(id)
-  @page.save!
-end
-
-Given(/^a page named "(.*?)" with the handle "(.*?)"$/) do |slug, handle|
-  page = new_content_page(slug, '')
-  page.handle = handle
-  page.save!
-end
-
-Given(/^the page named "(.*?)" has the title "(.*?)" in the "(.*?)" locale$/) do |slug, title, locale|
-  page = @site.pages.where(slug: slug).first
-  ::Mongoid::Fields::I18n.with_locale(locale) do
-    page.update_attributes!(title: title, slug: title.permalink)
-  end
-end
-
-Given /^a templatized page for the "(.*?)" model and with the template:$/ do |model_name, template|
-  content_type = Locomotive::ContentType.where(name: model_name).first
-  parent = create_content_page(content_type.slug, '')
-  @page = @site.pages.new(parent: parent, title: "Template for #{model_name}", published: true,
-    templatized: true, target_klass_name: content_type.entries_class_name,
-    raw_template: template)
-  @page.save!
-end
-
-# change the title
-When /^I change the page title to "([^"]*)"$/ do |title|
-  page.evaluate_script "window.prompt = function() { return '#{title}'; }"
-  page.find('h2 a.editable').click
-end
-
-# change the template
-When /^I change the page template to "([^"]*)"$/ do |template|
-  page.evaluate_script "window.application_view.view.model.set({ 'raw_template': '#{template}' })"
-end
-
-# update a page
-When /^I update the "([^"]*)" page with the template:$/ do |slug, template|
-  page = @site.pages.where(slug: slug).first
-  page.raw_template = template
-  page.save!
-end
-
-Given /^I delete the following code "([^"]*)" from the "([^"]*)" page$/ do |code, slug|
-  page = @site.pages.where(slug: slug).first
-  page.raw_template = page.raw_template.gsub(code, '')
-  page.save!
-end
-
-Given(/^the page "(.*?)" is unpublished$/) do |slug|
-  page = @site.pages.where(slug: slug).first
-  page.published = false
-  page.save!
-end
-
-
-# try to render a page by slug
-When /^I view the rendered page at "([^"]*)"$/ do |path|
-  # If we're running poltergeist then we need to use a different port
-  if Capybara.current_driver == :poltergeist
-    visit "http://#{@site.domains.first}:#{Capybara.server_port}#{path}"
-  else
-    visit "http://#{@site.domains.first}#{path}"
-  end
-end
-
-# checks to see if a string is in the slug
-Then /^I should have "(.*)" in the (.*) page$/ do |content, slug|
-  page = @site.pages.where(slug: slug).first
-  raise "Could not find page: #{slug}" unless page
-  page.raw_template.should == content
-end
-
-# checks if the rendered body matches a string
-Then /^the rendered output should look like:$/ do |body_contents|
-  # page.source.should == body_contents
-  page.source.index(body_contents).should_not be_nil
-end
-
-Then /^I should see delete page buttons$/ do
-  page.has_css?("ul#pages-list li .more a.remove").should be_true
-end
-
-Then /^I should not see delete page buttons$/ do
-  page.has_css?("ul#pages-list li .more a.remove").should be_false
-end
-
-Then /^updated_at of the (.*) page should respect site's timezone$/ do |slug|
-  edited_page = @site.pages.where(slug: slug).first
-  t = edited_page.updated_at.in_time_zone(@site.timezone)
-  page.source.should =~ /#{t.strftime('%-d %b %H:%M')}/
-end
-
-

data/features/step_definitions/pagination_steps.rb

@@ -1,35 +0,0 @@
-Then /^I should be able to display paginated models$/ do
-  # Create our article model and three articles
-  @article_model = FactoryGirl.build(:content_type, site: @site, name: 'Articles', order_by: '_position').tap do |ct|
-    ct.entries_custom_fields.build label: 'Body', type: 'string', required: false
-    ct.save!
-  end
-
-  %w(First Second Third).each do |body|
-    @article_model.entries.create!(body: body)
-  end
-
-  # Create a page with template
-  raw_template = %{
-  {% paginate contents.articles by 2 %}
-    {% for article in paginate.collection %}
-      {{ article.body }}
-    {% endfor %}
-    {{ paginate | default_pagination }}
-  {% endpaginate %}
-  }
-  FactoryGirl.create(:page, site: @site, slug: 'hello', parent: @site.pages.root.first, raw_template: raw_template)
-
-  # The page should have the first two articles
-  visit '/hello'
-  page.should have_content 'First'
-  page.should have_content 'Second'
-  page.should_not have_content 'Third'
-
-  # The second page should have the last article
-  click_link '2'
-  page.should_not have_content 'First'
-  page.should_not have_content 'Second'
-  page.should     have_content 'Third'
-end
-

data/features/step_definitions/pickle_steps.rb

@@ -1,100 +0,0 @@
-# this file generated by script/generate pickle
-
-# create a model
-Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
-  create_model(name, fields)
-end
-
-# create n models
-Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
-  count.to_i.times { create_model(plural_factory.singularize, fields) }
-end
-
-# create models from a table
-Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
-  create_models_from_table(plural_factory, table)
-end
-
-# find a model
-Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
-  find_model!(name, fields)
-end
-
-# not find a model
-Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
-  find_model(name, fields).should be_nil
-end
-
-# find models with a table
-Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
-  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
-end
-
-# find exactly n models
-Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
-  find_models(plural_factory.singularize, fields).size.should == count.to_i
-end
-
-# assert equality of models
-Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
-  model!(a).should == model!(b)
-end
-
-# assert model is in another model's has_many assoc
-Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should include(model!(target))
-end
-
-# assert model is not in another model's has_many assoc
-Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should_not include(model!(target))
-end
-
-# assert model is another model's has_one/belongs_to assoc
-Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should == model!(target)
-end
-
-# assert model is not another model's has_one/belongs_to assoc
-Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
-  model!(owner).send(association).should_not == model!(target)
-end
-
-# assert model.predicate? 
-Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
-  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
-    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
-  else
-    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
-  end
-end
-
-# assert not model.predicate?
-Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
-  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
-    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
-  else
-    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
-  end
-end
-
-# model.attribute.should eql(value)
-# model.attribute.should_not eql(value)
-Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
-  actual_value  = model(name).send(attribute)
-  expectation   = expectation.gsub(' ', '_')
-  
-  case expected
-  when 'nil', 'true', 'false'
-    actual_value.send(expectation, send("be_#{expected}"))
-  when /^[+-]?[0-9_]+(\.\d+)?$/
-    actual_value.send(expectation, eql(expected.to_f))
-  else
-    actual_value.to_s.send(expectation, eql(eval(expected)))
-  end
-end
-
-# assert size of association
-Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
-  model!(name).send(association).size.should == size.to_i
-end