surveyor 0.22.0 → 1.0.0

data/features/step_definitions/surveyor_steps.rb

@@ -4,6 +4,31 @@ When /^I start the "([^"]*)" survey$/ do |name|
     Then I should see "#{name}\"
     When I press "Take it"
   }
+  @survey_code       = current_path.split("/")[2] # /surveys/:survey_code/:response_set_code/take
+  @response_set_code = current_path.split("/")[3] # /surveys/:survey_code/:response_set_code/take
+end
+
+When /^I start the survey$/ do
+  steps %Q{
+    When I go to the surveys page
+     And I press "Take it"
+  }
+  @survey_code       = current_path.split("/")[2] # /surveys/:survey_code/:response_set_code/take
+  @response_set_code = current_path.split("/")[3] # /surveys/:survey_code/:response_set_code/take
+end
+
+# When I fill in the (nth) (string) for "(ref_id)" with "(value to fill)"
+When /^I fill in the (\d+[a-z]{0,2} )?(\w+) for "([^"]+)" with "([^"]+)"$/ do |index, type, answer_reference_id, value|
+  answer = Answer.where(:reference_identifier => answer_reference_id).first
+  fail "No answer with ref ID #{answer_reference_id.inspect}" unless answer
+
+  i = index ? index.to_i - 1 : 0
+
+  answer_input_id = page.all("input[@value='#{answer.id}']").
+    select { |x| x['id'] =~ /answer_id/ }[i]['id']
+  ordinal = answer_input_id.scan(/r_(\d+)/).first.first
+  value_input_id = "r_#{ordinal}_#{type}_value"
+  page.fill_in(value_input_id, :with => value)
 end
 
 Then /^there should be (\d+) response set with (\d+) responses? with:$/ do |rs_num, r_num, table|
@@ -66,7 +91,13 @@ Then /^there should be (\d+) text areas$/ do |count|
 end
 
 Then /^the question "([^"]*)" should be triggered$/ do |text|
-  page.should have_selector %(fieldset[name="#{text}"][class!="q_hidden"])
+  q = Question.find_by_text(text)
+  page.should_not have_css %(fieldset#q_#{q.id}.q_hidden)
+end
+
+Then /^the question "(.*?)" should be hidden$/ do |text|
+  q = Question.find_by_text(text)
+  page.should have_css %(fieldset#q_#{q.id}.q_hidden)
 end
 
 Then /^there should be (\d+) response with answer "([^"]*)"$/ do |count, answer_text|
@@ -74,34 +105,91 @@ Then /^there should be (\d+) response with answer "([^"]*)"$/ do |count, answer_
   Response.find_by_answer_id(Answer.find_by_text(answer_text)).should_not be_blank
 end
 
-Then /^there should be a datetime response with today's date$/ do
-  # Response.datetime_value returns ActiveSupport::TimeWithZone
-  # so we call .to_date on it for the comparison with Date.today
-  Response.all.one?{|x| x.datetime_value.to_date == Date.today}.should be_true
+When /^I choose row (\d+), column (\d+) of the grid$/ do |row, col|
+  find(".g_grid").find("tr:nth-child(#{row.to_i + 1})").find("td:nth-child(#{col.to_i + 1})").find("input").set(true)
+end
+
+Then /^there should (not )?be a (\w+ )?response(?: for answer "([^"]+)")?(?: with value "([^"]+)")?(?: on question "([^"]+)")?$/ do |neg, type, answer_reference_id, value, question_reference_id|
+  conditions = []
+  values = []
+  expected_count = neg.blank? ? 1 : 0
+  if type
+    attribute = case type.strip
+                when 'date'
+                  'datetime_value'
+                when 'time'
+                  'datetime_value'
+                else
+                  "#{type.strip}_value"
+                end
+    if value
+      case type.strip
+      when 'date'
+        # Work around deficient SQLite date handling
+        conditions << "date(#{attribute}) = date(?)"
+        values << value
+      else
+        conditions << "#{attribute} = ?"
+        values << value
+      end
+    else
+      conditions << "#{attribute} IS NOT NULL"
+    end
+  end
+
+  if question_reference_id
+    question = Question.where(:reference_identifier => question_reference_id).first
+    fail "No question with ref ID #{question_reference_id}" unless question
+    conditions << 'question_id = ?'
+    values << question
+  end
+
+  if answer_reference_id
+    a_conds = { :reference_identifier => answer_reference_id }
+    if question
+      a_conds[:question_id] = question
+    end
+    answer = Answer.where(a_conds).first
+    fail "No answer with ref ID #{answer_reference_id}" unless answer
+    conditions << 'answer_id = ?'
+    values << answer
+  end
+
+  Response.where(conditions.join(' AND '), *values).count.should == expected_count
 end
 
 Then /^I should see the image "([^"]*)"$/ do |src|
   page.should have_selector %(img[src^="#{src}"])
 end
 
