hssc_surveyor 1.4.1.pre

data/spec/models/response_spec.rb

@@ -0,0 +1,218 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Response, "when saving a response" do
+  before(:each) do
+    # @response = Response.new(:question_id => 314, :response_set_id => 159, :answer_id => 1)
+    @response = Factory(:response, :question => Factory(:question), :answer => Factory(:answer))
+  end
+
+  it "should be valid" do
+    @response.should be_valid
+  end
+
+  it "should be invalid without a question" do
+    @response.question_id = nil
+    @response.should have(1).error_on(:question_id)
+  end
+
+  it "should be correct if the question has no correct_answer_id" do
+    @response.question.correct_answer_id.should be_nil
+    @response.correct?.should be_true
+  end
+
+  it "should be correct if the answer's response class != answer" do
+    @response.answer.response_class.should_not == "answer"
+    @response.correct?.should be_true
+  end
+
+  it "should be (in)correct if answer_id is (not) equal to question's correct_answer_id" do
+    @answer = Factory(:answer, :response_class => "answer")
+    @question = Factory(:question, :correct_answer => @answer)
+    @response = Factory(:response, :question => @question, :answer => @answer)
+    @response.correct?.should be_true
+    @response.answer = Factory(:answer, :response_class => "answer").tap { |a| a.id = 143 }
+    @response.correct?.should be_false
+  end
+  
+  it "should be in order by created_at" do
+    @response.response_set.should_not be_nil
+    response2 = Factory(:response, :question => Factory(:question), :answer => Factory(:answer), :response_set => @response.response_set, :created_at => (@response.created_at + 1))
+    Response.all.should == [@response, response2]
+  end
+  
+  it "should protect api_id, timestamps" do
+    saved_attrs = @response.attributes
+    if defined? ActiveModel::MassAssignmentSecurity::Error
+      lambda {@response.update_attributes(:created_at => 3.days.ago, :updated_at => 3.hours.ago)}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      lambda {@response.update_attributes(:api_id => "NEW")}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+    else
+      @response.attributes = {:created_at => 3.days.ago, :updated_at => 3.hours.ago} # automatically protected by Rails
+      @response.attributes = {:api_id => "NEW"} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+    end
+    @response.attributes.should == saved_attrs
+  end
+  
+
+  describe "returns the response as the type requested" do
+    it "returns 'string'" do
+      @response.string_value = "blah"
+      @response.as("string").should == "blah"
+      @response.as(:string).should == "blah"
+    end
+
+    it "returns 'integer'" do
+      @response.integer_value = 1001
+      @response.as(:integer).should == 1001
+    end
+
+    it "returns 'float'" do
+      @response.float_value = 3.14
+      @response.as(:float).should == 3.14
+    end
+
+    it "returns 'answer'" do
+      @response.answer_id = 14
+      @response.as(:answer).should == 14
+    end
+
+    it "default returns answer type if not specified" do
+      @response.answer_id =18
+      @response.as(:stuff).should == 18
+    end
+
+    it "returns empty elements if the response is cast as a type that is not present" do
+      resp = Response.new(:question_id => 314, :response_set_id => 156)
+      resp.as(:string).should == nil
+      resp.as(:integer).should == nil
+      resp.as(:float).should == nil
+      resp.as(:answer).should == nil
+      resp.as(:stuff).should == nil
+    end
+  end
+end
+
+describe Response, "applicable_attributes" do
+  before(:each) do
+    @who = Factory(:question, :text => "Who rules?")
+    @odoyle = Factory(:answer, :text => "Odoyle", :response_class => "answer")
+    @other = Factory(:answer, :text => "Other", :response_class => "string")
+  end
+
+  it "should have string_value if response_type is string" do
+    good = {"question_id" => @who.id, "answer_id" => @other.id, "string_value" => "Frank"}
+    Response.applicable_attributes(good).should == good
+  end
+
+  it "should not have string_value if response_type is answer" do
+    bad = {"question_id"=>@who.id, "answer_id"=>@odoyle.id, "string_value"=>"Frank"}
+    Response.applicable_attributes(bad).
+      should == {"question_id" => @who.id, "answer_id"=> @odoyle.id}
+  end
+
+  it "should have string_value if response_type is string and answer_id is an array (in the case of checkboxes)" do
+    good = {"question_id"=>@who.id, "answer_id"=>["", @odoyle.id], "string_value"=>"Frank"}
+    Response.applicable_attributes(good).
+      should == {"question_id" => @who.id, "answer_id"=> ["", @odoyle.id]}
+  end
+
+  it "should have ignore attribute if missing answer_id" do
+    ignore = {"question_id"=>@who.id, "answer_id"=>"", "string_value"=>"Frank"}
+    Response.applicable_attributes(ignore).
+      should == {"question_id"=>@who.id, "answer_id"=>"", "string_value"=>"Frank"}
+  end
+
+  it "should have ignore attribute if missing answer_id is an array" do
+    ignore = {"question_id"=>@who.id, "answer_id"=>[""], "string_value"=>"Frank"}
+    Response.applicable_attributes(ignore).
+      should == {"question_id"=>@who.id, "answer_id"=>[""], "string_value"=>"Frank"}
+  end
+end
+
+describe Response, '#to_formatted_s' do
+  context "when datetime" do
+    let(:r) { Response.new(:answer => Answer.new(:response_class => 'datetime')) }
+
+    it 'returns "" when nil' do
+      r.datetime_value = nil
+
+      r.to_formatted_s.should == ""
+    end
+  end
+end
+
+describe Response, '#json_value' do
+  context "when integer" do
+    let(:r) {Response.new(:integer_value => 2, :answer => Answer.new(:response_class => 'integer'))}
+    it "should be 2" do
+      r.json_value.should == 2
+    end
+  end
+
+  context "when float" do
+    let(:r) {Response.new(:float_value => 3.14, :answer => Answer.new(:response_class => 'float'))}
+    it "should be 3.14" do
+      r.json_value.should == 3.14
+    end
+  end
+
+  context "when string" do
+    let(:r) {Response.new(:string_value => 'bar', :answer => Answer.new(:response_class => 'string'))}
+    it "should be 'bar'" do
+      r.json_value.should == 'bar'
+    end
+  end
+
+  context "when datetime" do
+    let(:r) {Response.new(:datetime_value => DateTime.strptime('2010-04-08T10:30+00:00', '%Y-%m-%dT%H:%M%z'), :answer => Answer.new(:response_class => 'datetime'))}
+    it "should be '2010-04-08T10:30+00:00'" do
+      r.json_value.should == '2010-04-08T10:30+00:00'
+      r.json_value.to_json.should == '"2010-04-08T10:30+00:00"'
+    end
+  end
+
+  context "when date" do
+    let(:r) {Response.new(:datetime_value => DateTime.strptime('2010-04-08', '%Y-%m-%d'), :answer => Answer.new(:response_class => 'date'))}
+    it "should be '2010-04-08'" do
+      r.json_value.should == '2010-04-08'
+      r.json_value.to_json.should == '"2010-04-08"'
+    end
+  end
+
+  context "when time" do
+    let(:r) {Response.new(:datetime_value => DateTime.strptime('10:30', '%H:%M'), :answer => Answer.new(:response_class => 'time'))}
+    it "should be '10:30'" do
+      r.json_value.should == '10:30'
+      r.json_value.to_json.should == '"10:30"'
+    end
+  end
+end
+
+describe Response, 'value methods' do
+  let(:response) { Response.new }
+
+  describe '#date_value=' do
+    it 'accepts a parseable date string' do
+      response.date_value = '2010-01-15'
+      response.datetime_value.strftime('%Y %m %d').should == '2010 01 15'
+    end
+
+    it 'clears when given nil' do
+      response.datetime_value = Time.new
+      response.date_value = nil
+      response.datetime_value.should be_nil
+    end
+  end
+
+  describe 'time_value=' do
+    it 'accepts a parseable time string' do
+      response.time_value = '11:30'
+      response.datetime_value.strftime('%H %M %S').should == '11 30 00'
+    end
+
+    it 'clears when given nil' do
+      response.datetime_value = Time.new
+      response.time_value = nil
+      response.datetime_value.should be_nil
+    end
+  end
+end

