fe 1.0.0 → 2.0.0

data/spec/models/fe/question_set_spec.rb

@@ -1,4 +1,95 @@
 require 'rails_helper'
 
 describe Fe::QuestionSet do
+  let(:app) { create(:application) }
+  let(:app2) { create(:application) }
+
+  before do
+    @page = create(:page)
+    @el_confidential = create(:text_field_element, label: 'conf1', is_confidential: true, share: true)
+    @el_visible = create(:text_field_element, label: 'vis1', is_confidential: false, share: false)
+    @el_confidential2 = create(:text_field_element, label: 'conf2', is_confidential: true, share: true)
+    @el_visible2 = create(:text_field_element, label: 'vis2', is_confidential: false, share: true)
+    @page.elements << @el_confidential << @el_visible << @el_confidential2 << @el_visible2
+    @question_set = Fe::QuestionSet.new(@page.elements, app)
+  end
+
+  it 'should filter default show' do
+    # filter out confidential questions and questions with share flag (the share flag would likely
+    # never be used to filter, but just to test that it will only filter those that match all the
+    # filter methods)
+    @question_set.set_filter(filter_default: :show, filter: [ :is_confidential, :share ])
+    expect(@question_set.elements).to eq([@el_visible, @el_visible2])
+  end
+
+  it 'should filter default hide' do
+    # show only confidential questions and questions with share flag (the share flag would likely
+    # never be used to filter, but just to test that it will only filter those that match all the
+    # filter methods)
+    @question_set.set_filter(filter_default: :hide, filter: [ :is_confidential, :share ])
+    expect(@question_set.elements).to eq([@el_confidential, @el_confidential2])
+  end
+
+  context 'saving answers (#post then #save)' do
+    it 'saves a new value' do
+      @question_set.post({ @el_visible.id => 'a text response' }, app)
+      @question_set.save
+      expect(Fe::Answer.count).to eq(1)
+      expect(Fe::Answer.first.value).to eq('a text response')
+      expect(Fe::Answer.first.answer_sheet_id).to eq(app.id)
+      expect(Fe::Answer.first.question_id).to eq(@el_visible.id)
+    end
+    it 'replaces an existing answer' do
+      create(:answer, value: 'a text response', answer_sheet: app, question: @el_visible)
+      @question_set = Fe::QuestionSet.new(@page.elements, app) # need this to reload the elements in the question set to get the new answer
+      @question_set.post({ @el_visible.id => 'an updated response' }, app)
+      @question_set.save
+      expect(Fe::Answer.count).to eq(1)
+      expect(Fe::Answer.first.value).to eq('an updated response')
+      expect(Fe::Answer.first.answer_sheet_id).to eq(app.id)
+      expect(Fe::Answer.first.question_id).to eq(@el_visible.id)
+    end
+    it "doesn't save empty strings continually" do
+      create(:answer, value: '', answer_sheet: app, question: @el_visible)
+      @question_set = Fe::QuestionSet.new(@page.elements, app) # need this to reload the elements in the question set to get the new answer
+      @question_set.post({ @el_visible.id => '' }, app)
+      @question_set.save
+      expect(Fe::Answer.count).to eq(1)
+      expect(Fe::Answer.first.value).to eq('')
+      expect(Fe::Answer.first.answer_sheet_id).to eq(app.id)
+      expect(Fe::Answer.first.question_id).to eq(@el_visible.id)
+    end
+    it 'saves multiple values' do
+      @el_visible.update(kind: 'Fe::ChoiceField', style: 'checkbox', content: "choice 1\nchoice 2")
+      create(:answer, value: 'choice 1', answer_sheet: app, question: @el_visible)
+      @question_set = Fe::QuestionSet.new(@page.elements, app) # need this to reload the elements in the question set to get the new answer
+      @question_set.post({ @el_visible.id => { '0' => 'choice 1', '1' => 'choice 2' } }, app)
+      @question_set.save
+      expect(Fe::Answer.count).to eq(2)
+      expect(Fe::Answer.first.value).to eq('choice 1')
+      expect(Fe::Answer.first.answer_sheet_id).to eq(app.id)
+      expect(Fe::Answer.first.question_id).to eq(@el_visible.id)
+      expect(Fe::Answer.second.value).to eq('choice 2')
+      expect(Fe::Answer.second.answer_sheet_id).to eq(app.id)
+      expect(Fe::Answer.second.question_id).to eq(@el_visible.id)
+    end
+    it 'saves the same value for different answer sheets' do
+      @el_visible.update(kind: 'Fe::ChoiceField', style: 'checkbox', content: "choice 1\nchoice 2")
+      @question_set = Fe::QuestionSet.new(@page.elements, app) # need this to reload the elements in the question set to get the new answer
+      @question_set.post({ @el_visible.id => { '0' => 'choice 1' } }, app)
+      @question_set.save
+      @question_set = Fe::QuestionSet.new(@page.elements, app2) # need this to save answers to app2
+      $b = true
+      @question_set.post({ @el_visible.id => { '0' => 'choice 1' } }, app2)
+      @question_set.save
+      $b = false
+      expect(Fe::Answer.count).to eq(2)
+      expect(Fe::Answer.first.value).to eq('choice 1')
+      expect(Fe::Answer.first.answer_sheet_id).to eq(app.id)
+      expect(Fe::Answer.first.question_id).to eq(@el_visible.id)
+      expect(Fe::Answer.second.value).to eq('choice 1')
+      expect(Fe::Answer.second.answer_sheet_id).to eq(app2.id)
+      expect(Fe::Answer.second.question_id).to eq(@el_visible.id)
+    end
+  end
 end

