fe 1.0.0 → 2.0.0

data/spec/models/fe/element_spec.rb

@@ -7,24 +7,26 @@ Fe::Application.class_eval do
   belongs_to :applicant, foreign_key: 'applicant_id', class_name: 'Person'
 end
 
-describe Fe::Element do
-  it { expect belong_to :question_grid }  
-  it { expect belong_to :choice_field }  
+describe Fe::Element, type: :model do
+  it { expect belong_to :question_grid }
+  it { expect belong_to :choice_field }
   it { expect have_many :page_elements }
   it { expect have_many :pages }
   it { expect validate_presence_of :kind }
   # it { expect validate_presence_of :style } # this isn't working
-  it { expect ensure_length_of :kind }
-  it { expect ensure_length_of :style }
+  it { expect validate_length_of :kind }
+  it { expect validate_length_of :style }
 
   it "should not require an element with choice_field set that has a false value" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
-    choice_field = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the enclosed element", conditional_type: "Fe::Element")
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
+    choice_field = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the enclosed element", conditional_type: "Fe::Element")
     question_sheet.pages.reload
     question_sheet.pages[3].elements << choice_field
-    element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the enclosing element", choice_field_id: choice_field.id, required: true)
+    element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the enclosing element", choice_field_id: choice_field.id, required: true)
+    question_sheet.pages[3].elements << element
 
-    application = FactoryGirl.create(:answer_sheet)
+    application = FactoryBot.create(:answer_sheet)
+    application.question_sheets << question_sheet
 
     # make the answer to the conditional question 'no' so that the element is not required
     choice_field.set_response("no", application)
@@ -34,11 +36,11 @@ describe Fe::Element do
   end
 
   it "should update a conditional question if added after that question" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
-    conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element")
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
+    conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element")
     question_sheet.pages.reload
     question_sheet.pages[3].elements << conditional_el
-    element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the previous elemenet", conditional_type: nil, conditional_answer: nil)
+    element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the previous elemenet", conditional_type: nil, conditional_answer: nil)
     question_sheet.pages[3].elements << element
     conditional_el.reload
     expect(conditional_el.conditional).to eq(element)
@@ -46,24 +48,24 @@ describe Fe::Element do
 
   context "in a grid" do
     it "should update a conditional question if added after that question" do
-      question_sheet = FactoryGirl.create(:question_sheet_with_pages)
-      question_grid = FactoryGirl.create(:question_grid)
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      question_grid = FactoryBot.create(:question_grid)
       question_sheet.pages.reload
       question_sheet.pages[3].elements << question_grid
 
-      conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element", question_grid_id: question_grid.id)
-      element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the previous elemenet", conditional_type: nil, conditional_answer: nil, question_grid_id: question_grid.id)
+      conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element", question_grid_id: question_grid.id)
+      element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the previous elemenet", conditional_type: nil, conditional_answer: nil, question_grid_id: question_grid.id)
       expect(conditional_el.reload.conditional).to eq(element)
     end
 
     it "should update the condition element" do
-      question_sheet = FactoryGirl.create(:question_sheet_with_pages)
-      question_grid = FactoryGirl.create(:question_grid)
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      question_grid = FactoryBot.create(:question_grid)
       question_sheet.pages.reload
       question_sheet.pages[3].elements << question_grid
 
-      conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element", question_grid_id: question_grid.id)
-      element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the previous elemenet", conditional_type: nil, conditional_answer: nil, question_grid_id: question_grid.id)
+      conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element", question_grid_id: question_grid.id)
+      element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer that will be hidden by the previous elemenet", conditional_type: nil, conditional_answer: nil, question_grid_id: question_grid.id)
 
       conditional_el.set_conditional_element
       expect(conditional_el.conditional).to eq(element)
@@ -71,13 +73,13 @@ describe Fe::Element do
   end
 
   it "should update a conditional question if elements are moved around" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
