affectiva-surveyor 1.5.0.pre.disco.2

data/features/step_definitions/surveyor_steps.rb

@@ -0,0 +1,325 @@
+When /^I start the "([^"]*)" survey$/ do |name|
+  steps %Q{
+    When I go to the surveys page
+    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 start the survey in "(.*?)"$/ do |locale|
+    step %Q{I go to the surveys page in "#{locale}"}
+    # these steps need to be separated so the url param has a chance to set I18n.locale
+    step %Q{I press "#{I18n.t 'surveyor.take_it'}"}
+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|
+  ResponseSet.count.should == rs_num.to_i
+  Response.count.should == r_num.to_i
+  table.hashes.each do |hash|
+    if hash.keys == ["answer"]
+      a = Answer.find_by_text(hash["answer"])
+      a.should_not be_nil
+      Response.first(:conditions => {:answer_id => a.id}).should_not be_nil
+    else
+      if !(a = hash.delete("answer")).blank? and !(answer = Answer.find_by_text(a)).blank?
+        Response.first(:conditions => hash.merge({:answer_id => answer.id})).should_not be_nil
+      elsif
+        Response.first(:conditions => hash).should_not be_nil
+      end
+    end
+  end
+end
+
+Then /^there should be (\d+) dependenc(?:y|ies)$/ do |x|
+  Dependency.count.should == x.to_i
+end
+
+Then /^question "([^"]*)" should have a dependency with rule "([^"]*)"$/ do |qr, rule|
+  q = Question.find_by_reference_identifier(qr)
+  q.should_not be_blank
+  q.dependency.should_not be_nil
+  q.dependency.rule.should == rule
+end
+
+Then /^the element "([^"]*)" should have the class "([^"]*)"$/ do |selector, css_class|
+  page.should have_selector(selector, :class => css_class)
+end
+
+Then /^the element "([^"]*)" should exist$/ do |selector|
+  page.should have_selector(selector)
+end
+
+Then /^the survey should be complete$/ do
+  ResponseSet.first.should be_complete
+end
+
+Then /^a dropdown should exist with the options "([^"]*)"$/ do |options_text|
+  page.should have_selector('select')
+  options = options_text.split(',').collect(&:strip)
+  within "select" do |select|
+    options.each do |o|
+      select o
+    end
+  end
+end
+
+Then /^there should be (\d+) checkboxes$/ do |count|
+  page.should have_selector('input[type=checkbox]', :count => count.to_i)
+end
+
+Then /^there should be (\d+) text areas$/ do |count|
+  page.should have_selector('textarea', :count => count.to_i)
+end
+
+Then /^the question "([^"]*)" should be triggered$/ do |text|
+  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|
+  Response.count.should == count.to_i
+  Response.find_by_answer_id(Answer.find_by_text(answer_text)).should_not be_blank
+end
+
+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 = []
+  where = {}
+  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' || 'datetime' || 'time'
+        where[:datetime_value] = Time.zone.parse(value).utc
+      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).where(where).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
+
+## JSON
+
+def last_json
+  page.find('body').text
+end
+
+When /^I visit "(.*?)"$/ do |path|
+  visit path
+end
+
+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
+
+Then /^the JSON representation for "(.*?)" should be:$/ do |title, string|
+  Survey.find_by_title(title).as_json.to_json.should be_json_eql(string)
+end
+
+Given /^I prefix the titles of exported surveys with "(.*?)"$/ do |prefix|
+  PREFIX = prefix
+  class Survey < ActiveRecord::Base
+    include Surveyor::Models::SurveyMethods
+    def filtered_for_json
+      dolly = self.clone
+      dolly.sections = self.sections
+      dolly.title = "#{PREFIX}#{dolly.title}"
+      dolly
+    end
+  end
+end
+
+## Hidden and shown elements
+
+Then /the element "([^\"]*)" should be hidden$/ do |selector|
+  wait_until do
+    its_hidden = page.evaluate_script("$('#{selector}').is(':hidden');")
+    its_not_in_dom = page.evaluate_script("$('#{selector}').length == 0;")
+    (its_hidden || its_not_in_dom).should be_true
+  end
+end
+
+Then /the element "([^\"]*)" should not be hidden$/ do |selector|
+  wait_until do
+    its_not_hidden = page.evaluate_script("$('#{selector}').is(':not(:hidden)');")
+    its_in_dom = page.evaluate_script("$('#{selector}').length > 0;")
+    (its_not_hidden && its_in_dom).should be_true
+  end
+end
+
+## Context and substitution with mustache
+
+Given /^I have survey context of "(.*)"$/ do |context|
+  class SurveyorController < ApplicationController
+    require 'mustache'
+    class FakeMustacheContext < ::Mustache
+      def name
+        "Santa Claus"
+      end
+      def site
+        "Northwestern"
+      end
+    end
+    def render_context
+      FakeMustacheContext
+    end
+  end
+end
+
+Given /^I have a simple hash context$/ do
+  class SurveyorController < ApplicationController
+    def render_context
+      {:name => "Moses", :site => "Northwestern"}
+    end
+  end
+end
+
+Given /^I replace question numbers with letters$/ do
+  module SurveyorHelper
+    include Surveyor::Helpers::SurveyorHelperMethods
+    def next_question_number(question)
+      @letters ||= ("A".."Z").to_a
+      @n ||= 25
+      "<span class='qnum'>#{@letters[(@n += 1)%26]}. </span>"
+    end
+  end
+end
+
+## Various input elements
+
+Then /^I should see (\d+) textarea(?:s?) on the page$/ do |i|
+  page.has_css?('textarea', :count => i).should == true
+end
+
+Then /^I should see (\d+) text input(?:s?) on the page$/ do |i|
+  page.has_css?('input[type="text"]', :count => i).should == true
+end
+
+Then /^I should see no text input(?:s?) on the page$/ do
+  page.has_css?('input[type="text"]').should == false
+end
+
+Then /^I should see (\d+) "(.*?)" input(?:s?) on the page$/ do |i, css_class|
+  page.has_css?("input.#{css_class}", :count => i).should == true
+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
+
+## for Rails 3.0
+Then /^I set the asset directory$/ do
+  ActionController::Base.helpers.config.assets_dir = "public" unless asset_pipeline_enabled?
+end
+
+When(/^I change the locale to "(.*?)"$/) do |locale|
+  steps %Q{When I select "#{locale}" from "new_locale"}
+end