data/spec/models/fe/question_sheet_spec.rb

@@ -1,24 +1,11 @@
 require 'rails_helper'
 
-describe Fe::QuestionSheet do
+describe Fe::QuestionSheet, type: :model do
   it { expect have_many :pages }
   it { expect have_many :answer_sheets }
   it { expect validate_presence_of :label }
   it { expect validate_uniqueness_of :label }
 
-  context '#questions_count' do
-    it 'should count elements in a grid' do
-      s = create(:question_sheet)
-      p = create(:page, question_sheet: s)
-      e = create(:question_grid)
-      create(:page_element, page: p, element: e)
-      create(:text_field_element, question_grid: e)
-      create(:section, question_grid: e) # this shouldn't get counted
-      p.reload # get the updated all_element_ids column
-      expect(s.questions_count).to eq(1)
-    end
-  end
-
   context '#all_elements' do
     it 'should return elements in the same order as the ids' do
       s = create(:question_sheet)
@@ -92,9 +79,18 @@ describe Fe::QuestionSheet do
     it 'should handle pages with no elements' do
       qs = create(:question_sheet)
       p = create(:page)
-      qs.pages.reload
+      qs.pages << p
       expect(qs.all_elements).to eq([])
     end
+    it 'should handle pages with no elements with empty string for all_elements' do
+      qs = create(:question_sheet)
+      p = create(:page, all_element_ids: '')
+      p2 = create(:page, all_element_ids: '')
+      e = create(:text_field_element)
+      create(:page_element, page: p2, element: e)
+      qs.pages << p << p2
+      expect(qs.all_elements).to eq([e])
+    end
   end
 
   context '#elements' do

data/spec/models/fe/question_spec.rb

@@ -1,21 +1,88 @@
 require 'rails_helper'
 
-describe Fe::Question do
+describe Fe::Question, type: :model do
   it { expect have_many :conditions }
   it { expect have_many :dependents }
   it { expect have_many :sheet_answers }
   it { expect belong_to :related_question_sheet }
-  
+
   # it { expect validate_format_of :slug }
   # it { expect validate_length_of :slug }
   # it { expect validate_uniqueness_of :slug }
-  
-  describe '#default_label?' do 
-    it 'expect return true' do 
+
+  describe '#default_label?' do
+    it 'expect return true' do
       question = Fe::Question.new
       #question.default_label?.expect be_true
       expect(question.default_label?).to eq(true)
     end
   end