-    conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element")
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
+    conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element", conditional_type: "Fe::Element")
     question_sheet.pages.reload
     question_sheet.pages[3].elements << conditional_el
-    element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer that will be moved", conditional_type: nil, conditional_answer: nil)
+    element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer that will be moved", conditional_type: nil, conditional_answer: nil)
     question_sheet.pages[3].elements << element
-    element2 = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer that will be moved to become hidden", conditional_type: nil, conditional_answer: nil)
+    element2 = FactoryBot.create(:text_field_element, label: "This is a test of a short answer that will be moved to become hidden", conditional_type: nil, conditional_answer: nil)
     question_sheet.pages[3].elements << element2
 
     element.reload
@@ -88,17 +90,17 @@ describe Fe::Element do
     # now swap the last 2 elements
     old_element_position = element.position(question_sheet.pages[3])
     old_element2_position = element2.position(question_sheet.pages[3])
-    element.page_elements.first.update_attributes(position: old_element2_position)
-    element2.page_elements.first.update_attributes(position: old_element_position)
+    element.page_elements.first.update(position: old_element2_position)
+    element2.page_elements.first.update(position: old_element_position)
 
     conditional_el.reload
     expect(conditional_el.conditional).to eq(element2)
   end
 
   it "should set the conditional page if a new conditional page element is created" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
     hide_page = question_sheet.pages[4]
-    conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next pag", conditional_type: "Fe::Page", conditional_id: hide_page.id)
+    conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next pag", conditional_type: "Fe::Page", conditional_id: hide_page.id)
     question_sheet.pages.reload
     question_sheet.pages[3].elements << conditional_el
     conditional_el.reload
@@ -106,20 +108,20 @@ describe Fe::Element do
   end
 
   it "should keep the conditional page if a page is moved" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
     hide_page = question_sheet.pages[4]
-    conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next pag", conditional_type: "Fe::Page", conditional_id: hide_page.id)
+    conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next pag", conditional_type: "Fe::Page", conditional_id: hide_page.id)
     question_sheet.pages.reload
     question_sheet.pages[3].elements << conditional_el
     conditional_el.reload
     expect(conditional_el.conditional).to eq(question_sheet.pages[4])
 
     # move some pages around
-    question_sheet.pages[0].update_attributes number: 1
-    question_sheet.pages[1].update_attributes number: 2
-    question_sheet.pages[2].update_attributes number: 3
-    question_sheet.pages[3].update_attributes number: 0 # the page the conditional element is on
-    question_sheet.pages[4].update_attributes number: 4
+    question_sheet.pages[0].update number: 1
+    question_sheet.pages[1].update number: 2
+    question_sheet.pages[2].update number: 3
+    question_sheet.pages[3].update number: 0 # the page the conditional element is on
+    question_sheet.pages[4].update number: 4
     question_sheet.pages.reload
 
     # the page after the conditional page should still be set to the same page
@@ -128,51 +130,97 @@ describe Fe::Element do
   end
 
   it "should not let a hidden page make the questionnaire incomplete" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
     hide_page = question_sheet.pages[4]
-    conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next page", conditional_type: "Fe::Page", conditional_id: hide_page.id, conditional_answer: "yes")
+    conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the page", conditional_type: "Fe::Page", conditional_id: hide_page.id, conditional_answer: "yes")
     question_sheet.pages.reload
     question_sheet.pages[3].elements << conditional_el
     conditional_el.reload
     expect(conditional_el.conditional).to eq(question_sheet.pages[4])
 
     # add required element on hidden page
-    element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer on a hidden page")
+    element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer on a hidden page")
     hide_page.elements << element
 
     # set up an answer sheet
-    application = FactoryGirl.create(:answer_sheet)
-    application.answer_sheet_question_sheet = FactoryGirl.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
-    application.answer_sheet_question_sheets.first.update_attributes(question_sheet_id: question_sheet.id)
+    application = FactoryBot.create(:answer_sheet)
+    application.answer_sheet_question_sheet = FactoryBot.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
+    application.answer_sheet_question_sheets.first.update(question_sheet_id: question_sheet.id)
+    application.reload
 
     # validate the hidden page, it should be marked complete
     expect(hide_page.complete?(application)).to eq(true)
 
