the_jobbook_admin_data 1.3.0a

data/test/dummy/features/step_definitions/feed_steps.rb

@@ -0,0 +1,24 @@
+def mock_authenticator_with_authentication_returning_true
+  #TODO use rspec double code here. This is a very bad hack
+  AdminData::Authenticator.class_eval do
+    def verify(*args)
+      true
+    end
+  end
+end
+
+def mock_authenticator_with_authentication_returning_false
+  AdminData::Authenticator.class_eval do
+    def verify(*args)
+      false
+    end
+  end
+end
+
+When /^mocked feed authentication returns true$/ do
+  mock_authenticator_with_authentication_returning_true
+end
+
+When /^mocked feed authentication returns false$/ do
+  mock_authenticator_with_authentication_returning_false
+end

data/test/dummy/features/step_definitions/quick_search_steps.rb

@@ -0,0 +1,68 @@
+Given /^user config has defined additional_column phone_numbers$/ do
+  AdminData.config.columns_order = AdminData.config.columns_order.merge('User' => [:id, :phone_numbers])
+  proc = lambda {|model| model.phone_numbers.map {|r| r.number}.join(', ') }
+  AdminData.config.column_settings = AdminData.config.column_settings.merge('User' => { :phone_numbers => proc })
+end
+
+Then /^table should have additional column phone_numbers with valid data$/ do
+  data = tableish('table.table tr', 'th,td')
+  data[0][0].should == "id"
+  data[0][1].should == "phone_numbers"
+  data[0][2].should == "first_name"
+  data[0][3].should == "last_name"
+  user = User.find(data[1][0].to_i)
+  assert_equal user.phone_numbers.map(&:number).join(', '),data[1][1]
+end
+
+Then /^reset columns_order and column_settings for User$/ do
+  AdminData.config.columns_order = AdminData.config.columns_order.merge('User' => nil)
+  AdminData.config.column_settings = AdminData.config.column_settings.merge('User' => nil)
+end
+
+
+Then /^I should see population_5000$/ do
+  assert page.has_content?("[:population, 5000]")
+end
+
+Then /^(.*)verify that user "(.*)" is "(.*)"$/ do |async, attribute, input|
+  wait_until { page.evaluate_script("jQuery.active === 0") } unless async.blank?
+
+  page.has_xpath?("//table[@id='view_table']")
+  table =  page.find(:xpath, "//table[@id='view_table']")
+
+  counter = attribute == 'first_name' ? 2 : 3
+  regex = Regexp.new(input)
+
+  if async.blank?
+    table.find(:xpath, "./tbody/tr/td[#{counter}]", :text => regex )
+  else
+    table.find(:xpath, "./tbody/tr/td[#{counter}]", :text => regex )
+  end
+end
+
+Then /^I should see following tabular attributes:$/ do |expected_cukes_table|
+  expected_cukes_table.diff!(tableish('table.table tr', 'td,th'))
+end
+
+Then /^first id of table should be of "(.*)"$/ do |first_name|
+  page.should have_css("#view_table tr td a", :text => User.find_by_first_name(first_name).id.to_s)
+end
+
+Then /^I should see tabular attributes for website with custom columns order$/ do
+  data = tableish('table.table tr', 'td,th').flatten
+  data[0].should == "id"
+  data[1].should == "dns_provider"
+  data[2].should == "user_id"
+  data[3].should == "url"
+  data[4].should == "created_at"
+  data[5].should == "updated_at"
+end
+
+Then /^I should see tabular attributes for city with custom column headers$/ do
+  data = tableish('table.table tr', 'td,th').flatten
+  data[0].should == "ID"
+  data[1].should == "City Name"
+  data[2].should == "City Info"
+  data[3].should == "created_at"
+  data[4].should == "updated_at"
+end

data/test/dummy/features/step_definitions/util.rb

