hssc_surveyor 1.4.1.pre

data/features/no_duplicates.feature

@@ -0,0 +1,110 @@
+@javascript @slow_updates @simultaneous_ajax
+Feature: Duplicate response prevention
+  As a survey administrator
+  I want to get exactly the number of responses entered
+  So that my results are analytically valid
+
+Scenario: With a simple pick-one question
+  Given the question
+    """
+    q_1 "Was this saved?", :pick => :one
+    a_y "Yes"
+    a_n "No"
+    """
+  When I start the survey
+   And I choose "Yes"
+   And I choose "No"
+   And I wait for things to settle out
+  Then there should be a response for answer "n"
+   And there should not be a response for answer "y"
+
+Scenario: With a simple pick-any question
+  Given the question
+    """
+    q_1 "What is the state of the cat?", :pick => :any
+    a_d "Dead"
+    a_a "Alive"
+    a_s "Sleeping"
+    """
+  When I start the survey
+   And I check "Alive"
+   And I check "Dead"
+   And I uncheck "Dead"
+   And I check "Sleeping"
+   And I wait for things to settle out
+  Then there should be a response for answer "a"
+   And there should be a response for answer "s"
+   And there should not be a response for answer "d"
+
+Scenario: With a free text question
+  Given the question
+    """
+    q_1 "What is your favorite movie?"
+    answer "Title", :string
+    """
+  When I start the survey
+   And I fill in "Title" with "The Shawshank Redemption"
+   And I click elsewhere
+   And I fill in "Title" with "Rear Window"
+   And I click elsewhere
+   And I wait for things to settle out
+   And there should be a string response with value "Rear Window"
+  Then there should not be a string response with value "The Shawshank Redemption"
+
+Scenario: With a pick-one plus free text question
+  Given the question
+    """
+    q_1 "Where is Panama City?", :pick => :one
+    a_florida "Florida"
+    a_panama "Panama"
+    a_other :other, :string
+    """
+  When I start the survey
+   And I choose "Florida"
+   And I choose "Other"
+   And I fill in the string for "other" with "Chicago"
+   And I click elsewhere
+   And I wait for things to settle out
+  Then there should be a string response for answer "other" with value "Chicago"
+   And there should not be a response for answer "florida"
+
+Scenario: With a grid question
+  Given the question
+    """
+    grid "Tell us how often do you cover these each day" do
+      a_1 "1"
+      a_2 "2"
+      a_3 "3"
+      q_h "Head", :pick => :one
+      q_k "Knees", :pick => :one
+      q_t "Toes", :pick => :one
+    end
+    """
+  When I start the survey
+   And I choose row 1, column 3 of the grid
+   And I choose row 1, column 2 of the grid
+   And I choose row 2, column 1 of the grid
+   And I wait for things to settle out
+  Then there should be a response for answer "2" on question "h"
+   And there should not be a response for answer "3" on question "h"
+   And there should be a response for answer "1" on question "k"
+
+Scenario: With a repeater
+  Given the question
+    """
+    repeater "List your former addresses" do
+      q "Address"
+      a_address_line "Line", :string
+    end
+    """
+  When I start the survey
+   And I fill in the 1st string for "address_line" with "10 Downing St."
+   And I press "+ add row"
+   And I fill in the 2nd string for "address_line" with "1600 Penn Ave."
+   And I click elsewhere
+   And I fill in the 2nd string for "address_line" with "1600 Pennsylvania Ave."
+   And I click elsewhere
+   And I wait for things to settle out longer
+  Then there should be a string response for answer "address_line" with value "10 Downing St."
+   And there should not be a string response for answer "address_line" with value "1600 Penn Ave."
+   And there should be a string response for answer "address_line" with value "1600 Pennsylvania Ave."

data/features/show_survey.feature

@@ -0,0 +1,71 @@
+Feature: showing a survey
+  As a survey administrator
+  I want to see a survey that a participant has taken
+  So that I can understand the data
+
+  Scenario: Take a survey, then look at it
+    Given I parse
+    """
+      survey "Favorites" do
+        section "Colors" do
+          label "You with the sad eyes don't be discouraged"
+
+          question_1 "What is your favorite color?", :pick => :one
+          answer "red"
+          answer "blue"
+          answer "green"
+          answer :other
+
+          q_2b "Choose the colors you don't like", :pick => :any
+          a_1 "orange"
+          a_2 "purple"
+          a_3 "brown"
+          a :omit
+        end
+      end
+    """
+    When I start the "Favorites" survey
+    Then I should see "You with the sad eyes don't be discouraged"
+    And I choose "red"
+    And I choose "blue"
+    And I check "orange"
+    And I check "brown"
+    And I press "Click here to finish"
+    Then there should be 1 response set with 3 responses with:
+      | answer |
+      | blue   |
+      | orange |
+      | brown  |
+    When I go to the last response set show page
+    Then I should see "You with the sad eyes don't be discouraged"
+    Then the "blue" radiobutton should be checked
+    And the "orange" checkbox should be checked
+    And the "brown" checkbox should be checked
+
+  Scenario: Take a survey with group questions, then look at it
+    Given I parse
+    """
+      survey "Grid question test", :default_mandatory => false do
+        section 'Communication Skills' do
+          grid 'Identify communication and interviewing skills' do
+            a 'Yes'
+            a 'No'
+
+            q 'Able to articulate job duties and skills', :pick => :one
+          end
+
+          q 'Communication Skills Comments'
+          a :text
+        end
+      end
+    """
+    When I start the "Grid question test" survey
+    Then I should see "Identify communication and interviewing skills"
+    And I choose "Yes"
+    And I press "Click here to finish"
+    Then there should be 1 response set with 1 responses with:
+      | answer |
+      | Yes    |
+    When I go to the last response set show page
+    Then I should see "Identify communication and interviewing skills"
+    Then the "Yes" radiobutton should be checked