data/spec/models/survey_section_spec.rb

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SurveySection do
+    let(:survey_section){ Factory(:survey_section) }
+
+  context "when creating" do
+    it "is invalid without #title" do
+      survey_section.title = nil
+      survey_section.should have(1).error_on(:title)
+    end
+    it "protects #api_id" do
+      saved_attrs = survey_section.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { survey_section.update_attributes(:api_id => "NEW") }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        survey_section.attributes = {:api_id => "NEW"} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      survey_section.attributes.should == saved_attrs
+    end
+    it "protects #created_at" do
+      saved_attrs = survey_section.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { survey_section.update_attributes(:created_at => 3.days.ago) }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        survey_section.attributes = {:created_at => 3.days.ago} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      survey_section.attributes.should == saved_attrs
+    end
+    it "protects #updated_at" do
+      saved_attrs = survey_section.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { survey_section.update_attributes(:updated_at => 3.hours.ago) }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        survey_section.attributes = {:updated_at => 3.hours.ago} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      survey_section.attributes.should == saved_attrs
+    end
+  end
+
+  context "with questions" do
+    let(:question_1){ Factory(:question, :survey_section => survey_section, :display_order => 3, :text => "Peep")}
+    let(:question_2){ Factory(:question, :survey_section => survey_section, :display_order => 1, :text => "Little")}
+    let(:question_3){ Factory(:question, :survey_section => survey_section, :display_order => 2, :text => "Bo")}
+    before do
+      [question_1, question_2, question_3].each{|q| survey_section.questions << q }
+    end
+    it{ survey_section.should have(3).questions}
+    it "gets questions in order" do
+      survey_section.questions.should == [question_2, question_3, question_1]
+      survey_section.questions.map(&:display_order).should == [1,2,3]
+    end
+    it "deletes child questions when deleted" do
+      question_ids = survey_section.questions.map(&:id)
+      survey_section.destroy
+      question_ids.each{|id| Question.find_by_id(id).should be_nil}
+    end
+  end
+
+  context "with translations" do
+    require 'yaml'
+    let(:survey){ Factory(:survey) }
+    let(:survey_translation){
+      Factory(:survey_translation, :locale => :es, :translation => {
+        :survey_sections => {
+          :one => {
+            :title => "Uno"
+          }
+        }
+      }.to_yaml)
+    }
+    before do
+      survey_section.reference_identifier = "one"
+      survey_section.survey = survey
+      survey.translations << survey_translation
+    end
+    it "returns its own translation" do
+      YAML.load(survey_translation.translation).should_not be_nil
+      survey_section.translation(:es)[:title].should == "Uno"
+    end
+    it "returns its own default values" do
+      survey_section.translation(:de).should == {"title" => survey_section.title, "description" => survey_section.description}
+    end
+  end
+end

