surveyor 0.22.0 → 1.0.0

data/spec/controllers/surveyor_controller_spec.rb

@@ -11,11 +11,6 @@ describe SurveyorController do
   # end
 
   describe "available surveys: GET /surveys" do
-    before(:each) do
-      @survey = Factory(:survey)
-      Survey.stub!(:find).and_return([@survey])
-    end
-
     def do_get
       get :new
     end
@@ -26,33 +21,37 @@ describe SurveyorController do
       response.should render_template('new')
     end
 
-    it "should find all surveys" do
-      Survey.should_receive(:find).with(:all).and_return([@survey])
-      do_get
-    end
-
-    it "should assign the found surveys for the view" do
+    it "should list codes and survey_versions for all surveys" do
+      original = Factory(:survey, :title => "Foo", :access_code => 'foo')
+      supplant = Factory(:survey, :title => "Foo", :access_code => 'foo', :survey_version => 1)
+      hash = {"foo"=>{"title"=>"Foo", "survey_versions"=>[0, 1]}}
       do_get
-      assigns[:surveys].should == [@survey]
+      assigns(:codes).should eq hash
     end
   end
 
   describe "take survey: POST /surveys/xyz" do
     before(:each) do
       @survey = Factory(:survey, :title => "xyz", :access_code => "xyz")
+      @newsurvey = Factory(:survey, :title => "xyz", :access_code => "xyz", :survey_version => 1)
       @response_set = Factory(:response_set, :access_code => "pdq")
       ResponseSet.stub!(:create).and_return(@response_set)
-      Survey.stub!(:find_by_access_code).and_return(@survey)
     end
 
     describe "with success" do
       def do_post
         post :create, :survey_code => "xyz"
       end
-      it "should look for the survey" do
-        Survey.should_receive(:find_by_access_code).with("xyz").and_return(@survey)
+      it "should look for the latest survey_version of the survey if survey_version is not explicitely provided" do
         do_post
+        assigns(:survey).should eq(@newsurvey)
       end
+
+      it "should look for the partculer survey_version of the survey if it is provided" do
+        post :create, :survey_code => "xyz", :survey_version => 0
+        assigns(:survey).should eq(@survey)
+      end
+
       it "should create a new response_set" do
         ResponseSet.should_receive(:create).and_return(@response_set)
         do_post
@@ -71,8 +70,7 @@ describe SurveyorController do
         response.should redirect_to(available_surveys_url)
       end
       it "should re-redirect to 'new' if Survey failed find" do
-        Survey.should_receive(:find_by_access_code).and_return(nil)
-        post :create, :survey_code => "XYZ"
+        post :create, :survey_code => "ABC"
         response.should redirect_to(available_surveys_url)
       end
     end
@@ -125,6 +123,25 @@ describe SurveyorController do
       get :show, :survey_code => "xyz", :response_set_code => "DIFFERENT"
       response.should redirect_to(available_surveys_url)
     end
+
+    it "should render correct survey survey_version" do
+      supplant = Factory(:survey, :title => "xyz", :access_code => 'xyz', :survey_version => 1)
+      supplant_section = Factory(:survey_section, :survey => supplant)
+      supplant_response_set = Factory(:response_set, :access_code => "rst", :survey => supplant)
+
+      get :show, :survey_code => "xyz", :response_set_code => "pdq"
+      response.should be_success
+      response.should render_template('show')
+      assigns[:response_set].should == @response_set
+      assigns[:survey].should == @survey
+
+      get :show, :survey_code => "xyz", :response_set_code => "rst"
+      response.should be_success
+      response.should render_template('show')
+      assigns[:response_set].should == supplant_response_set
+      assigns[:survey].should == supplant
+    end
+
   end
 
   describe "edit my survey: GET /surveys/XYZ/PDQ/take" do
@@ -169,99 +186,156 @@ describe SurveyorController do
       assigns[:dependents].should be_empty
       session[:surveyor_javascript].should == "enabled"
     end