data/features/step_definitions/parser_steps.rb

@@ -0,0 +1,145 @@
+Given /^I parse$/ do |string|
+  Surveyor::Parser.parse(string)
+end
+
+Given /^the survey$/ do |string|
+  @survey_string = string
+end
+
+Then /^the parser should fail with "(.*)"$/ do |error_message|
+  lambda { Surveyor::Parser.parse(@survey_string) }.should raise_error(Surveyor::ParserError, /#{error_message}/)
+end
+
+Given /^the questions?$/ do |q_string|
+  Surveyor::Parser.parse(<<-SURVEY)
+    survey "Some questions for you" do
+      section "All the questions" do
+        #{q_string}
+      end
+    end
+  SURVEY
+end
+
+Given /^I parse redcap file "(.*)"$/ do |name|
+  Surveyor::RedcapParser.parse File.read(File.join(Rails.root, '..', 'features', 'support', name)), name
+end
+
+Then /^there should be (\d+) survey(?:s?) with:$/ do |x, table|
+  Survey.count.should == x.to_i
+  table.hashes.each do |hash|
+    Survey.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) translations with$/ do |x, table|
+  SurveyTranslation.count.should == x.to_i
+  table.hashes.each do |hash|
+    SurveyTranslation.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) section(?:s?) with:$/ do |x, table|
+  SurveySection.count.should == x.to_i
+  table.hashes.each do |hash|
+    SurveySection.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) question groups with:$/ do |x, table|
+  QuestionGroup.count.should == x.to_i
+  table.hashes.each do |hash|
+    QuestionGroup.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) question(?:s?) with:$/ do |x, table|
+  Question.count.should == x.to_i
+  table.hashes.each do |hash|
+    hash["reference_identifier"] = nil if hash["reference_identifier"] == "nil"
+    hash["custom_class"] = nil if hash["custom_class"] == "nil"
+    if hash.has_key?("is_mandatory")
+      hash["is_mandatory"] = (hash["is_mandatory"] == "true" ? true : (hash["is_mandatory"] == "false" ? false : hash["is_mandatory"]))
+    end
+    result = Question.find(:first, :conditions => hash)
+    puts hash if result.nil?
+    result.should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) question(?:s?) with a correct answer$/ do |x|
+  Question.count(:conditions => "correct_answer_id NOT NULL").should == x.to_i
+  Question.all(:conditions => "correct_answer_id NOT NULL").compact.map(&:correct_answer).compact.size.should == x.to_i
+end
+
+Then /^there should be (\d+) answer(?:s?) with:$/ do |x, table|
+  Answer.count.should == x.to_i
+  table.hashes.each do |hash|
+    hash["reference_identifier"] = nil if hash["reference_identifier"] == "nil"
+    Answer.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) dependenc(?:y|ies) with:$/ do |x, table|
+  Dependency.count.should == x.to_i
+  table.hashes.each do |hash|
+    Dependency.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) resolved dependency_condition(?:s?) with:$/ do |x, table|
+  DependencyCondition.count.should == x.to_i
+  
+  table.hashes.each do |hash|
+    if hash.has_key?("question_reference")
+      question = Question.find_by_reference_identifier(hash.delete("question_reference"))
+      question.should_not be_nil
+      
+      hash.merge!({ :question_id => question.id })
+      
+      if hash.has_key?("answer_reference")
+        answer = Answer.find(:first, :conditions => { :question_id => question.id, :reference_identifier => hash.delete("answer_reference") })
+        answer.should_not be_nil
+        
+        hash.merge!({ :answer_id => answer.id })
+      end
+    end
+   
+    d = DependencyCondition.find(:first, :conditions => hash)
+    d.should_not be_nil
+    d.question.should_not be_nil
+    d.answer.should_not be_nil unless d.operator.match(/^count[<>=!]{1,2}\d+/)
+  end
+end
+
+
+Then /^there should be (\d+) validation(?:s?) with:$/ do |x, table|
+  Validation.count.should == x.to_i
+  table.hashes.each do |hash|
+    Validation.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^there should be (\d+) validation_condition(?:s?) with:$/ do |x, table|
+  ValidationCondition.count.should == x.to_i
+  table.hashes.each do |hash|
+    hash["integer_value"] = nil if hash["integer_value"] == "nil"
+    ValidationCondition.find(:first, :conditions => hash).should_not be_nil
+  end
+end
+
+Then /^question "([^"]*)" should have correct answer "([^"]*)"$/ do |qr, ar|
+  (q = Question.find_by_reference_identifier(qr)).should_not be_nil
+  q.correct_answer.should == q.answers.find_by_reference_identifier(ar)
+end
+
+Then /^(\d+) dependencies should depend on questions$/ do |x|
+  arr = Dependency.find_all_by_question_group_id(nil)
+  arr.size.should == 2
+  arr.each{|d| d.question.should_not be_nil}
+end
+
+Then /^(\d+) dependencies should depend on question groups$/ do |x|
+  arr = Dependency.find_all_by_question_id(nil)
+  arr.size.should == 2
+  arr.each{|d| d.question_group.should_not be_nil}
+end

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