-    # make the answer to the conditional question 'yes' so that the element shows up and is thus required
+    # make the answer to the conditional question 'yes' so that the page is now visible
     conditional_el.set_response("yes", application)
     conditional_el.save_response(application)
 
-    # validate the now-visible  page, it should be marked not complete
+    # validate the now-visible page, it should be marked not complete
+    hide_page.clear_hidden_cache
     expect(hide_page.complete?(application)).to eq(false)
   end
 
+  it "should not require a nested element in nested hidden page" do
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
+    conditional_el1 = FactoryBot.create(:choice_field_element, label: 'LVL1')
+    question_sheet.pages.reload
+    question_sheet.pages[0].elements << conditional_el1
+
+    conditional_el2 = FactoryBot.create(:choice_field_element, label: 'LVL2', choice_field_id: conditional_el1.id)
+    conditional_el2.reload
+
+    group = FactoryBot.create(:question_grid, choice_field_id: conditional_el2.id, label: 'LVL3 (GRID)')
+
+    conditional_el3 = FactoryBot.create(:choice_field_element, label: 'LVL4', question_grid_id: group.id)
+    conditional_el3.reload
+
+    # add required element on hidden group
+    element = FactoryBot.create(:text_field_element, label: "EL (LVL5)", choice_field_id: conditional_el3.id)
+
+    # set up an answer sheet
+    application = FactoryBot.create(:answer_sheet)
+    application.answer_sheet_question_sheet = FactoryBot.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
+    application.answer_sheet_question_sheets.first.update(question_sheet_id: question_sheet.id)
+    application.reload
+
+    # start with all the conditional element values yes so that the element will show
+    conditional_el1.set_response("yes", application)
+    conditional_el1.save_response(application)
+    conditional_el2.set_response("yes", application)
+    conditional_el2.save_response(application)
+    conditional_el3.set_response("yes", application)
+    conditional_el3.save_response(application)
+
+    # the element should be visible at this point
+    expect(element.visible?(application)).to be(true)
+
+    # hide the second conditional element, that should hide the group and the element with it
+    conditional_el2.set_response("no", application)
+    conditional_el2.save_response(application)
+
+    # the element should be hidden now
+    element = Fe::Element.find(element.id)
+    expect(element.visible?(application)).to be(false)
+  end
+
   it "should not require questions in a hidden page" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
     hide_page = question_sheet.pages[4]
-    conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next page", conditional_type: "Fe::Page", conditional_id: hide_page.id, conditional_answer: "yes")
+    conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next page", conditional_type: "Fe::Page", conditional_id: hide_page.id, conditional_answer: "yes")
     question_sheet.pages.reload
     question_sheet.pages[3].elements << conditional_el
     conditional_el.reload
     expect(conditional_el.conditional).to eq(question_sheet.pages[4])
 
     # add required element on hidden page
-    element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer on a hidden page")
+    element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer on a hidden page")
     hide_page.elements << element
 
     # set up an answer sheet
-    application = FactoryGirl.create(:answer_sheet)
-    application.answer_sheet_question_sheet = FactoryGirl.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
-    application.answer_sheet_question_sheets.first.update_attributes(question_sheet_id: question_sheet.id)
+    application = FactoryBot.create(:answer_sheet)
+    application.answer_sheet_question_sheet = FactoryBot.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
+    application.answer_sheet_question_sheets.first.update(question_sheet_id: question_sheet.id)
+    application.reload
 
     # make the answer to the conditional question 'yes' (match) so that the element is visible (and thus required)
     conditional_el.set_response("yes", application)