+
+    it "should render correct survey survey_version" do
+      supplant = Factory(:survey, :title => "XYZ", :access_code => 'XYZ', :survey_version => 1)
+      supplant_section = Factory(:survey_section, :survey => supplant)
+      supplant_response_set = Factory(:response_set, :access_code => "RST", :survey => supplant)
+
+      get :edit, :survey_code => "XYZ", :response_set_code => "PDQ"
+      response.should be_success
+      response.should render_template('edit')
+      assigns[:response_set].should == @response_set
+      assigns[:survey].should == @survey
+
+      get :edit, :survey_code => "XYZ", :response_set_code => "RST"
+      response.should be_success
+      response.should render_template('edit')
+      assigns[:response_set].should == supplant_response_set
+      assigns[:survey].should == supplant
+    end
   end
 
   describe "update my survey: PUT /surveys/XYZ/PDQ" do
-    before(:each) do
-      @survey = Factory(:survey, :title => "XYZ", :access_code => "XYZ")
-      @section = Factory(:survey_section, :survey => @survey)
-      @response_set = Factory(:response_set, :access_code => "PDQ", :survey => @survey)
-      # @response_set.stub!(:update_attributes).and_return(true)
-      # @response_set.stub!(:complete!).and_return(Time.now)
-      # @response_set.stub!(:save).and_return(true)
-    end
+    let(:survey_code) { 'XYZ' }
+    let!(:survey) { Factory(:survey, :title => survey_code, :access_code => survey_code) }
 
-    def do_put
-      put :update, :survey_code => "XYZ", :response_set_code => "PDQ"
-    end
+    let(:response_set_code) { 'PDQ' }
+    let!(:response_set) { Factory(:response_set, :access_code => response_set_code, :survey => survey) }
+
+    let(:responses_ui_hash) { {} }
 
