hssc_surveyor 1.4.1.pre

data/spec/models/dependency_condition_spec.rb

@@ -0,0 +1,439 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe DependencyCondition do
+  it "should have a list of operators" do
+    %w(== != < > <= >=).each do |operator|
+      DependencyCondition.operators.include?(operator).should be_true
+    end
+  end
+
+  describe "instance" do
+    before(:each) do
+      @dependency_condition = DependencyCondition.new(
+        :dependency_id => 1, :question_id => 45, :operator => "==",
+        :answer_id => 23, :rule_key => "A")
+    end
+
+    it "should be valid" do
+      @dependency_condition.should be_valid
+    end
+
+    it "should be invalid without a parent dependency_id, question_id" do
+      # this causes issues with building and saving
+      # @dependency_condition.dependency_id = nil
+      # @dependency_condition.should have(1).errors_on(:dependency_id)
+      # @dependency_condition.question_id = nil
+      # @dependency_condition.should have(1).errors_on(:question_id)
+    end
+
+    it "should be invalid without an operator" do
+      @dependency_condition.operator = nil
+      @dependency_condition.should have(2).errors_on(:operator)
+    end
+
+    it "should be invalid without a rule_key" do
+      @dependency_condition.should be_valid
+      @dependency_condition.rule_key = nil
+      @dependency_condition.should_not be_valid
+      @dependency_condition.should have(1).errors_on(:rule_key)
+    end
+
+    it "should have unique rule_key within the context of a dependency" do
+      @dependency_condition.should be_valid
+      DependencyCondition.create(
+        :dependency_id => 2, :question_id => 46, :operator => "==",
+        :answer_id => 14, :rule_key => "B")
+      @dependency_condition.rule_key = "B" # rule key uniquness is scoped by dependency_id
+      @dependency_condition.dependency_id = 2
+      @dependency_condition.should_not be_valid
+      @dependency_condition.should have(1).errors_on(:rule_key)
+    end
+
+    it "should have an operator in DependencyCondition.operators" do
+      DependencyCondition.operators.each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(0).errors_on(:operator)
+      end
+      @dependency_condition.operator = "#"
+      @dependency_condition.should have(1).error_on(:operator)
+    end
+    it "should have a properly formed count operator" do
+      %w(count>1 count<1 count>=1 count<=1 count==1 count!=1).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(0).errors_on(:operator)
+      end
+      %w(count> count< count>= count<= count== count!=).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(1).errors_on(:operator)
+      end
+      %w(count=1 count><1 count<>1 count!1 count!!1 count=>1 count=<1).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(1).errors_on(:operator)
+      end
+      %w(count= count>< count<> count! count!! count=> count=< count> count< count>= count<= count== count!=).each do |o|
+        @dependency_condition.operator = o
+        @dependency_condition.should have(1).errors_on(:operator)
+      end
+    end
+
+    it "should protect timestamps" do
+      saved_attrs = @dependency_condition.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        lambda {@dependency_condition.update_attributes(:created_at => 3.days.ago, :updated_at => 3.hours.ago)}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        @dependency_condition.attributes = {:created_at => 3.days.ago, :updated_at => 3.hours.ago} # automatically protected by Rails
+      end
+      @dependency_condition.attributes.should == saved_attrs
+    end
+
+  end
+
+  it "returns true for != with no responses" do
+    question = Factory(:question)
+    dependency_condition = Factory(:dependency_condition, :rule_key => "C", :question => question)
+    rs = Factory(:response_set)
+    dependency_condition.to_hash(rs).should == {:C => false}
+  end
+
+
+  it "should not assume that Response#as is not nil" do
+    # q_HEIGHT_FT "Portion of height in whole feet (e.g., 5)",
+    # :pick=>:one
+    # a :integer
+    # a_neg_1 "Refused"
+    # a_neg_2 "Don't know"
+    # label "Provided value is outside of the suggested range (4 to 7 feet). This value is admissible, but you may wish to verify."
+    # dependency :rule=>"A or B"
+    # condition_A :q_HEIGHT_FT, "<", {:integer_value => "4"}
+    # condition_B :q_HEIGHT_FT, ">", {:integer_value => "7"}
+
+    answer = Factory(:answer, :response_class => :integer)
+    @dependency_condition = DependencyCondition.new(
+      :dependency => Factory(:dependency),
+      :question => answer.question,
+      :answer => answer,
+      :operator => ">",
+      :integer_value => 4,
+      :rule_key => "A")
+
+    response = Factory(:response, :answer => answer, :question => answer.question)
+    response_set = response.response_set
+    response.integer_value.should == nil
+
+    @dependency_condition.to_hash(response_set).should == {:A => false}
+  end
+
+  describe "evaluate '==' operator" do
+    before(:each) do
+      @a = Factory(:answer, :response_class => "answer")
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => "==", :rule_key => "D")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with checkbox/radio type response" do
+      @dc.to_hash(@rs).should == {:D => true}
+      @dc.answer = @b
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with string value response" do
+      @a.update_attributes(:response_class => "string")
+      @r.update_attributes(:string_value => "hello123")
+      @dc.string_value = "hello123"
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:string_value => "foo_abc")
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with a text value response" do
+      @a.update_attributes(:response_class => "text")
+      @r.update_attributes(:text_value => "hello this is some text for comparison")
+      @dc.text_value = "hello this is some text for comparison"
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:text_value => "Not the same text")
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 10045)
+      @dc.integer_value = 10045
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 121.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:D => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:D => false}
+    end
+  end
+
+  describe "evaluate '!=' operator" do
+    before(:each) do
+      @a = Factory(:answer)
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => "!=", :rule_key => "E")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with checkbox/radio type response" do
+      @dc.to_hash(@rs).should == {:E => false}
+      @dc.answer_id = @a.id.to_i+1
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with string value response" do
+      @a.update_attributes(:response_class => "string")
+      @r.update_attributes(:string_value => "hello123")
+      @dc.string_value = "hello123"
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:string_value => "foo_abc")
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with a text value response" do
+      @a.update_attributes(:response_class => "text")
+      @r.update_attributes(:text_value => "hello this is some text for comparison")
+      @dc.text_value = "hello this is some text for comparison"
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:text_value => "Not the same text")
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 10045)
+      @dc.integer_value = 10045
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 121.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:E => false}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:E => true}
+    end
+  end
+
+  describe "evaluate the '<' operator" do
+    before(:each) do
+      @a = Factory(:answer)
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => "<", :rule_key => "F")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:F => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:F => false}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:F => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:F => false}
+    end
+  end
+
+  describe "evaluate the '<=' operator" do
+    before(:each) do
+      @a = Factory(:answer)
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => "<=", :rule_key => "G")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:integer_value => 100)
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:G => false}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:float_value => 121.1)
+      @dc.to_hash(@rs).should == {:G => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:G => false}
+    end
+
+  end
+
+  describe "evaluate the '>' operator" do
+    before(:each) do
+      @a = Factory(:answer)
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => ">", :rule_key => "H")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:H => false}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:H => true}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:H => false}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:H => true}
+    end
+  end
+
+  describe "evaluate the '>=' operator" do
+    before(:each) do
+      @a = Factory(:answer)
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a)
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => ">=", :rule_key => "I")
+      @dc.as(:answer).should == @r.as(:answer)
+    end
+
+    it "with an integer value response" do
+      @a.update_attributes(:response_class => "integer")
+      @r.update_attributes(:integer_value => 50)
+      @dc.integer_value = 100
+      @dc.to_hash(@rs).should == {:I => false}
+      @r.update_attributes(:integer_value => 100)
+      @dc.to_hash(@rs).should == {:I => true}
+      @r.update_attributes(:integer_value => 421)
+      @dc.to_hash(@rs).should == {:I => true}
+    end
+
+    it "with a float value response" do
+      @a.update_attributes(:response_class => "float")
+      @r.update_attributes(:float_value => 5.1)
+      @dc.float_value = 121.1
+      @dc.to_hash(@rs).should == {:I => false}
+      @r.update_attributes(:float_value => 121.1)
+      @dc.to_hash(@rs).should == {:I => true}
+      @r.update_attributes(:float_value => 130.123)
+      @dc.to_hash(@rs).should == {:I => true}
+    end
+  end
+
+  describe "evaluating with response_class string" do
+    it "should compare answer ids when the dependency condition string_value is nil" do
+      @a = Factory(:answer, :response_class => "string")
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a, :string_value => "")
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => "==", :rule_key => "J")
+      @dc.to_hash(@rs).should == {:J => true}
+    end
+
+    it "should compare strings when the dependency condition string_value is not nil, even if it is blank" do
+      @a = Factory(:answer, :response_class => "string")
+      @b = Factory(:answer, :question => @a.question)
+      @r = Factory(:response, :question => @a.question, :answer => @a, :string_value => "foo")
+      @rs = @r.response_set
+      @dc = Factory(:dependency_condition, :question => @a.question, :answer => @a, :operator => "==", :rule_key => "K", :string_value => "foo")
+      @dc.to_hash(@rs).should == {:K => true}
+
+      @r.update_attributes(:string_value => "")
+      @dc.string_value = ""
+      @dc.to_hash(@rs).should == {:K => true}
+    end
+  end
+
+  describe "evaluate 'count' operator" do
+    before(:each) do
+      @q = Factory(:question)
+      @dc = DependencyCondition.new(:operator => "count>2", :rule_key => "M", :question => @q)
+      @as = []
+      3.times do
+        @as << Factory(:answer, :question => @q, :response_class => "answer")
+      end
+      @rs = Factory(:response_set)
+      @as.slice(0,2).each do |a|
+        Factory(:response, :question => @q, :answer => a, :response_set => @rs)
+      end
+      @rs.save
+    end
+
+    it "with operator with >" do
+      @dc.to_hash(@rs).should == {:M => false}
+      Factory(:response, :question => @q, :answer => @as.last, :response_set => @rs)
+      @rs.reload.responses.count.should == 3
+      @dc.to_hash(@rs.reload).should == {:M => true}
+    end
+
+    it "with operator with <" do
+      @dc.operator = "count<2"
+      @dc.to_hash(@rs).should == {:M => false}
+      @dc.operator = "count<3"
+      @dc.to_hash(@rs).should == {:M => true}
+    end
+
+    it "with operator with <=" do
+      @dc.operator = "count<=1"
+      @dc.to_hash(@rs).should == {:M => false}
+      @dc.operator = "count<=2"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count<=3"
+      @dc.to_hash(@rs).should == {:M => true}
+    end
+
+    it "with operator with >=" do
+      @dc.operator = "count>=1"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count>=2"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count>=3"
+      @dc.to_hash(@rs).should == {:M => false}
+    end
+
+    it "with operator with !=" do
+      @dc.operator = "count!=1"
+      @dc.to_hash(@rs).should == {:M => true}
+      @dc.operator = "count!=2"
+      @dc.to_hash(@rs).should == {:M => false}
+      @dc.operator = "count!=3"
+      @dc.to_hash(@rs).should == {:M => true}
+    end
+  end
+
+end