@@ -186,6 +234,7 @@ describe Fe::Element do
     conditional_el.save_response(application)
 
     # validate the hidden page, it should be marked complete because of being hidden
+    hide_page.clear_hidden_cache
     expect(hide_page.complete?(application)).to eq(true)
   end
 
@@ -196,13 +245,13 @@ describe Fe::Element do
 
   context '#limit' do
     it "should return a value for a legitimate object_name and attribute_name" do
-      application = FactoryGirl.create(:application)
+      application = FactoryBot.create(:application)
       application.applicant_id = create(:fe_person).id
       element = Fe::Element.new object_name: 'applicant', attribute_name: 'first_name'
       expect(element.limit(application)).to_not be_nil
     end
     it "should return nil instead of crashing if there's an exception thrown" do
-      application = FactoryGirl.create(:application)
+      application = FactoryBot.create(:application)
       application.applicant_id = create(:fe_person).id
       element = Fe::Element.new object_name: 'applicant', attribute_name: 'asdf'
       expect(element.limit(application)).to be_nil
@@ -211,7 +260,7 @@ describe Fe::Element do
 
   context '#previous_element' do
     it "should work" do
-      application = FactoryGirl.create(:application)
+      application = FactoryBot.create(:application)
       application.applicant_id = create(:fe_person).id
       element1 = create(:text_field_element)
       element2 = create(:text_field_element)
@@ -225,11 +274,8 @@ describe Fe::Element do
   end
 
   context '#required' do
-    it "should work when the required flag is set" do
-      # TODO
-    end
     it "should not require a conditional element when its prev element isn't matching the answer text" do
-      application = FactoryGirl.create(:application)
+      application = FactoryBot.create(:application)
       application.applicant_id = create(:fe_person).id
       element1 = create(:text_field_element)
       element2 = create(:text_field_element, conditional_answer: 'test')
@@ -245,9 +291,9 @@ describe Fe::Element do
       create(:page_element, page_id: page.id, element_id: element3.id)
 
       # set up an answer sheet
-      application = FactoryGirl.create(:answer_sheet)
-      application.answer_sheet_question_sheet = FactoryGirl.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
-      application.answer_sheet_question_sheets.first.update_attributes(question_sheet_id: question_sheet.id)
+      application = FactoryBot.create(:answer_sheet)
+      application.answer_sheet_question_sheet = FactoryBot.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
+      application.answer_sheet_question_sheets.first.update(question_sheet_id: question_sheet.id)
 
       # make the answer to the conditional question 'yes' so that the element shows up and is thus required
       element2.set_response('nomatch', application)
@@ -286,7 +332,7 @@ describe Fe::Element do
       expect(page.elements.last.pages).to eq([page])
     end
   end
-  
+
   context '#update_page_all_element_ids' do
     it 'should rebuild all_element_ids in all pages' do
       element1 = create(:text_field_element)
@@ -324,4 +370,150 @@ describe Fe::Element do
       expect(page.reload.all_element_ids).to eq("#{grid.id},#{textfield.id}")
     end
   end