data/features/step_definitions/ui_steps.rb

@@ -0,0 +1,25 @@
+When /^I select "([^"]+)" as the datepicker's (\w+)$/ do |selection, type|
+  page.find(".ui-datepicker-#{type}").select(selection)
+end
+
+When /^I click the first date field$/ do
+  first(:css, "input.date[type='text']").click
+end
+
+Then /^the first date field should contain "(.*?)"$/ do |value|
+  field_value = first(:css, "input.date[type='text']").value
+  if field_value.respond_to? :should
+    field_value.should =~ /#{value}/
+  else
+    assert_match(/#{value}/, field_value)
+  end
+end
+
+Then /^the first date field should not contain "(.*?)"$/ do |value|
+  field_value = first(:css, "input.date[type='text']").value
+  if field_value.respond_to? :should_not
+    field_value.should_not =~ /#{value}/
+  else
+    assert_no_match(/#{value}/, field_value)
+  end
+end

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,225 @@
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file was generated by Cucumber-Rails and is only here to get you a head start
+# These step definitions are thin wrappers around the Capybara/Webrat API that lets you
+# visit pages, interact with widgets and make assertions about page content.
+#
+# If you use these step definitions as basis for your features you will quickly end up
+# with features that are:
+#
+# * Hard to maintain
+# * Verbose to read
+#
+# A much better approach is to write your own higher level step definitions, following
+# the advice in the following blog posts:
+#
+# * http://benmabey.com/2008/05/19/imperative-vs-declarative-scenarios-in-user-stories.html
+# * http://dannorth.net/2011/01/31/whose-domain-is-it-anyway/
+# * http://elabs.se/blog/15-you-re-cuking-it-wrong
+#
+
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "selectors"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step, parent|
+  with_scope(parent) { When step }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step, parent, table_or_string|
+  with_scope(parent) { When "#{step}:", table_or_string }
+end
+
+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 )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
+
+When /^(?:|I )check "([^"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+When /^(?:|I )click "([^"]*)"$/ do |field|
+  find_field(field).click
+end
+
+When /^(?:|I )change "([^"]*)" to "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+  id = "#" + find_field(field)[:id]
+  page.execute_script("$('#{id}').trigger('change');")
+end
+
+Then /^(?:|I )should see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_content(text)
+  else
+    assert page.has_content?(text)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_xpath('//*', :text => regexp)
+  else
+    assert page.has_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_no_content(text)
+  else
+    assert page.has_no_content?(text)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
+  else
+    assert page.has_no_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) 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, parent, value|
+  with_scope(parent) 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|radiobutton)(?: within (.*))? should be checked$/ do |label, _, parent|
+  with_scope(parent) 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|radiobutton)(?: within (.*))? should not be checked$/ do |label, _, parent|
+  with_scope(parent) 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
+
+Then /^I should get a "(\d+)" response$/ do |http_status|
+  page.status_code.should == http_status.to_i
+end