+Then /^I click elsewhere$/ do
+  page.find('.survey_title').click
+end
+
 Then /^(\d+) responses should exist$/ do |response_count|
   Response.count.should == response_count.to_i
 end
 
-Then /^the json for "([^"]*)" should be$/ do |title, string|
-  visit "/surveys/#{Survey.find_by_title(title).access_code}.json"
-  puts page.find('body').text
-  Surveyor::Common.equal_json_excluding_wildcards(page.find('body').text, string).should == true
+## JSON
+
+def last_json
+  page.find('body').text
+end
+
+When /^I visit "(.*?)"$/ do |path|
+  visit path
 end
 
-Then /^the json for the last response set for "([^"]*)" should be$/ do |title, string|
-  (survey = Survey.find_by_title(title)).should_not be_nil
-  (response_set = ResponseSet.last(:conditions => {:survey_id => survey.id})).should_not be_nil
-  visit "/surveys/#{survey.access_code}/#{response_set.access_code}.json"
-  puts page.find('body').text
-  Surveyor::Common.equal_json_excluding_wildcards(page.find('body').text, string).should == true
+Then /^I export the response set$/ do
+  visit "/surveys/#{@survey_code}/#{@response_set_code}.json"
 end
 
+Then /^the JSON response at "(.*?)" should correspond to an answer with text "(.*?)"$/ do |path, text|
+  last_json.should be_json_eql(JsonSpec.remember("\"#{Answer.find_by_text(text).api_id}\"")).at_path(path)
+end
+
+## Hidden and shown elements
+
 Then /the element "([^\"]*)" should be hidden$/ do |selector|
   wait_until do
     its_hidden = page.evaluate_script("$('#{selector}').is(':hidden');")
@@ -117,7 +205,10 @@ Then /the element "([^\"]*)" should not be hidden$/ do |selector|
     (its_not_hidden && its_in_dom).should be_true
   end
 end
-Given /^I have survey context of "([^"]*)"$/ do |context|
+
+## Context and substitution with mustache
+
+Given /^I have survey context of "(.*)"$/ do |context|
   class SurveyorController < ApplicationController
     require 'mustache'
     class FakeMustacheContext < ::Mustache
@@ -134,8 +225,42 @@ Given /^I have survey context of "([^"]*)"$/ do |context|
   end
 end
 
-When /^I follow today's date$/ do
-  steps %Q{
-    When I follow "#{Date.today.strftime('%d').to_i}"
-  }
+## Various input elements
+
+Then /^I should see (\d+) textareas on the page$/ do |i|
+  page.has_css?('textarea', :count => i)
+end
+
+Then /^I should see (\d+) "(.*?)" input on the page$/ do |i, css_class|
+  page.has_css?("input.#{css_class}", :count => i)
+end
+
+Then /^I should see (\d+) select on the page$/ do |i|
+  page.has_css?("select", :count => i)
+end
+
+Then /^the checkbox for "(.*?)" should be (dis|en)abled$/ do |text, dis_or_en|
+  a = Answer.find_by_text(text)
+  a.should_not be_nil
+  element = find("input[value='#{a.id}']")
+  if dis_or_en == 'dis'
+    element['disabled'].should == 'true'
+  else
+    [nil, 'false'].should include(element['disabled'])
+  end
+end
+
+# see support/simultaneous_ajax.rb
+Then /^I wait for things to settle out( longer)?$/ do |longer|
+  if @simultaneous_ajax
+    Capybara.timeout(longer ? 120 : 10, page.driver, "waiting for all AJAX requests timed out") do
+      page.evaluate_script("window.surveyorIntegratedTestsRequestsOutstanding <= 0")
+    end
+  end
+end
+
+## quizzes
+
+Then /^the question "(.*?)" should have correct answer "(.*?)"$/ do |q, a|
+  Question.find_by_reference_identifier(q).correct_answer.reference_identifier.should == a
 end