data/spec/models/survey_spec.rb

@@ -0,0 +1,191 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Survey do
+  let(:survey){ Factory(:survey) }
+
+  context "when creating" do
+    it "is invalid without #title" do
+      survey.title = nil
+      survey.should have(1).error_on :title
+    end
+    it "adjust #survey_version" do
+      original = Survey.new(:title => "Foo")
+      original.save.should be_true
+      original.survey_version.should == 0
+      imposter = Survey.new(:title => "Foo")
+      imposter.save.should be_true
+      imposter.title.should == "Foo"
+      imposter.survey_version.should == 1
+      bandwagoneer = Survey.new(:title => "Foo")
+      bandwagoneer.save.should be_true
+      bandwagoneer.title.should == "Foo"
+      bandwagoneer.survey_version.should == 2
+    end
+    it "prevents duplicate #survey_version" do
+      original = Survey.new(:title => "Foo")
+      original.save.should be_true
+      imposter = Survey.new(:title => "Foo")
+      imposter.save.should be_true
+      imposter.survey_version = 0
+      imposter.save.should be_false
+      imposter.should have(1).error_on(:survey_version)
+    end
+    it "doesn't adjust #title when" do
+      original = Factory(:survey, :title => "Foo")
+      original.save.should be_true
+      original.update_attributes(:title => "Foo")
+      original.title.should == "Foo"
+    end
+    it "has #api_id with 36 characters by default" do
+      survey.api_id.length.should == 36
+    end
+    it "protects #access_code" do
+      saved_attrs = survey.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { survey.update_attributes(:access_code => "NEW") }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        survey.attributes = {:access_code => "NEW"} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      survey.attributes.should == saved_attrs
+    end
+    it "protects #api_id" do
+      saved_attrs = survey.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { survey.update_attributes(:api_id => "NEW") }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        survey.attributes = {:api_id => "NEW"} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      survey.attributes.should == saved_attrs
+    end
+    it "protects #created_at" do
+      saved_attrs = survey.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { survey.update_attributes(:created_at => 3.days.ago) }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        survey.attributes = {:created_at => 3.days.ago} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      survey.attributes.should == saved_attrs
+    end
+    it "protects #updated_at" do
+      saved_attrs = survey.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { survey.update_attributes(:updated_at => 3.hours.ago) }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        survey.attributes = {:updated_at => 3.hours.ago} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      survey.attributes.should == saved_attrs
+    end
+  end
+
+  context "activating" do
+    it { survey.active?.should }
+    it "both #inactive_at and #active_at == nil by default" do
+      survey.active_at.should be_nil
+      survey.inactive_at.should be_nil
+    end
+    it "#active_at on a certain date/time" do
+      survey.inactive_at = 2.days.from_now
+      survey.active_at = 2.days.ago
+      survey.active?.should be_true
+    end
+    it "#inactive_at on a certain date/time" do
+      survey.active_at = 3.days.ago
+      survey.inactive_at = 1.days.ago
+      survey.active?.should be_false
+    end
+    it "#activate! and #deactivate!" do
+      survey.activate!
+      survey.active?.should be_true
+      survey.deactivate!
+      survey.active?.should be_false
+    end
+    it "nils out past values of #inactive_at on #activate!" do
+      survey.inactive_at = 5.days.ago
+      survey.active?.should be_false
+      survey.activate!
+      survey.active?.should be_true
+      survey.inactive_at.should be_nil
+    end
+    it "nils out pas values of #active_at on #deactivate!" do
+      survey.active_at = 5.days.ago
+      survey.active?.should be_true
+      survey.deactivate!
+      survey.active?.should be_false
+      survey.active_at.should be_nil
+    end
+  end
+
+  context "with survey_sections" do
+    let(:s1){ Factory(:survey_section, :survey => survey, :title => "wise", :display_order => 2)}
+    let(:s2){ Factory(:survey_section, :survey => survey, :title => "er", :display_order => 3)}
+    let(:s3){ Factory(:survey_section, :survey => survey, :title => "bud", :display_order => 1)}
+    let(:q1){ Factory(:question, :survey_section => s1, :text => "what is wise?", :display_order => 2)}
+    let(:q2){ Factory(:question, :survey_section => s2, :text => "what is er?", :display_order => 4)}
+    let(:q3){ Factory(:question, :survey_section => s2, :text => "what is mill?", :display_order => 3)}
+    let(:q4){ Factory(:question, :survey_section => s3, :text => "what is bud?", :display_order => 1)}
+    before do
+      [s1, s2, s3].each{|s| survey.sections << s }
+      s1.questions << q1
+      s2.questions << q2
+      s2.questions << q3
+      s3.questions << q4
+    end
+
+    it{ survey.should have(3).sections}
+    it "gets survey_sections in order" do
+      survey.sections.should == [s3, s1, s2]
+      survey.sections.map(&:display_order).should == [1,2,3]
+    end
+    it "gets survey_sections_with_questions in order" do
+      survey.sections_with_questions.map(&:questions).flatten.should have(4).questions
+      survey.sections_with_questions.map(&:questions).flatten.should == [q4,q1,q3,q2]
+    end
+    it "deletes child survey_sections when deleted" do
+      survey_section_ids = survey.sections.map(&:id)
+      survey.destroy
+      survey_section_ids.each{|id| SurveySection.find_by_id(id).should be_nil}
+    end
+  end
+
+  context "serialization" do
+    let(:s1){ Factory(:survey_section, :survey => survey, :title => "wise") }
+    let(:s2){ Factory(:survey_section, :survey => survey, :title => "er") }
+    let(:q1){ Factory(:question, :survey_section => s1, :text => "what is wise?") }
+    let(:q2){ Factory(:question, :survey_section => s2, :text => "what is er?") }
+    let(:q3){ Factory(:question, :survey_section => s2, :text => "what is mill?") }
+    before do
+      [s1, s2].each{|s| survey.sections << s }
+      s1.questions << q1
+      s2.questions << q2
+      s2.questions << q3
+    end
+
+    it "includes title, sections, and questions" do
+      actual = survey.as_json
+      actual[:title].should == 'Simple survey'
+      actual[:sections].size.should == 2
+      actual[:sections][0][:questions_and_groups].size.should == 1
+      actual[:sections][1][:questions_and_groups].size.should == 2
+    end
+  end
+
+  context "with translations" do
+    require 'yaml'
+    let(:survey_translation){
+      Factory(:survey_translation, :locale => :es, :translation => {
+        :title => "Un idioma nunca es suficiente"
+      }.to_yaml)
+    }
+    before do
+      survey.translations << survey_translation
+    end
+    it "returns its own translation" do
+      YAML.load(survey_translation.translation).should_not be_nil
+      survey.translation(:es)[:title].should == "Un idioma nunca es suficiente"
+    end
+    it "returns its own default values" do
+      survey.translation(:de).should == {"title" => survey.title, "description" => survey.description}
+    end
+  end
+end