+
+  context 'translations' do
+    it 'uses the translation' do
+      e = create(:text_field_element, label_translations: { 'fr' => 'fr label' }, tip_translations: { 'fr' => 'fr tip' },
+                 content_translations: { 'fr' => 'fr content' })
+      expect(e.label('fr')).to eq('fr label')
+      expect(e.content('fr')).to eq('fr content')
+      expect(e.tooltip('fr')).to eq('fr tip')
+    end
+    it 'shows english if the translation is an empty string' do
+      e = create(:text_field_element, label_translations: { 'fr' => '' }, tip_translations: { 'fr' => '' },
+                 content_translations: { 'fr' => '' })
+      expect(e.label('fr')).to eq(e[:label])
+      expect(e.content('fr')).to eq(e[:content])
+      expect(e.tooltip('fr')).to eq(e[:tooltip])
+    end
+    it 'uses english choices if the translation is an empty string' do
+      e = create(:choice_field_element, style: 'drop-down', content: "1\r\n2", content_translations: { 'fr' => '' })
+      expect(e.choices('fr')).to eq([['1', '1'], ['2', '2']])
+    end
+  end
+
+  context '#css_classes' do
+    it 'splits the css classes into an array' do
+      e = create(:text_field_element, css_class: 'a    1 2')
+      expect(e.css_classes).to eq(%w(a 1 2))
+    end
+    it 'handles nil' do
+      e = create(:text_field_element, css_class: nil)
+      expect(e.css_classes).to eq([])
+    end
+  end
+
+  context '#matches_filter' do
+    let(:e) { create(:text_field_element, is_confidential: true, share: true, hide_label: false) }
+
+    it 'matches when all filter methods match' do
+      expect(e.matches_filter([:is_confidential, :share])).to be true
+    end
+    it "doesn't matches when any methods is false" do
+      expect(e.matches_filter([:is_confidential, :hide_label])).to be false
+    end
+    it "doesn't matches when all methods are false" do
+      expect(e.matches_filter([:hide_label])).to be false
+    end
+  end
+
+  context '#hidden?' do
+    let(:e) { create(:text_field_element, is_confidential: true, share: true, hide_label: false) }
+    let(:application) { FactoryBot.create(:answer_sheet) }
+
+    it "returns true if the page is nil and the element isn't on any pages" do
+      expect(e.hidden?(application, nil)).to be true
+    end
+  end
+
+  context 'multiple question sheets' do
+    let(:e2) { create(:text_field_element, is_confidential: true, share: true, hide_label: false) }
+    let(:e) { create(:text_field_element, is_confidential: true, share: true, hide_label: false,
+                     conditional_type: 'Fe::Element', conditional_id: e2, conditional_answer: 'match') }
+    let(:application) { FactoryBot.create(:answer_sheet) }
+    let(:qs) { create(:question_sheet_with_pages) }
+    let(:qs2) { create(:question_sheet_with_pages) }
+    let(:p2) { qs2.pages.first }
+
+    before do
+      e.set_response('nomatch', application) # no match so the next element is hidden
+      e.save_response(application)
+      application.question_sheets << qs << qs2
+      p2.elements << e << e2
+    end
+
+    context '#hidden?' do
+      it "returns true for a page that's not on the application" do
+        qs2 = create(:question_sheet_with_pages)
+        expect(e2.hidden?(application, p2)).to be(true)
+      end
+      it "returns false for a conditionally visible element on a question sheet that isn't the first one" do
+        e.set_response('match', application) # match so the next element is visible
+        e.save_response(application)
+        expect(e2.hidden?(application, p2)).to be(false)
+      end
+      it "returns true for a hidden element on a question sheet that isn't the first one" do
+        expect(e2.hidden?(application, p2)).to be(true)
+      end
+    end
+    context '#hidden_by_conditional?' do
+      it "returns false for a page passed in that's not on the application" do
+        expect(e.hidden_by_conditional?(application, create(:page))).to be(false)
+      end
+    end
+  end
+
+  context '#visibility_affecting_element_ids' do
+    let(:grid_el) { create(:question_grid) }
+    let(:grid_cond) { create(:choice_field_element, label: "Is the grid visible?", conditional_type: "Fe::Element", conditional_id: grid_el.id, conditional_answer: "yes") }
+    let(:ref_el) { create(:reference_element, question_grid_id: grid_el.id) }
+    let(:choice) { create(:choice_field_element, label: "is the ref element inside this element visible?") }
+    let(:ref_el2) { create(:reference_element, choice_field_id: choice.id) }
+    let(:choice_cond) { create(:choice_field_element, label: "Is the next choice element visible?", conditional_type: "Fe::Element", conditional_id: choice.id, conditional_answer: "yes") }
+    let(:ref_el3_cond) { create(:choice_field_element, label: "Is the next ref element visible?", conditional_type: "Fe::Element", conditional_id: ref_el3.id, conditional_answer: "yes") }
+    let(:ref_el3) { create(:reference_element) }
+
+    before do
+      # make sure all the elements are created
+      grid_el
+      grid_cond
+      ref_el
+      choice
+      ref_el2
+      choice_cond
+      ref_el3_cond
+      ref_el3
+    end
+
+    it 'recomputes the visibility affecting element ids after a new element is added' do
+      expect(ref_el.visibility_affecting_element_ids).to eq([grid_el.id, grid_cond.id])
+      # add a new visibility affecting element and it should pick it up
+      # need to instantiate the ref_el again though to clear out the in-memory
+      # instance variable cache
+      ref_el1 = Fe::Element.find(ref_el.id)
+      grid_cond_cond = create(:choice_field_element, label: "Is the grid conditional visible?", conditional_type: "Fe::Element", conditional_id: grid_cond.id, conditional_answer: "yes")
+      expect(ref_el1.visibility_affecting_element_ids).to eq([grid_el.id, grid_cond.id, grid_cond_cond.id])
+    end
+    it 'includes affecting element ids of an element in a grid' do
+      expect(ref_el.visibility_affecting_element_ids).to eq([grid_el.id, grid_cond.id])
+    end
+    it 'includes affecting element ids of an element in a choice field' do
+      expect(ref_el2.visibility_affecting_element_ids).to eq([choice.id, choice_cond.id])
+    end
+    it 'includes directly affecting element ids' do
+      expect(ref_el3.visibility_affecting_element_ids).to eq([ref_el3_cond.id])
+    end
+  end
+
+  context '#visibility_affecting_questions' do
+    let!(:ref_el) { create(:reference_element) }
+    let!(:text_el) { create(:text_field_element) }
+    let!(:grid_el) { create(:question_grid) }
+
+    it 'returns all questions with id in visibility_affecting_element_ids' do
+      element_ids = [ text_el.id, grid_el.id ]
+      expect(ref_el).to receive(:visibility_affecting_element_ids).and_return(element_ids)
+      expect(ref_el.visibility_affecting_questions).to eq([text_el])
+    end
+  end
 end