data/features/step_definitions/ui_steps.rb

@@ -0,0 +1,3 @@
+When /^I select "([^"]+)" as the datepicker's (\w+)$/ do |selection, type|
+  page.find(".ui-datepicker-#{type}").select(selection)
+end

data/features/support/database_cleaner.rb

@@ -0,0 +1,16 @@
+require 'database_cleaner'
+
+# Use transaction cleaning for performance by default
+DatabaseCleaner.strategy = :transaction
+# Clean to start so that manual testing data in testbed can't cause false
+# test results.
+DatabaseCleaner.clean_with(:truncation)
+
+# use truncation to allow direct DB checks in Selenium tests
+Before('@javascript') do
+  DatabaseCleaner.strategy = :truncation
+end
+
+After('@javascript') do
+  DatabaseCleaner.strategy = :transaction
+end

data/features/support/env.rb

@@ -5,6 +5,8 @@
 # files.
 ENV["RAILS_ROOT"] ||= File.expand_path(File.dirname(__FILE__) + '/../../testbed')
 require 'cucumber/rails'
+
+
 # require File.expand_path(File.dirname(__FILE__) + '/../../testbed/config/environment.rb')
 # 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
@@ -29,22 +31,24 @@ Capybara.default_selector = :css
 #
 ActionController::Base.allow_rescue = false
 
-# Remove/comment out the lines below if your app doesn't have a database.
-# For some databases (like MongoDB and CouchDB) you may need to use :truncation instead.
-begin
-  DatabaseCleaner.strategy = :transaction
-rescue NameError
-  raise "You need to add database_cleaner to your Gemfile (in the :test group) if you wish to use it."
+# Use chrome for Selenium by default. This is because of Firefox's bug 566671
+# (https://bugzilla.mozilla.org/show_bug.cgi?id=566671): any test that relies on
+# blur or change events will not work when Firefox is in the background.
+ENV['SELENIUM_BROWSER'] ||= 'chrome'
+
+# Wait for AJAX requests to complete in selenium
+# n.b.: Capybara 2.0 will change the way this works.
+# http://groups.google.com/group/ruby-capybara/browse_thread/thread/6d955173ce413b0a/d0682d47a915dfbd
+Capybara.register_driver :selenium do |app|
+  SingleQuitSeleniumDriver.new(app, :browser => ENV['SELENIUM_BROWSER'].to_sym,
+    :resynchronize => true)
 end
 
-# You may also want to configure DatabaseCleaner to use different strategies for certain features and scenarios.
-# See the DatabaseCleaner documentation for details. Example:
-#
-#   Before('@no-txn,@selenium,@culerity,@celerity,@javascript') do
-#     DatabaseCleaner.strategy = :truncation, {:except => %w[widgets]}
-#   end
-#
-#   Before('~@no-txn', '~@selenium', '~@culerity', '~@celerity', '~@javascript') do
-#     DatabaseCleaner.strategy = :transaction
-#   end
-#
+Before do |scenario|
+  Rails.logger.info "\n\nBeginning scenario #{scenario.file_colon_line} \"#{scenario.title}\""
+end
+
+require "json_spec/cucumber"
+JsonSpec.configure do
+  exclude_keys "id", "created_at", "updated_at", "uuid", "modified_at", "completed_at"
+end

data/features/support/simultaneous_ajax.rb