data/spec/models/validation_condition_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ValidationCondition, "Class methods" do
+  it "should have a list of operators" do
+    %w(== != < > <= >= =~).each{|operator| ValidationCondition.operators.include?(operator).should be_true }
+  end
+end
+
+describe ValidationCondition do
+  before(:each) do
+    @validation_condition = Factory(:validation_condition)
+  end
+  
+  it "should be valid" do
+     @validation_condition.should be_valid
+  end
+  # this causes issues with building and saving
+  # it "should be invalid without a parent validation_id" do
+  #   @validation_condition.validation_id = nil
+  #   @validation_condition.should have(1).errors_on(:validation_id)
+  # end
+
+  it "should be invalid without an operator" do
+    @validation_condition.operator = nil
+    @validation_condition.should have(2).errors_on(:operator)
+  end
+  
+  it "should be invalid without a rule_key" do
+    @validation_condition.should be_valid
+    @validation_condition.rule_key = nil
+    @validation_condition.should_not be_valid
+    @validation_condition.should have(1).errors_on(:rule_key)
+  end
+
+  it "should have unique rule_key within the context of a validation" do
+   @validation_condition.should be_valid
+   Factory(:validation_condition, :validation_id => 2, :rule_key => "2")
+   @validation_condition.rule_key = "2" #rule key uniquness is scoped by validation_id
+   @validation_condition.validation_id = 2
+   @validation_condition.should_not be_valid
+   @validation_condition.should have(1).errors_on(:rule_key)
+  end
+
+  it "should have an operator in ValidationCondition.operators" do
+    ValidationCondition.operators.each do |o|
+      @validation_condition.operator = o
+      @validation_condition.should have(0).errors_on(:operator)
+    end
+    @validation_condition.operator = "#"
+    @validation_condition.should have(1).error_on(:operator)
+  end
+  it "should protect timestamps" do
+    saved_attrs = @validation_condition.attributes
+    if defined? ActiveModel::MassAssignmentSecurity::Error
+      lambda {@validation_condition.update_attributes(:created_at => 3.days.ago, :updated_at => 3.hours.ago)}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+    else
+      @validation_condition.attributes = {:created_at => 3.days.ago, :updated_at => 3.hours.ago} # automatically protected by Rails
+    end
+    @validation_condition.attributes.should == saved_attrs
+  end
+end
+
+describe ValidationCondition, "validating responses" do
+  def test_var(vhash, ahash, rhash)
+    v = Factory(:validation_condition, vhash)
+    a = Factory(:answer, ahash)
+    r = Factory(:response, {:answer => a, :question => a.question}.merge(rhash))
+    return v.is_valid?(r)
+  end
+  
+  it "should validate a response by regexp" do
+    test_var({:operator => "=~", :regexp => /^[a-z]{1,6}$/}, {:response_class => "string"}, {:string_value => "clear"}).should be_true
+    test_var({:operator => "=~", :regexp => /^[a-z]{1,6}$/}, {:response_class => "string"}, {:string_value => "foobarbaz"}).should be_false
+  end
+  it "should validate a response by integer comparison" do
+    test_var({:operator => ">", :integer_value => 3}, {:response_class => "integer"}, {:integer_value => 4}).should be_true
+    test_var({:operator => "<=", :integer_value => 256}, {:response_class => "integer"}, {:integer_value => 512}).should be_false
+  end
+  it "should validate a response by (in)equality" do
+    test_var({:operator => "!=", :datetime_value => Date.today + 1}, {:response_class => "date"}, {:datetime_value => Date.today}).should be_true
+    test_var({:operator => "==", :string_value => "foo"}, {:response_class => "string"}, {:string_value => "foo"}).should be_true
+  end
+  it "should represent itself as a hash" do
+    @v = Factory(:validation_condition, :rule_key => "A")
+    @v.stub!(:is_valid?).and_return(true)
+    @v.to_hash("foo").should == {:A => true}
+    @v.stub!(:is_valid?).and_return(false)
+    @v.to_hash("foo").should == {:A => false}
+  end
+end
+
+describe ValidationCondition, "validating responses by other responses" do
+  def test_var(v_hash, a_hash, r_hash, ca_hash, cr_hash)
+    ca = Factory(:answer, ca_hash)
+    cr = Factory(:response, cr_hash.merge(:answer => ca, :question => ca.question))
+    v = Factory(:validation_condition, v_hash.merge({:question_id => ca.question.id, :answer_id => ca.id}))
+    a = Factory(:answer, a_hash)
+    r = Factory(:response, r_hash.merge(:answer => a, :question => a.question))
+    return v.is_valid?(r)
+  end
+  it "should validate a response by integer comparison" do
+    test_var({:operator => ">"}, {:response_class => "integer"}, {:integer_value => 4}, {:response_class => "integer"}, {:integer_value => 3}).should be_true
+    test_var({:operator => "<="}, {:response_class => "integer"}, {:integer_value => 512}, {:response_class => "integer"}, {:integer_value => 4}).should be_false
+  end
+  it "should validate a response by (in)equality" do
+    test_var({:operator => "!="}, {:response_class => "date"}, {:datetime_value => Date.today}, {:response_class => "date"}, {:datetime_value => Date.today + 1}).should be_true
+    test_var({:operator => "=="}, {:response_class => "string"}, {:string_value => "donuts"}, {:response_class => "string"}, {:string_value => "donuts"}).should be_true
+  end
+  it "should not validate a response by regexp" do
+    test_var({:operator => "=~"}, {:response_class => "date"}, {:datetime_value => Date.today}, {:response_class => "date"}, {:datetime_value => Date.today + 1}).should be_false
+    test_var({:operator => "=~"}, {:response_class => "string"}, {:string_value => "donuts"}, {:response_class => "string"}, {:string_value => "donuts"}).should be_false
+  end
+end