@@ -0,0 +1,90 @@
+# Usage:
+#
+# Then page should have "select" field with selector "#phone_number_user_id"
+# Then page should have "input" field with selector "#phone_number_user_id"
+Then /^page should have "(.*)" field with selector "(.*)"$/ do |tag_name, css_selector|
+  elem = page.find(css_selector)
+  elem.tag_name.should == tag_name
+  elem.value.should == PhoneNumber.last.user.id.to_s
+end
+
+Then /^page should have id "remove_row_3"$/ do
+  page.has_css?("remove_row_3")
+end
+
+Then /^I should see "(.*)" rows in table "(.*)"$/ do |count, table_id|
+  table =  page.find(:xpath, "//table[@id='#{table_id}']")
+  table.find(:xpath, "./tbody/tr", :count => count.to_i )
+end
+
+Then /^async I should see "(.*)"$/ do |msg|
+  page.should have_content(msg)
+end
+
+Then /^page should have css "(.*)"$/ do |css_selector|
+  page.should have_css(css_selector)
+end
+
+Then /^page should have disabled css "(.*)"$/ do |css_selector|
+  elem = page.find(css_selector)
+  elem['disabled'].should == 'true'
+end
+
+def handy_has_links(table)
+  table.hashes.each do |h|
+    css_selector = h[:within]
+    selector = css_selector[1..-1]
+    page.should have_xpath( "//div[@id='#{selector}']//a[@href='#{h[:url]}']", :text => h[:text] )
+  end
+end
+
+# Usage:
+#
+# Then page should have following links:
+#  | url                                                | text          | within  |
+#  | http://github.com/neerajdotname/admin_data         | admin_data    | #footer |
+#  | http://github.com/neerajdotname/admin_data/issues  | Report Bug    | #footer |
+#  | http://github.com/neerajdotname/admin_data/wiki    | Documentation | #footer |
+Then /^page should have following links?:$/ do |table|
+  handy_has_links(table)
+end
+
+
+# Usage :
+#
+#  position:         if the option is the very first option in the dropdown list then position should be 1.
+#  css_selector:     only class and id are supported at this time.
+#  value_match_type: If specified as "regex" then Regular expression will be used to detect the match.
+#
+#  Then I should see dropdown with css_selector ".drop_down_value_klass" with following options:
+#    | text         | value                                 | position | value_match_type |
+#    | phone_number | /admin_data/quick_search/phone_number | 2        | regex            |
+#    | user         | /admin_data/quick_search/user         | 3        | regex            |
+#    | website      | /admin_data/quick_search/website      | 4        | regex            |
+#
+def handy_has_select?(css_selector, select_options)
+  selector = css_selector[1..-1]
+  case css_selector[0,1]
+  when '.'
+    attribute = "@class='#{selector}'"
+  when '#'
+    attribute = "@id='#{selector}'"
+  else
+    raise 'only css_selector class or id is currently supported'
+  end
+
+  page.should have_xpath("//select[#{attribute}]")
+  selects = page.find(:xpath, "//select[#{attribute}]")
+
+  select_options.each do |h|
+    if h[:value_match_type] == 'regex'
+      selects.find(:xpath, "option[#{h[:position]}]").value.should match Regexp.new(h[:value])
+    else
+      selects.find(:xpath, "option[#{h[:position]}]", :text => h[:value])
+    end
+  end
+end
+
+Then /^I should see dropdown with css_selector "(.*)" with following options:$/ do |css_selector, table|
+  handy_has_select?(css_selector, table.hashes)
+end

data/test/dummy/features/step_definitions/web_steps.rb

