fe 0.0.4 → 2.0.0

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,38 +9,195 @@ 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
     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
+
+  context '#all_elements' do
+    it 'should return elements in the same order the ids were given' do
+      p = create(:page, all_element_ids: '2,1')
+      e1 = create(:text_field_element)
+      e2 = create(:text_field_element)
+      expect(p.all_elements).to eq([e2,e1])
+    end
+    it 'should include elements in a grid' do
+      p = create(:page)
+      e = create(:question_grid)
+      create(:page_element, page: p, element: e)
+      tf1 = create(:text_field_element, question_grid: e)
+
+      # add text field directly to page
+      tf2 = create(:text_field_element)
+      create(:page_element, page: p, element: tf2)
+
+      # add section to grid
+      section = create(:section, question_grid: e)
+
+      p.reload # get the updated all_element_ids column
+      expect(p.all_elements).to eq([e, tf1, section, tf2])
+    end
+    it 'should return an empty active record result set when no elements are added' do
+      p = create(:page)
+      expect(p.all_elements).to eq([])
+    end
+    it 'should rebuild_all_element_ids first when not set' do
+      p = create(:page)
+      p.all_elements
+      p.reload
+      expect(p.all_element_ids).to eq('')
+    end
+  end
+  context '#has_questions?' do
+    it 'should return true when there is a question directly on the page' do
+      p = create(:page)
+      e = create(:text_field_element)
+      create(:page_element, page: p, element: e)
+      expect(p.has_questions?).to be true
+    end
+    it 'should not count a non-question directly on the page' do
+      p = create(:page)
+      e = create(:section)
+      create(:page_element, page: p, element: e)
+      expect(p.has_questions?).to be false
+    end
+    it 'should return true when the only question is in a grid' do
+      p = create(:page)
+      e = create(:question_grid)
+      create(:page_element, page: p, element: e)
+      tf1 = create(:text_field_element, question_grid: e)
+      section = create(:section, question_grid: e)
+      p.reload # get the updated all_element_ids column
+      expect(p.has_questions?).to be true
+    end
+    it 'should not count a non-question inside a grid as a question' do
+      p = create(:page)
+      e = create(:question_grid)
+      create(:page_element, page: p, element: e)
+      section = create(:section, question_grid: e)
+      p.reload # get the updated all_element_ids column
+      expect(p.has_questions?).to be false
+    end
+  end
+  context '#all_questions' do
+    it 'should include elements in a grid with total' do
+      p = create(:page)
+      grid = create(:question_grid_with_total) # shouldn't be included in all_questions because it's a not a question
+      create(:page_element, page: p, element: grid, position: 1)
+      tf1 = create(:text_field_element, question_grid: grid)
+      tf2 = create(:text_field_element) # add directly to page
+      create(:page_element, page: p, element: tf2, position: 2)
+      section = create(:section, question_grid: grid) # shouldn't be included in all_questions because it's not a question
+      p.reload # get the updated all_element_ids column
+      expect(p.all_questions).to eq([tf1, tf2])
+    end
+  end
+  context '#rebuild_all_element_ids' do
+    it 'should include elements in a grid' do
+      p = create(:page)
+      e = create(:question_grid)
+      create(:page_element, page: p, element: e)
+      tf1 = create(:text_field_element, question_grid: e)
+      tf2 = create(:text_field_element) # add directly to page
+      create(:page_element, page: p, element: tf2)
+      section = create(:section, question_grid: e)
+      p.update_column :all_element_ids, nil
+      p.rebuild_all_element_ids
+      expect(p.all_element_ids).to eq("#{e.id},#{tf1.id},#{section.id},#{tf2.id}")
+    end
+  end
+  context '#all_element_ids' do
+    it 'should rebuild_all_element_ids first when not set' do
+      p = create(:page)
+      p.all_element_ids
+      p.reload
+      expect(p.all_element_ids).to eq('')
+    end
+    it 'should rebuild_all_element_ids when an element is removed from a page' do
+      p = create(:page)
+      e = create(:text_field_element, question_grid: e)
+      pe = create(:page_element, page: p, element: e)
+      expect(p.all_element_ids).to eq(e.id.to_s)
+      pe.destroy
+      p.reload
+      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

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,8 +1,110 @@
 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 '#all_elements' do
+    it 'should return elements in the same order as the ids' do
+      s = create(:question_sheet)
+
+      # P1
+      p1 = create(:page, question_sheet: s)
+      tf1 = create(:text_field_element)
+      create(:page_element, page: p1, element: tf1)
+      tf2 = create(:text_field_element)
+      create(:page_element, page: p1, element: tf2)
+      p1.update_column(:all_element_ids, "#{tf2.id},#{tf1.id}")
+
+      # P2
+      p2 = create(:page, question_sheet: s)
+      tf3 = create(:text_field_element)
+      create(:page_element, page: p2, element: tf3)
+      tf4 = create(:text_field_element)
+      create(:page_element, page: p2, element: tf4)
+      p2.update_column(:all_element_ids, "#{tf4.id},#{tf3.id}")
+
+      p1.reload # get the updated all_element_ids column
+      p2.reload # get the updated all_element_ids column
+      expect(s.all_elements).to eq([tf2, tf1, tf4, tf3])
+    end
+
+    it 'should include 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)
+      tf1 = create(:text_field_element, question_grid: e)
+      tf2 = create(:text_field_element) # add directly to page
+      create(:page_element, page: p, element: tf2)
+      section = create(:section, question_grid: e)
+      p.reload # get the updated all_element_ids column
+      expect(s.all_elements).to eq([e, tf1, section, tf2])
+    end
+    it 'should include elements across multiple pages' do
+      s = create(:question_sheet)
+
+      # P1
+      p1 = create(:page, question_sheet: s)
+
+      # grid pg1
+      g1 = create(:question_grid)
+      create(:page_element, page: p1, element: g1)
+      tf1 = create(:text_field_element, question_grid: g1)
+      s1 = create(:section, question_grid: g1)
+
+      # tf added directly to pg1
+      tf2 = create(:text_field_element)
+      create(:page_element, page: p1, element: tf2)
+
+      # P2
+      p2 = create(:page, question_sheet: s)
+
+      # grid pg2
+      g2 = create(:question_grid)
+      create(:page_element, page: p2, element: g2)
+      tf3 = create(:text_field_element, question_grid: g2)
+      s2 = create(:section, question_grid: g2)
+
+      # tf added directly to pg2
+      tf4 = create(:text_field_element)
+      create(:page_element, page: p2, element: tf4)
+
+      p1.reload # get the updated all_element_ids column
+      p2.reload # get the updated all_element_ids column
+      expect(s.all_elements).to eq([g1, tf1, s1, tf2, g2, tf3, s2, tf4])
+    end
+    it 'should handle pages with no elements' do
+      qs = create(:question_sheet)
+      p = create(:page)
+      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
+    it 'should not include 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)
+      tf1 = create(:text_field_element, question_grid: e) # shouldn't be included because it's in grid
+      tf2 = create(:text_field_element)
+      create(:page_element, page: p, element: tf2)
+      create(:section, question_grid: e) # shouldn't be included because it's in grid
+      p.reload # get the updated all_element_ids column
+      expect(s.elements).to eq([e, tf2])
+    end
+  end
 end

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