-    def do_put_with_finish
-      responses = {
-         "6"=>{"question_id"=>"6", "answer_id" => "6", "string_value"=>"saf"}, #string
-         "7"=>{"question_id"=>"7", "answer_id" => "11", "text_value"=>"foo"}, #text
-         "1"=>{"question_id"=>"1", "answer_id"=>"1", "string_value"=>"bar"}, #radio+txt
-         "2"=>{"question_id"=>"2", "answer_id"=>"6"}, #radio
-         "3"=>{"question_id"=>"3", "answer_id"=>"10"}, #radio
-         "4"=>{"question_id"=>"4", "answer_id"=>"15"}, #check
-         "5"=>{"question_id"=>"5", "answer_id"=>"16", "string_value"=>""} #check+txt
+    let(:params) {
+      {
+        :survey_code => survey_code,
+        :response_set_code => response_set_code,
+        :r => responses_ui_hash.empty? ? nil : responses_ui_hash
       }
-      put :update, :survey_code => "XYZ", :response_set_code => "PDQ", :finish => "finish", :r => responses
-    end
+    }
 
-    it "should find the response set requested" do
-      ResponseSet.should_receive(:find_by_access_code).and_return(@response_set)
-      do_put
+    def a_ui_response(hash)
+      { 'api_id' => 'something' }.merge(hash)
     end
 
-    it "should redirect to 'edit' without params" do
-      do_put
-      response.should redirect_to(:action => :edit)
-    end
+    shared_examples 'common update behaviors' do
+      it "should find the response set requested" do
+        ResponseSet.should_receive(:find_by_access_code).and_return(response_set)
+        do_put
+      end
 
-    it "should complete the found response set on finish" do
-      do_put_with_finish
-      flash[:notice].should == "Completed survey"
-    end
+      it 'applies any provided responses to the response set' do
+        ResponseSet.stub!(:find_by_access_code).and_return(response_set)
 
-    it "should redirect to available surveys if :response_code not found" do
-      put :update, :survey_code => "XYZ", :response_set_code => "DIFFERENT"
-      response.should redirect_to(available_surveys_url)
-      flash[:notice].should == "Unable to find your responses to the survey"
-    end
-  end
+        responses_ui_hash['11'] = a_ui_response('answer_id' => '56', 'question_id' => '9')
+        response_set.should_receive(:update_from_ui_hash).with(responses_ui_hash)
+        do_put
+      end
 
-  describe "update my survey with ajax" do
-    before(:each) do
-      @survey = Factory(:survey, :title => "XYZ", :access_code => "XYZ")
-      @section = Factory(:survey_section, :survey => @survey)
-      @response_set = Factory(:response_set, :access_code => "PDQ", :survey => @survey)
-      ResponseSet.stub!(:find_by_access_code).and_return(@response_set)
-    end
+      it 'does not fail when there are no responses' do
+        lambda { do_put }.should_not raise_error
+      end
 
-    def do_ajax_put(r)
-      xhr :put, :update, :survey_code => "XYZ", :response_set_code => "PDQ", :r => r
-    end
+      describe 'when updating the response set produces a exception' do
+        before do
+          responses_ui_hash['11'] = a_ui_response('answer_id' => '56', 'question_id' => '9')
+
+          ResponseSet.stub!(:find_by_access_code).and_return(response_set)
+        end
+
+        it 'retries the update on a constraint violation' do
+          response_set.should_receive(:update_from_ui_hash).ordered.
+            with(responses_ui_hash).and_raise(ActiveRecord::StatementInvalid)
+          response_set.should_receive(:update_from_ui_hash).ordered.with(responses_ui_hash)
 
-    it "should return an id for new responses" do
-      do_ajax_put({
-         "2"=>{"question_id"=>"4", "answer_id"=>"14"}
-      })
-      JSON.parse(response.body).
-        should == {"ids" => {"2" => 1}, "remove" => {}, "show" => [], "hide" => []}
-      do_ajax_put({
-         "4"=>{"question_id"=>"4", "answer_id"=>"15"}
-      })
-      JSON.parse(response.body).
-        should == {"ids" => {"4" => 2}, "remove" => {}, "show" => [], "hide" => []}
+          lambda { do_put }.should_not raise_error
+        end
+
+        it 'only retries three times' do
+          response_set.should_receive(:update_from_ui_hash).exactly(3).times.
+            with(responses_ui_hash).and_raise(ActiveRecord::StatementInvalid)
+
+          lambda { do_put }.should raise_error(ActiveRecord::StatementInvalid)
+        end
+
+        it 'does not retry for other errors' do
+          response_set.should_receive(:update_from_ui_hash).once.
+            with(responses_ui_hash).and_raise('Bad news')
+
+          lambda { do_put }.should raise_error('Bad news')
+        end
+      end
     end
 
-    it "should return a delete for when responses are removed" do
-      r = @response_set.responses.create(:question_id => 4, :answer_id => 14)
-      do_ajax_put({
-         "2"=>{"question_id"=>"4", "answer_id"=>"", "id" => r.id} # uncheck
-      })
-      # r.id is a String with AR 3.0 and an int with AR 3.1
-      JSON.parse(response.body)['remove']['2'].to_s.should == r.id.to_s
+    describe 'via full cycle form submission' do
+      def do_put
+        put :update, params
+      end
+
+      include_examples 'common update behaviors'
+
+      it "should redirect to 'edit' without params" do
+        do_put
+        response.should redirect_to(:action => :edit)
+      end
+
+      describe 'on finish' do
+        before do
+          params[:finish] = 'finish'
+          do_put
+        end
+
+        it "completes the found response set" do
+          response_set.reload.should be_complete
+        end
+
+        it 'flashes completion' do
+          flash[:notice].should == "Completed survey"
+        end
+      end
+
+      it "should redirect to available surveys if :response_code not found" do
+        params[:response_set_code] = "DIFFERENT"
+        do_put
+        response.should redirect_to(available_surveys_url)
+        flash[:notice].should == "Unable to find your responses to the survey"
+      end
     end
 
-    it "should return dependencies" do
-      @response_set.should_receive(:all_dependencies).
-        and_return({"show" => ['q_1'], "hide" => ['q_2']})
-      do_ajax_put({
-        "4"=>{"question_id"=>"9", "answer_id"=>"12"} #check
-      })
-      JSON.parse(response.body).
-        should == {"ids" => {"4" => 1}, "remove" => {}, "show" => ['q_1'], "hide" => ["q_2"]}
+    describe 'via ajax' do
+      def do_put
+        xhr :put, :update, params
+      end
+
+      include_examples 'common update behaviors'
+
+      it "should return dependencies" do
+        ResponseSet.stub!(:find_by_access_code).and_return(response_set)
+
+        response_set.should_receive(:all_dependencies).
+          and_return({"show" => ['q_1'], "hide" => ['q_2']})
+
+        responses_ui_hash['4'] = a_ui_response("question_id"=>"9", "answer_id"=>"12") # check
+        do_put
+
+        JSON.parse(response.body).
+          should == {"show" => ['q_1'], "hide" => ["q_2"]}
+      end
+
+      it '404s if the response set does not exist' do
+        params[:response_set_code] = 'ELSE'
+        do_put
+        response.status.should == 404
+      end
     end
   end
 end

data/spec/factories.rb

@@ -5,12 +5,13 @@ require 'factory_girl'
 Factory.sequence(:unique_survey_access_code){|n| "simple_survey" << n.to_s }
 
 Factory.define :survey do |s|
-  s.title         {"Simple survey"}
-  s.description   {"A simple survey for testing"}
-  s.access_code   {Factory.next :unique_survey_access_code}
-  s.active_at     {Time.now}
-  s.inactive_at   {}
-  s.css_url       {}
+  s.title           {"Simple survey"}
+  s.description     {"A simple survey for testing"}
+  s.access_code     {Factory.next :unique_survey_access_code}
+  s.active_at       {Time.now}
+  s.inactive_at     {}
+  s.css_url         {}
+  s.survey_version  {0}
 end
 
 Factory.sequence(:survey_section_display_order){|n| n }
@@ -28,20 +29,20 @@ Factory.sequence(:question_display_order){|n| n }
 
 Factory.define :question do |q|
   q.association             :survey_section  # s.survey_section_id       {}
-  q.question_group_id       {}
-  q.text                    {"What is your favorite color?"}
-  q.short_text              {"favorite_color"}
-  q.help_text               {"just write it in the box"}
-  q.pick                    {:none}
+  # q.question_group_id       {}
+  q.text                    "What is your favorite color?"
+  q.short_text              "favorite_color"
+  q.help_text               "just write it in the box"
+  q.pick                    :none
   q.reference_identifier    {|me| "q_#{me.object_id}"}
-  q.data_export_identifier  {}
-  q.common_namespace        {}
-  q.common_identifier       {}
-  q.display_order           {Factory.next :question_display_order}
-  q.display_type            {} # nil is default
-  q.is_mandatory            {false}
-  q.display_width           {}
-  q.correct_answer_id       {nil}
+  # q.data_export_identifier  {}
+  # q.common_namespace        {}
+  # q.common_identifier       {}
+  q.display_order           Factory.next :question_display_order
+  # q.display_type            {} # nil is default
+  q.is_mandatory            false
+  # q.display_width           {}
+  q.correct_answer_id       nil
 end
 
 Factory.define :question_group do |g|
@@ -60,21 +61,21 @@ Factory.sequence(:answer_display_order){|n| n }
 
 Factory.define :answer do |a|
   a.association               :question  # a.question_id               {}
-  a.text                      {"My favorite color is clear"}
-  a.short_text                {"clear"}
-  a.help_text                 {"Clear is the absense of color"}
-  a.weight                    {}
-  a.response_class            {"String"}
-  a.reference_identifier      {}
-  a.data_export_identifier    {}
-  a.common_namespace          {}
-  a.common_identifier         {}
+  a.text                      "My favorite color is clear"
+  a.short_text                "clear"
+  a.help_text                 "Clear is the absense of color"
+  # a.weight
+  a.response_class            "string"
+  # a.reference_identifier      {}
+  # a.data_export_identifier    {}
+  # a.common_namespace          {}
+  # a.common_identifier         {}
   a.display_order             {Factory.next :answer_display_order}
-  a.is_exclusive              {}
+  # a.is_exclusive              {}
   a.display_type              "default"
-  a.display_length            {}
-  a.custom_class              {}
-  a.custom_renderer           {}
+  # a.display_length            {}
+  # a.custom_class              {}
+  # a.custom_renderer           {}
 end
 
 Factory.define :dependency do |d|

data/spec/helpers/formtastic_custom_input_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/surveyor/helpers/formtastic_custom_input')
+
+describe Surveyor::Helpers::FormtasticCustomInput do
+  context "input helpers" do
+    it "should translate response class into attribute" do
+      helper.response_class_to_method(:string).should == :string_value
+      helper.response_class_to_method(:other_and_string).should == :string_value
+      helper.response_class_to_method(:integer).should == :integer_value
+      helper.response_class_to_method(:float).should == :float_value
+      helper.response_class_to_method(:datetime).should == :datetime_value
+      helper.response_class_to_method(:date).should == :datetime_value
+      helper.response_class_to_method(:time).should == :datetime_value
+    end
+  end
+end

data/spec/lib/common_spec.rb

@@ -18,45 +18,6 @@ describe Surveyor::Common, "" do
       "In general, you would say your health is:" => "you_would_say_your_health"
     }.each{|k, v| Surveyor::Common.to_normalized_string(k).should == v}
   end