data/spec/models/fe/email_template_spec.rb

@@ -1,5 +1,5 @@
 require 'rails_helper'
 
-describe Fe::EmailTemplate do
+describe Fe::EmailTemplate, type: :model do
   it { expect validate_presence_of :name }
 end

data/spec/models/fe/page_element_spec.rb

@@ -1,6 +1,6 @@
 require 'rails_helper'
 
-describe Fe::PageElement do
+describe Fe::PageElement, type: :model do
   it { expect belong_to :page }
   it { expect belong_to :element }
 end

data/spec/models/fe/page_spec.rb

@@ -1,6 +1,6 @@
 require 'rails_helper'
 
-describe Fe::Page do
+describe Fe::Page, type: :model do
   it { expect belong_to :question_sheet }
   it { expect have_many :page_elements }
   it { expect have_many :elements }
@@ -9,39 +9,40 @@ describe Fe::Page do
   it { expect have_many :question_grid_with_totals }
   # it { expect validate_presence_of :label } # this isn't working
   # it { expect validate_presence_of :number } # this isn't working
-  it { expect ensure_length_of :label }
+  it { expect validate_length_of :label }
   # it { expect validate_numericality_of :number }
 
   it "should not require a hidden element" do
-    question_sheet = FactoryGirl.create(:question_sheet_with_pages)
-    conditional_el = FactoryGirl.create(:choice_field_element, label: "This is a test for a yes/no question that will hide the next element if the answer is yes", conditional_type: "Fe::Element", conditional_answer: "yes")
+    question_sheet = FactoryBot.create(:question_sheet_with_pages)
+    conditional_el = FactoryBot.create(:choice_field_element, label: "This is a test for a yes/no question that will show the next element if the answer is yes", conditional_type: "Fe::Element", conditional_answer: "yes")
     question_sheet.pages.reload
     question_sheet.pages[3].elements << conditional_el