data/spec/models/dependency_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dependency do
+  before(:each) do
+    @dependency = Factory(:dependency)
+  end
+
+  it "should be valid" do
+    @dependency.should be_valid
+  end
+
+  it "should be invalid without a rule" do
+    @dependency.rule = nil
+    @dependency.should have(2).errors_on(:rule)
+    @dependency.rule = " "
+    @dependency.should have(1).errors_on(:rule)
+  end
+
+  it "should be invalid without a question_id" do
+    @dependency.question_id = nil
+    @dependency.should have(1).error_on(:question_id)
+
+    @dependency.question_group_id = 1
+    @dependency.should be_valid
+
+    @dependency.question_id.should be_nil
+    @dependency.question_group_id = nil
+    @dependency.should have(1).error_on(:question_group_id)
+  end
+
+  it "should alias question_id as dependent_question_id" do
+    @dependency.question_id = 19
+    @dependency.dependent_question_id.should == 19
+    @dependency.dependent_question_id = 14
+    @dependency.question_id.should == 14
+  end
+
+  it "should be invalid unless rule composed of only references and operators" do
+    @dependency.rule = "foo"
+    @dependency.should have(1).error_on(:rule)
+    @dependency.rule = "1 to 2"
+    @dependency.should have(1).error_on(:rule)
+    @dependency.rule = "a and b"
+    @dependency.should have(1).error_on(:rule)
+  end
+  it "should protect timestamps" do
+    saved_attrs = @dependency.attributes
+    if defined? ActiveModel::MassAssignmentSecurity::Error
+      lambda {@dependency.update_attributes(:created_at => 3.days.ago, :updated_at => 3.hours.ago)}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+    else
+      @dependency.attributes = {:created_at => 3.days.ago, :updated_at => 3.hours.ago} # automatically protected by Rails
+    end
+    @dependency.attributes.should == saved_attrs
+  end
+
+  
+end
+
+describe Dependency, "when evaluating dependency conditions of a question in a response set" do
+
+  before(:each) do
+    @dep = Dependency.new(:rule => "A", :question_id => 1)
+    @dep2 = Dependency.new(:rule => "A and B", :question_id => 1)
+    @dep3 = Dependency.new(:rule => "A or B", :question_id => 1)
+    @dep4 = Dependency.new(:rule => "!(A and B) and C", :question_id => 1)
+    
+    @dep_c = mock_model(DependencyCondition, :id => 1, :rule_key => "A", :to_hash => {:A => true})
+    @dep_c2 = mock_model(DependencyCondition, :id => 2, :rule_key => "B", :to_hash => {:B => false})
+    @dep_c3 = mock_model(DependencyCondition, :id => 3, :rule_key => "C", :to_hash => {:C => true})
+
+    @dep.stub!(:dependency_conditions).and_return([@dep_c])
+    @dep2.stub!(:dependency_conditions).and_return([@dep_c, @dep_c2])
+    @dep3.stub!(:dependency_conditions).and_return([@dep_c, @dep_c2])
+    @dep4.stub!(:dependency_conditions).and_return([@dep_c, @dep_c2, @dep_c3])
+  end
+
+  it "knows if the dependencies are met" do
+    @dep.is_met?(@response_set).should be_true
+    @dep2.is_met?(@response_set).should be_false
+    @dep3.is_met?(@response_set).should be_true
+    @dep4.is_met?(@response_set).should be_true
+  end
+
+  it "returns the proper keyed pairs from the dependency conditions" do
+    @dep.conditions_hash(@response_set).should == {:A => true}
+    @dep2.conditions_hash(@response_set).should == {:A => true, :B => false}
+    @dep3.conditions_hash(@response_set).should == {:A => true, :B => false}
+    @dep4.conditions_hash(@response_set).should == {:A => true, :B => false, :C => true}
+  end
+end
+describe Dependency, "with conditions" do
+  it "should destroy conditions when destroyed" do
+    @dependency = Dependency.new(:rule => "A and B and C", :question_id => 1)
+    Factory(:dependency_condition, :dependency => @dependency, :rule_key => "A")
+    Factory(:dependency_condition, :dependency => @dependency, :rule_key => "B")
+    Factory(:dependency_condition, :dependency => @dependency, :rule_key => "C")
+    dc_ids = @dependency.dependency_conditions.map(&:id)
+    @dependency.destroy
+    dc_ids.each{|id| DependencyCondition.find_by_id(id).should == nil}
+  end
+end