-  it "should deep compare json objects" do
-    a = {"a" => "b"}.to_json
-    b = '{"a": "b"}'
-    Surveyor::Common.equal_json_excluding_wildcards(a,b).should be_true
-    
-    a = {"y" => "x"}.to_json
-    b = {:y => "x"}
-    Surveyor::Common.equal_json_excluding_wildcards(a,b).should be_true
-
-    a = [{"y" => "x"}, {"j" => "b"}].to_json
-    b = '[{"y": "x"}]'
-    Surveyor::Common.equal_json_excluding_wildcards(a,b).should be_false
-    
-    a = [{"y" => "x"}, {"uuid" => "*"}].to_json
-    b = '[{"y": "x"}, {"uuid": "12312312312123"}]'
-    Surveyor::Common.equal_json_excluding_wildcards(a,b).should be_true
-
-    a = %({"survey": {
-      "title":"Simple survey",
-      "uuid":"72888670-9151-012e-9ec1-00254bc472f4",
-      "sections":[{
-        "title":"Basic questions"
-        }]
-      }
-    })
-    b = %({"survey": {"title": "Simple survey","uuid": "*","sections": [{"title": "Basic questions"}]}})
-    Surveyor::Common.equal_json_excluding_wildcards(a,b).should be_true
-    
-    a = %({"survey": {
-      "title":"Simple survey",
-      "uuid":"72888670-9151-012e-9ec1-00254bc472f4",
-      "sections":[{
-        "title":"Different"
-        }]
-      }
-    })
-    b = %({"survey": {"title": "Simple survey","uuid": "*","sections": [{"title": "Basic questions"}]}})
-    Surveyor::Common.equal_json_excluding_wildcards(a,b).should be_false
-  end
   describe '#generate_api_id' do
     def generate
       Surveyor::Common.generate_api_id