@@ -0,0 +1,101 @@
+require 'selenium/webdriver'
+
+Before('~@simultaneous_ajax') do
+  evict_capybara_session :selenium_nowait
+end
+
+Before('@simultaneous_ajax') do
+  evict_capybara_session :selenium
+
+  @simultaneous_ajax = true
+  Capybara.javascript_driver = Capybara.current_driver = :selenium_nowait
+end
+
+After('@simultaneous_ajax') do
+  Capybara.javascript_driver = nil
+  @simultaneous_ajax = false
+end
+
+# Evict the "other" selenium driver's session when switching drivers because it
+# seems that WebDriver can't handle having two different browsers open
+# simultaneously. Specifically, if you:
+#
+#   * Run a test with driver A, then
+#   * Run set of tests with driver B, then
+#   * Attempt to run a test with driver A
+#
+# ... the final driver A test will hang attempting to contact some piece of the
+# webdriver infrastructure. It will hang until it times out, or until you
+# kill the browser associated with driver B. This code does the killing for
+# you.
+def evict_capybara_session(driver_name)
+  Capybara.instance_eval do
+    key = session_pool.keys.grep(/^#{driver_name}\:/).first
+    if key
+      session = session_pool.delete(key)
+      puts "key=#{key} evicting session #{session.object_id} driver #{session.driver.object_id}"
+      session.driver.quit
+    end
+  end
+end
+
+class AjaxRefCountListener < Selenium::WebDriver::Support::AbstractEventListener
+  def refcount_key
+    'surveyorIntegratedTestsRequestsOutstanding'
+  end
+
+  def call(*args)
+    event = args.unshift
+    driver = args.pop
+    unless event.to_s =~ /script/ # prevent infinite recursion
+      enable_ajax_call_refcount_if_necessary(driver)
+    end
+  end
+
+  def enable_ajax_call_refcount_if_necessary(driver)
+    unless driver.execute_script "return window.hasOwnProperty('#{refcount_key}')"
+      enable_ajax_call_refcount(driver)
+    end
+  end
+
+  # Taken wholesale from the resynchronize code in Capybara's Selenium driver.
+  # Replicated here because the Capybara implementation doesn't let you make
+  # multiple interactions issuing separate AJAX calls and then wait for all of
+  # them — it can only wait for those AJAX requests issued in the context of a
+  # single interaction (a click, etc.).
+  def enable_ajax_call_refcount(driver)
+    driver.execute_script <<-JS
+      window.#{refcount_key} = 0;
+      (function() { // Overriding XMLHttpRequest
+          var oldXHR = window.XMLHttpRequest;
+
+          function newXHR() {
+              var realXHR = new oldXHR();
+
+              window.#{refcount_key}++;
+              realXHR.addEventListener("readystatechange", function() {
+                  if( realXHR.readyState == 4 ) {
+                    setTimeout( function() {
+                      window.#{refcount_key}--;
+                      if(window.#{refcount_key} < 0) {
+                        window.#{refcount_key} = 0;
+                      }
+                    }, 500 );
+                  }
+              }, false);
+
+              return realXHR;
+          }
+
+          window.XMLHttpRequest = newXHR;
+      })();
+    JS
+  end
+end
+
+# Provides an alternative selenium driver with resync off and refcounting on.
+# This allows for simulation of competing AJAX requests.
+Capybara.register_driver :selenium_nowait do |app|
+  SingleQuitSeleniumDriver.new(app, :browser => ENV['SELENIUM_BROWSER'].to_sym,
+    :resynchronize => false, :listener => AjaxRefCountListener.new)
+end

data/features/support/single_quit_selenium_driver.rb

@@ -0,0 +1,23 @@
+require 'capybara/selenium/driver'
+
+##
+# Subclass of `Capybara::Selenium::Driver` that ensures that quit is only called
+# once.
+#
+# This is necessary because there is code in the Firefox selenium bridge which
+# reacts poorly if its quit method is called more than once. The
+# @simultaneous_ajax support for the duplicate check features requires a
+# separate selenium driver instance, which in turn requires directly calling
+# quit on the running driver when switching between them.
+#
+# Capybara::Selenium::Driver registers an `at_exit` hook which isn't removed
+# when you call quit. This results in quit being called twice for some driver
+# instances, provoking the issue with Firefox.
+class SingleQuitSeleniumDriver < Capybara::Selenium::Driver
+  def quit
+    unless @already_quit
+      super
+      @already_quit = true
+    end
+  end
+end

data/features/support/slow_updates.rb

@@ -0,0 +1,18 @@
+# It appears that rails caches the filter chain after the first request. We
+# can't wait and only apply this if any @slow_updates scenarios are executed.
+class SurveyorController
+  before_filter(:only => :update) do
+    if $delay_updates
+      Rails.logger.info "Slowing things down."
+      sleep 2
+    end
+  end
+end
+
+Before('@slow_updates') do
+  $delay_updates = true
+end
+
+After('@slow_updates') do
+  $delay_updates = false
+end