data/spec/models/question_group_spec.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe QuestionGroup do
+  let(:question_group){ Factory(:question_group) }
+  let(:dependency){ Factory(:dependency) }
+  let(:response_set){ Factory(:response_set) }
+
+  context "when creating" do
+    it { question_group.should be_valid }
+    it "#display_type = inline by default" do
+      question_group.display_type = "inline"
+      question_group.renderer.should == :inline
+    end
+    it "#renderer == 'default' when #display_type = nil" do
+      question_group.display_type = nil
+      question_group.renderer.should == :default
+    end
+    it "interprets symbolizes #display_type to #renderer" do
+      question_group.display_type = "foo"
+      question_group.renderer.should == :foo
+    end
+    it "reports DOM ready #css_class based on dependencies" do
+      question_group.dependency = dependency
+      dependency.should_receive(:is_met?).and_return(true)
+      question_group.css_class(response_set).should == "g_dependent"
+
+      dependency.should_receive(:is_met?).and_return(false)
+      question_group.css_class(response_set).should == "g_dependent g_hidden"
+
+      question_group.custom_class = "foo bar"
+      dependency.should_receive(:is_met?).and_return(false)
+      question_group.css_class(response_set).should == "g_dependent g_hidden foo bar"
+    end
+    it "protects #api_id" do
+      saved_attrs = question_group.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { question_group.update_attributes(:api_id => "NEW") }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        question_group.attributes = {:api_id => "NEW"} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      question_group.attributes.should == saved_attrs
+    end
+    it "protects #created_at" do
+      saved_attrs = question_group.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { question_group.update_attributes(:created_at => 3.days.ago) }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        question_group.attributes = {:created_at => 3.days.ago} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      question_group.attributes.should == saved_attrs
+    end
+    it "protects #updated_at" do
+      saved_attrs = question_group.attributes
+      if defined? ActiveModel::MassAssignmentSecurity::Error
+        expect { question_group.update_attributes(:updated_at => 3.hours.ago) }.to raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      else
+        question_group.attributes = {:updated_at => 3.hours.ago} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+      end
+      question_group.attributes.should == saved_attrs
+    end
+  end
+
+  context "with translations" do
+    require 'yaml'
+    let(:survey){ Factory(:survey) }
+    let(:survey_section){ Factory(:survey_section) }
+    let(:survey_translation){
+      Factory(:survey_translation, :locale => :es, :translation => {
+        :question_groups => {
+          :goodbye => {
+            :text => "¡Adios!"
+          }
+        }
+      }.to_yaml)
+    }
+    let(:question){ Factory(:question) }
+    before do
+      question_group.text = "Goodbye"
+      question_group.reference_identifier = "goodbye"
+      question_group.questions = [question]
+      question.survey_section = survey_section
+      survey_section.survey = survey
+      survey.translations << survey_translation
+    end
+    it "returns its own translation" do
+      question_group.translation(:es)[:text].should == "¡Adios!"
+    end
+    it "returns its own default values" do
+      question_group.translation(:de).should == {"text" => "Goodbye", "help_text" => nil}
+    end
+  end
+end