-  
+
+  context 'slug' do
+    let(:qs) { create(:question_sheet_with_pages) }
+    let(:page) { qs.pages.first }
+    let(:qs2) { create(:question_sheet_with_pages) }
+    let(:page2) { qs2.pages.first }
+    let(:e1) { create(:text_field_element, slug: 'test') }
+    let(:e2) { create(:text_field_element) }
+
+    before do
+      e1.pages << page
+    end
+
+    it "doesn't let the same slug be used in the question sheet" do
+      e2.pages << page
+      e2.slug = 'test'
+      e2.save
+      expect(e2.errors.full_messages.join(', ')).to include('Slug must be unique (within the question sheet)')
+    end
+    it "lets two elements with the same slug save on different sheets" do
+      e2.pages << page2
+      e2.slug = 'test'
+      expect(e2.save).to be true
+    end
+  end
+
+  context 'saving' do
+    let(:e) { create(:text_field_element) }
+    let(:app) { create(:text_field_element) }
+    let(:app2) { create(:text_field_element) }
+
+    before do
+      e.set_response('answer value', app)
+    end
+
+    context '#save_file' do
+      it ' checks that the answer sheet that calls set_response is the same one that calls save' do
+        expect {
+          e.save_file(app2, nil)
+        }.to raise_error(RuntimeError, "Trying to save answers to a different answer sheet than the one given in set_response")
+      end
+    end
+
+    context '#delete_file' do
+      it ' checks that the answer sheet that calls set_response is the same one that calls delete' do
+        expect {
+          e.delete_file(app2, nil)
+        }.to raise_error(RuntimeError, "Trying to save answers to a different answer sheet than the one given in set_response")
+      end
+
+      it 'deletes the given answer record' do
+        answer_sheet = create(:answer_sheet)
+        question = create(:attachment_field_element)
+        answer = create(:answer, attachment_file_name: 'test_file', answer_sheet: answer_sheet, question: question)
+        question.set_response('', answer_sheet)
+        question.delete_file(answer_sheet, answer)
+        expect{answer.reload}.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    context '#save_response' do
+      it ' checks that the answer sheet that calls set_response is the same one that calls save' do
+        expect {
+          e.save_response(app2)
+        }.to raise_error(RuntimeError, "Trying to save answers to a different answer sheet than the one given in set_response")
+      end
+    end
+  end
 end

data/spec/models/fe/reference_question_spec.rb

@@ -14,4 +14,24 @@ describe Fe::ReferenceQuestion do
       expect(ref.ptemplate).to eq("fe/reference_abc")
     end
   end
+
+  it 'resets the question_sheet_id for references not created' do
+    qs1 = create(:question_sheet)
+    reference_question = create(:reference_question, related_question_sheet_id: qs1.id)
+    reference_sheet = create(:reference_sheet, question: reference_question)
+    expect(reference_sheet.question_sheet_id).to eq(qs1.id)
+
+    # change question sheet on ref element, the reference_sheet's question sheet should change
+    qs2 = create(:question_sheet)
+    expect(reference_sheet.status).to eq('created')
+    reference_question.update_attribute(:related_question_sheet_id, qs2.id)
+    expect(reference_sheet.reload.question_sheet_id).to eq(qs2.id)
+
+    # start the reference, then change question sheet on ref element, 
+    # the reference_sheet's question sheet should not change
+    reference_sheet.update_attribute(:status, 'started')
+    qs3 = create(:question_sheet)
+    reference_question.update_attribute(:related_question_sheet_id, qs3.id)
+    expect(reference_sheet.reload.question_sheet_id).to eq(qs2.id)
+  end
 end

data/spec/models/fe/reference_sheet_spec.rb

@@ -1,14 +1,14 @@
 require 'rails_helper'
 
-describe Fe::ReferenceSheet do
-  it { expect belong_to :question }  
+describe Fe::ReferenceSheet, type: :model do
+  it { expect belong_to :question }
   it { expect belong_to :applicant_answer_sheet }
   # it { expect validate_presence_of :first_name } # need to add started_at column
   # it { expect validate_presence_of :last_name } # need to add started_at column
   # it { expect validate_presence_of :phone } # need to add started_at column
   # it { expect validate_presence_of :email } # need to add started_at column
   # it { expect validate_presence_of :relationship } # need to add started_at column
-  
+
   context '#access_key' do
     it 'should generate two different in the same second' do
       # there's a small chance the first and second access keys generated will be in different seconds
@@ -27,5 +27,288 @@ describe Fe::ReferenceSheet do
     a = create(:answer_sheet, applicant_id: p.id)
     r = create(:reference_sheet, applicant_answer_sheet: a)
     expect(r.applicant).to eq(a.applicant)