data/spec/models/validation_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Validation do
+  before(:each) do
+    @validation = Factory(:validation)
+  end
+  
+  it "should be valid" do
+    @validation.should be_valid
+  end
+  
+  it "should be invalid without a rule" do
+    @validation.rule = nil
+    @validation.should have(2).errors_on(:rule)
+    @validation.rule = " "
+    @validation.should have(1).errors_on(:rule)
+  end
+
+  # this causes issues with building and saving
+  # it "should be invalid without a answer_id" do
+  #   @validation.answer_id = nil
+  #   @validation.should have(1).error_on(:answer_id)
+  # end
+
+  it "should be invalid unless rule composed of only references and operators" do
+    @validation.rule = "foo"
+    @validation.should have(1).error_on(:rule)
+    @validation.rule = "1 to 2"
+    @validation.should have(1).error_on(:rule)
+    @validation.rule = "a and b"
+    @validation.should have(1).error_on(:rule)
+  end
+  it "should protect timestamps" do
+    saved_attrs = @validation.attributes
+    if defined? ActiveModel::MassAssignmentSecurity::Error
+      lambda {@validation.update_attributes(:created_at => 3.days.ago, :updated_at => 3.hours.ago)}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+    else
+      @validation.attributes = {:created_at => 3.days.ago, :updated_at => 3.hours.ago} # automatically protected by Rails
+      @validation.attributes = {:created_at => 3.days.ago, :updated_at => 3.hours.ago} # automatically protected by Rails
+    end
+    @validation.attributes.should == saved_attrs
+  end
+end
+describe Validation, "reporting its status" do
+  def test_var(vhash, vchashes, ahash, rhash)
+    a = Factory(:answer, ahash)
+    v = Factory(:validation, {:answer => a, :rule => "A"}.merge(vhash))
+    vchashes.each do |vchash|
+      Factory(:validation_condition, {:validation => v, :rule_key => "A"}.merge(vchash))
+    end
+    rs = Factory(:response_set)
+    r = Factory(:response, {:answer => a, :question => a.question}.merge(rhash))
+    rs.responses << r
+    return v.is_valid?(rs)
+  end
+
+  it "should validate a response by integer comparison" do
+    test_var({:rule => "A and B"}, [{:operator => ">=", :integer_value => 0}, {:rule_key => "B", :operator => "<=", :integer_value => 120}], {:response_class => "integer"}, {:integer_value => 48}).should be_true
+  end
+  it "should validate a response by regexp" do
+    test_var({}, [{:operator => "=~", :regexp => /^[a-z]{1,6}$/}], {:response_class => "string"}, {:string_value => ""}).should be_false
+  end
+end
+describe Validation, "with conditions" do
+  it "should destroy conditions when destroyed" do
+    @validation = Factory(:validation)
+    Factory(:validation_condition, :validation => @validation, :rule_key => "A")
+    Factory(:validation_condition, :validation => @validation, :rule_key => "B")
+    Factory(:validation_condition, :validation => @validation, :rule_key => "C")
+    v_ids = @validation.validation_conditions.map(&:id)
+    @validation.destroy
+    v_ids.each{|id| DependencyCondition.find_by_id(id).should == nil}
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude "spec/*,gems/*"
+--rails