data/spec/lib/redcap_parser_spec.rb

@@ -20,56 +20,56 @@ describe Surveyor::RedcapParser do
   end
   it "should decompose dependency rules" do
     # basic
-    Dependency.decompose_rule('[f1_q12]="1"').should == {:rule => "A", :components => ['[f1_q12]="1"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q12]="1"').should == {:rule => "A", :components => ['[f1_q12]="1"']}
     # spacing
-    Dependency.decompose_rule('[f1_q9] = "1"').should == {:rule => "A", :components => ['[f1_q9] = "1"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q9] = "1"').should == {:rule => "A", :components => ['[f1_q9] = "1"']}
     # and
-    Dependency.decompose_rule('[pre_q88]="1" and [pre_q90]="1"').should == {:rule => "A and B", :components => ['[pre_q88]="1"', '[pre_q90]="1"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[pre_q88]="1" and [pre_q90]="1"').should == {:rule => "A and B", :components => ['[pre_q88]="1"', '[pre_q90]="1"']}
     # or
-    Dependency.decompose_rule('[second_q111]="1" or [second_q111]="3"').should == {:rule => "A or B", :components => ['[second_q111]="1"', '[second_q111]="3"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[second_q111]="1" or [second_q111]="3"').should == {:rule => "A or B", :components => ['[second_q111]="1"', '[second_q111]="3"']}
     # or and
-    Dependency.decompose_rule('[second_q100]="1" or [second_q100]="3" and [second_q101]="1"').should == {:rule => "A or B and C", :components => ['[second_q100]="1"', '[second_q100]="3"', '[second_q101]="1"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[second_q100]="1" or [second_q100]="3" and [second_q101]="1"').should == {:rule => "A or B and C", :components => ['[second_q100]="1"', '[second_q100]="3"', '[second_q101]="1"']}
     # and or
-    Dependency.decompose_rule('[second_q4]="1" and [second_q11]="1" or [second_q11]="98"').should == {:rule => "A and B or C", :components => ['[second_q4]="1"', '[second_q11]="1"', '[second_q11]="98"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[second_q4]="1" and [second_q11]="1" or [second_q11]="98"').should == {:rule => "A and B or C", :components => ['[second_q4]="1"', '[second_q11]="1"', '[second_q11]="98"']}
     # or or or
-    Dependency.decompose_rule('[pre_q74]="1" or [pre_q74]="2" or [pre_q74]="4" or [pre_q74]="5"').should == {:rule => "A or B or C or D", :components => ['[pre_q74]="1"', '[pre_q74]="2"', '[pre_q74]="4"', '[pre_q74]="5"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[pre_q74]="1" or [pre_q74]="2" or [pre_q74]="4" or [pre_q74]="5"').should == {:rule => "A or B or C or D", :components => ['[pre_q74]="1"', '[pre_q74]="2"', '[pre_q74]="4"', '[pre_q74]="5"']}
     # and with different operator
-    Dependency.decompose_rule('[f1_q15] >= 21 and [f1_q28] ="1"').should == {:rule => "A and B", :components => ['[f1_q15] >= 21', '[f1_q28] ="1"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q15] >= 21 and [f1_q28] ="1"').should == {:rule => "A and B", :components => ['[f1_q15] >= 21', '[f1_q28] ="1"']}
   end
   it "should decompose nested dependency rules" do
     # external parenthesis
-    Dependency.decompose_rule('([pre_q74]="1" or [pre_q74]="2" or [pre_q74]="4" or [pre_q74]="5") and [pre_q76]="2"').should == {:rule => "(A or B or C or D) and E", :components => ['[pre_q74]="1"', '[pre_q74]="2"', '[pre_q74]="4"', '[pre_q74]="5"', '[pre_q76]="2"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('([pre_q74]="1" or [pre_q74]="2" or [pre_q74]="4" or [pre_q74]="5") and [pre_q76]="2"').should == {:rule => "(A or B or C or D) and E", :components => ['[pre_q74]="1"', '[pre_q74]="2"', '[pre_q74]="4"', '[pre_q74]="5"', '[pre_q76]="2"']}
     # internal parenthesis
-    Dependency.decompose_rule('[f1_q10(4)]="1"').should == {:rule => "A", :components => ['[f1_q10(4)]="1"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[f1_q10(4)]="1"').should == {:rule => "A", :components => ['[f1_q10(4)]="1"']}
     # internal and external parenthesis
-    Dependency.decompose_rule('([f1_q7(11)] = "1" or [initial_52] = "1") and [pre_q76]="2"').should == {:rule => "(A or B) and C", :components => ['[f1_q7(11)] = "1"', '[initial_52] = "1"', '[pre_q76]="2"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('([f1_q7(11)] = "1" or [initial_52] = "1") and [pre_q76]="2"').should == {:rule => "(A or B) and C", :components => ['[f1_q7(11)] = "1"', '[initial_52] = "1"', '[pre_q76]="2"']}
   end
   it "should decompose shortcut dependency rules" do
     # 'or' on the right of the operator
-    Dependency.decompose_rule('[initial_108] = "1" or "2"').should == {:rule => "A or B", :components => ['[initial_108] = "1"', '[initial_108] = "2"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_108] = "1" or "2"').should == {:rule => "A or B", :components => ['[initial_108] = "1"', '[initial_108] = "2"']}
     # multiple 'or' on the right
-    Dependency.decompose_rule('[initial_52] = "1" or "2" or "3"').should == {:rule => "A or B or C", :components => ['[initial_52] = "1"', '[initial_52] = "2"', '[initial_52] = "3"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_52] = "1" or "2" or "3"').should == {:rule => "A or B or C", :components => ['[initial_52] = "1"', '[initial_52] = "2"', '[initial_52] = "3"']}
     # commas on the right
-    Dependency.decompose_rule('[initial_189] = "1, 2, 3"').should == {:rule => "(A and B and C)", :components => ['[initial_189] = "1"', '[initial_189] = "2"', '[initial_189] = "3"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_189] = "1, 2, 3"').should == {:rule => "(A and B and C)", :components => ['[initial_189] = "1"', '[initial_189] = "2"', '[initial_189] = "3"']}
     # multiple internal parenthesis on the left
-    Dependency.decompose_rule('[initial_119(1)(2)(3)(4)(5)] = "1"').should == {:rule => "(A and B and C and D and E)", :components => ['[initial_119(1)] = "1"', '[initial_119(2)] = "1"', '[initial_119(3)] = "1"', '[initial_119(4)] = "1"', '[initial_119(5)] = "1"']}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_rule('[initial_119(1)(2)(3)(4)(5)] = "1"').should == {:rule => "(A and B and C and D and E)", :components => ['[initial_119(1)] = "1"', '[initial_119(2)] = "1"', '[initial_119(3)] = "1"', '[initial_119(4)] = "1"', '[initial_119(5)] = "1"']}
   end
   it "should decompose components" do
-    Dependency.decompose_component('[initial_52] = "1"').should == {:question_reference => 'initial_52', :operator => '==', :answer_reference => '1'}
-    Dependency.decompose_component('[initial_119(2)] = "1"').should == {:question_reference => 'initial_119', :operator => '==', :answer_reference => '2'}
-    Dependency.decompose_component('[f1_q15] >= 21').should == {:question_reference => 'f1_q15', :operator => '>=', :integer_value => '21'}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component('[initial_52] = "1"').should == {:question_reference => 'initial_52', :operator => '==', :answer_reference => '1'}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component('[initial_119(2)] = "1"').should == {:question_reference => 'initial_119', :operator => '==', :answer_reference => '2'}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component('[f1_q15] >= 21').should == {:question_reference => 'f1_q15', :operator => '>=', :integer_value => '21'}
     # basic, blanks
-    Dependency.decompose_component("[f1_q15]=''").should == {:question_reference => 'f1_q15', :operator => '==', :answer_reference => ''}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[f1_q15]=''").should == {:question_reference => 'f1_q15', :operator => '==', :answer_reference => ''}
     # basic, negatives
-    Dependency.decompose_component("[f1_q15]='-2'").should == {:question_reference => 'f1_q15', :operator => '==', :answer_reference => '-2'}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[f1_q15]='-2'").should == {:question_reference => 'f1_q15', :operator => '==', :answer_reference => '-2'}
     # internal parenthesis
-    Dependency.decompose_component("[hiprep_heat2(97)] = '1'").should == {:question_reference => 'hiprep_heat2', :operator => '==', :answer_reference => '97'}
-    Dependency.decompose_component("[hi_event1_type] <> ''").should == {:question_reference => 'hi_event1_type', :operator => '!=', :answer_reference => ''}
-    
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[hiprep_heat2(97)] = '1'").should == {:question_reference => 'hiprep_heat2', :operator => '==', :answer_reference => '97'}
+    Dependency.new.extend(SurveyorRedcapParserDependencyMethods).decompose_component("[hi_event1_type] <> ''").should == {:question_reference => 'hi_event1_type', :operator => '!=', :answer_reference => ''}
+
   end
   it "should return a survey object" do
     x = %("Variable / Field Name","Form Name","Field Units","Section Header","Field Type","Field Label","Choices OR Calculations","Field Note","Text Validation Type","Text Validation Min","Text Validation Max",Identifier?,"Branching Logic (Show field only if...)","Required Field?"\nstudy_id,demographics,,,text,"Study ID",,,,,,,,)
     Surveyor::RedcapParser.new.parse(x, "redcaptest").is_a?(Survey).should be_true
   end
-  
+
 end

data/spec/models/answer_spec.rb

@@ -42,6 +42,18 @@ describe Answer, "when creating a new answer" do
     @answer.api_id.length.should == 36
   end
   
+  it "should protect api_id, timestamps" do
+    saved_attrs = @answer.attributes
+    if defined? ActiveModel::MassAssignmentSecurity::Error
+      lambda {@answer.update_attributes(:created_at => 3.days.ago, :updated_at => 3.hours.ago)}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+      lambda {@answer.update_attributes(:api_id => "NEW")}.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
+    else
+      @answer.attributes = {:created_at => 3.days.ago, :updated_at => 3.hours.ago} # automatically protected by Rails
+      @answer.attributes = {:api_id => "NEW"} # Rails doesn't return false, but this will be checked in the comparison to saved_attrs
+    end
+    @answer.attributes.should == saved_attrs
+  end
+  
   require 'mustache'
   class FakeMustacheContext < ::Mustache
     def site