-  end 
+  end
+
+  it 'returns the user for applicant' do
+    p = create(:fe_person)
+    a = create(:answer_sheet, applicant_id: p.id)
+    r = create(:reference_sheet, applicant_answer_sheet: a)
+    expect(r.applicant).to eq(a.applicant)
+  end
+
+  context '#required?' do
+    it 'should return the opposite of required? when optional? is false' do
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      application = FactoryBot.create(:answer_sheet)
+      application.question_sheets << question_sheet
+      element = FactoryBot.create(:reference_element, label: "Reference question here", required: true)
+      question_sheet.pages.first.elements << element
+      reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+      allow(reference).to receive(:optional?).and_return(false)
+      expect(reference.optional?).to be false
+      expect(reference.required?).to be true
+    end
+    it 'should return the opposite of required? when optional? is true' do
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      application = FactoryBot.create(:answer_sheet)
+      application.question_sheets << question_sheet
+      element = FactoryBot.create(:reference_element, label: "Reference question here", required: true)
+      question_sheet.pages.first.elements << element
+      reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+      allow(reference).to receive(:optional?).and_return(true)
+      expect(reference.optional?).to be true
+      expect(reference.required?).to be false
+    end
+    it 'should return false when the element is not required' do
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      application = FactoryBot.create(:answer_sheet)
+      application.question_sheets << question_sheet
+      element = FactoryBot.create(:reference_element, label: "Reference question here", required: false)
+      reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+      expect(reference.required?).to be false
+    end
+  end
+
+  context '#optional?' do
+    it 'returns true when the ref question element is hidden from a yes/no choice_field' do
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      choice_field = FactoryBot.create(:choice_field_element, label: "Is the reference required?")
+      question_sheet.pages.reload
+      question_sheet.pages[3].elements << choice_field
+      element = FactoryBot.create(:reference_element, label: "Reference question here", choice_field_id: choice_field.id, required: true)
+      question_sheet.pages[3].elements << element
+
+      application = FactoryBot.create(:answer_sheet)
+      application.question_sheets << question_sheet
+      reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+
+      # make the answer to the conditional question 'no' so that the ref is not required (optional true)
+      choice_field.set_response("no", application)
+      choice_field.save_response(application)
+
+      expect(reference.optional?).to be true
+    end
+    it 'returns false when the ref question element is visible from a yes/no choice_field' do
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      choice_field = FactoryBot.create(:choice_field_element, label: "Is the reference required?")
+      question_sheet.pages.reload
+      question_sheet.pages[3].elements << choice_field
+      element = FactoryBot.create(:reference_element, label: "Reference question here", choice_field_id: choice_field.id, required: true)
+      question_sheet.pages[3].elements << element
+
+      question_sheet.pages[3].elements << choice_field
+      application = FactoryBot.create(:answer_sheet)
+      application.question_sheets << question_sheet
+      reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+
+      # make the answer to the conditional question 'yes' so that the ref is required (optional false)
+      choice_field.set_response("yes", application)
+      choice_field.save_response(application)
+
+      expect(reference.optional?).to be false
+    end
+    it 'returns false when the ref question element is hidden from a conditional element' do
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      choice_field = FactoryBot.create(:choice_field_element, label: "Is the reference required?", conditional_type: "Fe::Element", conditional_answer: "yes")
+      question_sheet.pages.reload
+      question_sheet.pages[3].elements << choice_field
+      element = FactoryBot.create(:reference_element, label: "Reference question here", required: true)
+      question_sheet.pages[3].elements << element
+
+      application = FactoryBot.create(:answer_sheet)
+      application.question_sheets << question_sheet
+      reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+
+      # make the answer to the conditional question 'no' so that the ref is not required (optional true)
+      choice_field.set_response("no", application)
+      choice_field.save_response(application)
+
+      expect(reference.optional?).to be true
+    end
+    it 'returns false when the ref question element is visible from a conditional element' do
+      question_sheet = FactoryBot.create(:question_sheet_with_pages)
+      choice_field = FactoryBot.create(:choice_field_element, label: "Is the reference required?", conditional_type: "Fe::Element", conditional_answer: "yes")
+      question_sheet.pages.reload
+      question_sheet.pages[3].elements << choice_field
+      element = FactoryBot.create(:reference_element, label: "Reference question here", required: true)
+      question_sheet.pages[3].elements << element
+
+      application = FactoryBot.create(:answer_sheet)
+      application.question_sheets << question_sheet
+      reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+
+      # make the answer to the conditional question 'yes' so that the ref is required (optional false)
+      choice_field.set_response("yes", application)
+      choice_field.save_response(application)
+
+      expect(reference.optional?).to be false
+    end
+  end
+
+  it 'sets the question_sheet_id' do
+    element = FactoryBot.create(:reference_element, label: "Reference question here", required: true, related_question_sheet_id: 1)
+    application = FactoryBot.create(:answer_sheet)
+    reference = FactoryBot.create(:reference_sheet, applicant_answer_sheet: application, question: element)
+    expect(reference.question_sheet_id).to eq(1)
+  end
+
+  it 'starts out in created status' do
+    r = create(:reference_sheet)
+    expect(r.status).to eq('created')
+  end
+
+  context '#check_email_change' do
+    let(:qs) { create(:question_sheet) }
+    let(:ref_qs) { create(:question_sheet) }
+    let(:ref_tf) { create(:text_field_element) }
+    let(:q) { create(:reference_question, related_question_sheet: ref_qs) }
+    let(:applicant) { FactoryBot.create(:fe_person) }
+    let(:application) { FactoryBot.create(:answer_sheet, applicant_id: applicant.id) }
+    let(:r) { create(:reference_sheet, status: 'started', question: q, email_sent_at: 1.hour.ago, applicant_answer_sheet: application) }
+    let(:a) { create(:answer, value: 'test', answer_sheet_id: r.id, question: ref_tf) }
+
+    before do
+      ref_qs.pages << create(:page)
+      ref_qs.pages.first.elements << ref_tf
+      @access_key_before = r.access_key
+      @a = create(:answer, value: 'test', answer_sheet_id: r.id, question: ref_tf)
+      create(:fe_email_template, name: 'Reference Deleted', subject: 'Reference Deleted', content: "<a href='test'>reference deleted</a>")
+    end
+
+    it 'should reset the answers and access key if created' do
+      r.update_column(:status, 'created')
+      r.update_attribute(:email, 'a@b.com')
+      expect(r.access_key).to_not eq(@access_key_before)
+      expect(Fe::Answer.count).to eq(0)
+    end
+
+    it 'should reset the answers and access key if started' do
+      r.update_column(:status, 'started')
+      r.update_attribute(:email, 'a@b.com')
+      expect(r.access_key).to_not eq(@access_key_before)
+      expect(Fe::Answer.count).to eq(0)
+    end
+
+    it 'should not reset the answers and access key if completed' do
+      r.update_column(:status, 'completed')
+      r.update_attribute(:email, 'a@b.com')
+      expect(r.access_key).to eq(@access_key_before)
+      expect(Fe::Answer.count).to eq(1)
+    end
+
+    it 'should not reset the answers and access key if completed' do
+      r.update_column(:status, 'completed')
+      r.update_attribute(:email, 'a@b.com')
+      expect(r.access_key).to eq(@access_key_before)
+      expect(Fe::Answer.find_by(id: a.id)).to_not be_nil
+    end
+
+    it "doesn't delete the answers if allow_quiet_reference_email_changes is set " do
+      r.update_column(:status, 'started')
+      r.update_attribute(:email, 'a@b.com')
+      r.allow_quiet_reference_email_changes = true
+      expect(r.access_key).to_not eq(@access_key_before)
+      expect(Fe::Answer.count).to eq(0)
+    end
+  end
+
+  context do
+    let(:qs) { create(:question_sheet_with_pages) }
+    let(:qs2) { create(:question_sheet_with_pages) }
+    let(:p) { qs.pages.first }
+    let(:p2) { qs.pages.first }
+    let(:ref_el) { create(:reference_element) }
+    let(:ref_el2) { create(:reference_element) }
+    let(:ref_el3) { create(:reference_element) }
+    let(:app) { create(:application) }
+    let(:affecting_el) { create(:choice_field_element, label: "Is the reference required?", conditional_type: "Fe::Element", conditional_id: ref_el.id, conditional_answer: "yes") }
+    let(:ref_sheet) { create(:reference_sheet, question: ref_el, applicant_answer_sheet_id: app.id) }
+
+    before do
+      p.elements << affecting_el << ref_el
+      p2.elements << ref_el2
+      app.question_sheets << qs << qs2
+    end
+
+    context '#computed_visibility_cache_key' do
+      it 'returns a cache key that changes when the answers on visibility_affecting_element_ids changes' do
+        # make the answer to the conditional question 'no' so that the ref is required (optional false)
+        affecting_el.set_response('no', app)
+        affecting_el.save_response(app)
+
+        cache_key_before = ref_sheet.computed_visibility_cache_key
+
+        # make the answer to the conditional question 'yes' so that the ref is required (optional false)
+        sleep(1) # make sure the update_at for the answer is changed
+        affecting_el.set_response('yes', app)
+        affecting_el.save_response(app)
+        cache_key_after = ref_sheet.computed_visibility_cache_key
+
+        expect(cache_key_before).to_not eq(cache_key_after)
+      end
+    end
+
+    context '#update_visible' do
+      it "doesn't recompute the visibility if the cache key is the same" do
+        # make the answer to the conditional question 'no' so that the ref is required (optional false)
+        affecting_el.set_response('no', app)
+        affecting_el.save_response(app)
+        ref_sheet.update_visible
+
+        # call update_visible again, it shouldn't update anything because the cache
+        # key hasn't changed
+        allow(ref_sheet).to receive(:question).and_return(ref_el)
+        expect(ref_el).to_not receive(:visible?)
+        ref_sheet.update_visible
+       end
+      it 'computes the visibility and sets the cache key if cache key is initially null' do
+        ref_sheet.update(visibility_cache_key: nil)
+
+        # make the answer to the conditional question 'no' so that the ref is required (optional false)
+        affecting_el.set_response('no', app)
+        affecting_el.save_response(app)
+        allow(ref_sheet).to receive(:question).and_return(ref_el)
+        expect(ref_el).to receive(:visible?).and_return(true)
+        ref_sheet.update_visible
+        ref_sheet.reload
+        expect(ref_sheet.visible).to be true
+        expect(ref_sheet.visibility_cache_key).to_not be_nil
+      end
+      it 'computes the visibility and sets the cache key if the cache key changes' do
+        ref_sheet.update(visibility_cache_key: 'something')
+
+        # make the answer to the conditional question 'no' so that the ref is required (optional false)
+        affecting_el.set_response('no', app)
+        affecting_el.save_response(app)
+        allow(ref_sheet).to receive(:question).and_return(ref_el)
+        expect(ref_el).to receive(:visible?).and_return(false)
+        ref_sheet.update_visible
+        ref_sheet.reload
+        expect(ref_sheet.visible).to be false
+        expect(ref_sheet.visibility_cache_key).to_not eq('something')
+      end
+    end
+  end
+
+  context '#all_affecting_questions_answered' do
+    let(:p) { create(:fe_person) }
+    let(:a) { create(:answer_sheet, applicant_id: p.id) }
+    let(:ref_el) { create(:reference_element) }
+    let(:r) { create(:reference_sheet, question_id: ref_el.id, applicant_answer_sheet: a) }
+    let(:text_el) { create(:text_field_element) }
+
+    it 'returns true when all visibility affecting questions are answered' do
+      expect(r).to receive(:question).and_return(ref_el).twice
+      expect(ref_el).to receive(:visibility_affecting_questions).and_return([text_el])
+      text_el.set_response('some text response', a)
+      text_el.save_response(a)
+      expect(r.all_affecting_questions_answered).to be true
+    end
+
+    it 'returns false when not all visibility affecting questions are answered' do
+      expect(r).to receive(:question).and_return(ref_el).twice
+      expect(ref_el).to receive(:visibility_affecting_questions).and_return([text_el])
+      expect(r.all_affecting_questions_answered).to be false
+    end
+  end
 end

data/spec/models/fe/text_field_spec.rb

@@ -14,4 +14,26 @@ describe Fe::TextField do
       expect(text_field.ptemplate).to eq("fe/text_area_field")
     end 
   end
+
+  it 'should match conditional_match' do
+    qs = create(:question_sheet)
+    app = create(:application)
+    app.question_sheets << qs
+    e = create(:text_field_element, conditional_answer: 'a;b', style: 'drop-down')
+    qs.pages << create(:page)
+    qs.pages.reload.first.elements << e
+    a = create(:answer, question_id: e.id, value: 'b', answer_sheet_id: app.id)
+    expect(e.conditional_match(app)).to be true
+  end
+
+  it "should not match conditional_match if the answer doesn't match" do
+    qs = create(:question_sheet)
+    app = create(:application)
+    app.question_sheets << qs
+    e = create(:text_field_element, conditional_answer: 'a;b', style: 'drop-down')
+    qs.pages << create(:page)
+    qs.pages.reload.first.elements << e
+    a = create(:answer, question_id: e.id, value: 'c', answer_sheet_id: app.id)
+    expect(e.conditional_match(app)).to_not be true
+  end
 end