@@ -0,0 +1,219 @@
+# 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 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(locator) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+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 "([^"]*)"(?: within "([^"]*)")?$/ do |button, selector|
+  with_scope(selector) do
+    click_button(button)
+  end
+end
+
+When /^(?:|I )follow "([^"]*)"(?: within "([^"]*)")?$/ do |link, selector|
+  with_scope(selector) do
+    click_link(link)
+  end
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"(?: within "([^"]*)")?$/ do |field, value, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"(?: within "([^"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+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(?: within "([^"]*)")?:$/ do |selector, fields|
+  with_scope(selector) do
+    fields.rows_hash.each do |name, value|
+      When %{I fill in "#{name}" with "#{value}"}
+    end
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"(?: within "([^"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    select(value, :from => field)
+  end
+end
+
+When /^(?:|I )check "([^"]*)"(?: within "([^"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    check(field)
+  end
+end
+
+When /^(?:|I )uncheck "([^"]*)"(?: within "([^"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    uncheck(field)
+  end
+end
+
+When /^(?:|I )choose "([^"]*)"(?: within "([^"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    choose(field)
+  end
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"(?: within "([^"]*)")?$/ do |path, field, selector|
+  with_scope(selector) do
+    attach_file(field, path)
+  end
+end
+
+Then /^(?:|I )should see JSON:$/ do |expected_json|
+  require 'json'
+  expected = JSON.pretty_generate(JSON.parse(expected_json))
+  actual   = JSON.pretty_generate(JSON.parse(response.body))
+  expected.should == actual
+end
+
+Then /^(?:|I )should see "([^"]*)"(?: within "([^"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_content(text)
+    else
+      assert page.has_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/(?: within "([^"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_xpath('//*', :text => regexp)
+    else
+      assert page.has_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"(?: within "([^"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_content(text)
+    else
+      assert page.has_no_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/(?: within "([^"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_xpath('//*', :text => regexp)
+    else
+      assert page.has_no_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within "([^"]*)")? should contain "([^"]*)"$/ do |field, selector, value|
+  with_scope(selector) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within "([^"]*)")? should not contain "([^"]*)"$/ do |field, selector, value|
+  with_scope(selector) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within "([^"]*)")? should be checked$/ do |label, selector|
+  with_scope(selector) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_true
+    else
+      assert field_checked
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within "([^"]*)")? should not be checked$/ do |label, selector|
+  with_scope(selector) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_false
+    else
+      assert !field_checked
+    end
+  end
+end
+ 
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')} 
+  
+  if actual_params.respond_to? :should
+    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

data/test/dummy/features/support/env.rb

@@ -0,0 +1,66 @@
+# 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.
+
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'cucumber/rails/world'
+require 'cucumber/rails/active_record'
+require 'cucumber/web/tableish'
+
+require 'capybara/rails'
+require 'capybara/cucumber'
+require 'capybara/session'
+#require 'cucumber/rails/capybara_javascript_emulation' # Lets you click links with onclick javascript handlers without using @culerity or @javascript
+# Capybara defaults to XPath selectors rather than Webrat's default of CSS3. In
+# order to ease the transition to Capybara we set the default here. If you'd
+# prefer to use XPath just remove this line and adjust any selectors in your
+# steps to use the XPath syntax.
+Capybara.default_selector = :css
+
+# If you set this to false, any error raised from within your app will bubble
+# up to your step definition and out to cucumber unless you catch it somewhere
+# on the way. You can make Rails rescue errors and render error pages on a
+# per-scenario basis by tagging a scenario or feature with the @allow-rescue tag.
+#
+# If you set this to true, Rails will rescue all errors and render error
+# pages, more or less in the same way your application would behave in the
+# default production environment. It's not recommended to do this for all
+# of your scenarios, as this makes it hard to discover errors in your application.
+ActionController::Base.allow_rescue = false
+
+# If you set this to true, each scenario will run in a database transaction.
+# You can still turn off transactions on a per-scenario basis, simply tagging
+# a feature or scenario with the @no-txn tag. If you are using Capybara,
+# tagging with @culerity or @javascript will also turn transactions off.
+#
+# If you set this to false, transactions will be off for all scenarios,
+# regardless of whether you use @no-txn or not.
+#
+# Beware that turning transactions off will leave data in your database
+# after each scenario, which can lead to hard-to-debug failures in
+# subsequent scenarios. If you do this, we recommend you create a Before
+# block that will explicitly put your database in a known state.
+Cucumber::Rails::World.use_transactional_fixtures = true
+# How to clean your database when transactions are turned off. See
+# http://github.com/bmabey/database_cleaner for more info.
+if defined?(ActiveRecord::Base)
+  begin
+    require 'database_cleaner'
+    DatabaseCleaner.strategy = :truncation
+  rescue LoadError => ignore_if_database_cleaner_not_present
+  end
+end
+
+
+
+require 'factory_girl'
+require Rails.root.join('test', 'factories')
+require 'factory_girl/step_definitions'
+require 'shoulda'
+
+#Capybara.default_wait_time = 40