-    element = FactoryGirl.create(:text_field_element, label: "This is a test of a short answer that is made visible by the previous elemenet")
+    element = FactoryBot.create(:text_field_element, label: "This is a test of a short answer that is made visible by the previous element")
     question_sheet.pages[3].elements << element
     conditional_el.reload
     expect(conditional_el.conditional).to eq(element)
 
     # set up an answer sheet
-    application = FactoryGirl.create(:answer_sheet)
-    application.answer_sheet_question_sheet = FactoryGirl.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
-    application.answer_sheet_question_sheets.first.update_attributes(question_sheet_id: question_sheet.id)
+    application = FactoryBot.create(:answer_sheet)
+    application.answer_sheet_question_sheet = FactoryBot.create(:answer_sheet_question_sheet, answer_sheet: application, question_sheet: question_sheet)
+    application.answer_sheet_question_sheets.first.update(question_sheet_id: question_sheet.id)
+    application.reload
 
-    # make the answer to the conditional question 'yes' so that the next element shows up and is thus required
+    # make the answer to the conditional question 'no' so that the next element does not show up and is not required
     conditional_el.set_response("no", application)
     conditional_el.save_response(application)
 
-    # validate the page -- the next element after the conditional should not be required
+    # validate the page -- the next element after the conditional should not be required (because it's hidden)
     page = question_sheet.pages[3]
     question_sheet.pages.reload
-    page.reload
     expect(page.complete?(application)).to eq(true)
 
     # make the answer to the conditional question 'yes' so that the next element shows up and is thus required
     conditional_el.set_response("yes", application)
     conditional_el.save_response(application)
+    conditional_el.display_response(application)
 
-    # validate the page -- the next element after the conditional should not be required
+    # validate the page -- the next element after the conditional be required now, making the page incomplete
     page = question_sheet.pages[3]
     expect(page.complete?(application)).to eq(false)
   end
@@ -155,4 +156,48 @@ describe Fe::Page do
       expect(p.all_element_ids).to eq('')
     end
   end
+  context '#copy_to' do
+    it 'should return the new page' do
+      q = create(:question_sheet)
+      p = create(:page)
+      r = p.copy_to(q)
+      expect(r.class).to be(Fe::Page)
+    end
+  end
+  context '#complete' do
+    it "is complete when there's a required element inside a hidden group" do
+      q = create(:question_sheet)
+      p = create(:page, question_sheet: q)
+      g1 = create(:question_grid)
+      c = create(:text_field_element, conditional_answer: 'asdf', conditional: g1)
+      create(:page_element, page: p, element: c)
+      create(:page_element, page: p, element: g1)
+      g2 = create(:question_grid_with_total, question_grid: g1)
+      e = create(:text_field_element, question_grid: g2)
+
+      application = create(:answer_sheet)
+      application.question_sheets << q
+
+      c.set_response('asdf', application)
+      c.save_response(application)
+      expect(e.hidden?(application)).to be(false)
+      expect(p.complete?(application)).to be(false)
+
+      # change the answer to make sure it changes to not required
+      c.set_response('something else', application)
+      c.save_response(application)
+      expect(c.display_response(application)).to eq('something else')
+
+      expect(e.hidden?(application)).to be(true)
+      p.clear_all_hidden_elements
+      expect(p.complete?(application)).to be(true)
+    end
+  end
+  context '#hidden' do
+    it 'checks the hidden column' do
+      q = create(:question_sheet)
+      p = create(:page, question_sheet: q, hidden: true)
+      expect(p.hidden).to be true
+    end
+  end
 end

data/spec/models/fe/person_spec.rb

@@ -1,4 +1,4 @@
 require 'rails_helper'
 
-RSpec.describe Fe::Person, :type => :model do
+RSpec.describe Fe::Person, type: :model do
 end