fe 0.0.4 → 2.0.0

data/spec/models/fe/reference_sheet_spec.rb

@@ -1,11 +1,314 @@
 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
+      # doing it 5 times should make it extremely to pass despite there being a bug
+      5.times do
+        r = Fe::ReferenceSheet.new email: 'tester@test.com'
+        k1 = r.generate_access_key
+        k2 = r.generate_access_key
+        expect(k1).to_not eq(k2)
+      end
+    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
+
+  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

data/spec/rails_helper.rb

@@ -1,66 +1,97 @@
 # This file is copied to spec/ when you run 'rails generate rspec:install'
-require 'spork'
 
-Spork.prefork do
-  ENV["RAILS_ENV"] ||= 'test'
-  require File.expand_path("../dummy/config/environment.rb", __FILE__)
-  require 'rspec/rails'
-  require 'rspec'
-  require 'shoulda'
-  require 'database_cleaner'
-  require 'factory_girl_rails'
-  require 'simplecov'
-  SimpleCov.start 'rails' do
-    add_filter "vendor"
-  end
-  Rails.backtrace_cleaner.remove_silencers!
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment.rb", __FILE__)
+require 'rspec/rails'
+require 'rspec'
+require 'shoulda'
+require 'database_cleaner'
+require 'simplecov'
+SimpleCov.start 'rails' do
+  add_filter "vendor"
+end
+Rails.backtrace_cleaner.remove_silencers!
+
+# load concerns and decorators here now that code coverage has started
+Dir.glob(File.join(Fe::Engine.root + 'app/**/*_concern.rb')).each do |c|
+  require_dependency(c)
+end
+Dir.glob(File.join(Rails.root + 'app/decorators/**/*_decorator.rb')).each do |c|
+  require_dependency(c)
+end
+require 'factory_bot_rails'
 
-  ENGINE_RAILS_ROOT = File.join( File.dirname(__FILE__), '../' )
+ENGINE_RAILS_ROOT = File.join( File.dirname(__FILE__), '../' )
 
-  # Requires supporting ruby files with custom matchers and macros, etc,
-  # in spec/support/ and its subdirectories.
-  Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
-  Dir[File.join(ENGINE_RAILS_ROOT,"spec/support/**/*.rb")].each {|f| require f}
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+Dir[File.join(ENGINE_RAILS_ROOT,"spec/support/**/*.rb")].each {|f| require f}
 
-  RSpec.configure do |config|
+RSpec.configure do |config|
 
-    config.include FactoryGirl::Syntax::Methods
-    #
-    #config.before(:suite) do
-    #  DatabaseCleaner.strategy = :transaction
-    #  DatabaseCleaner.clean_with(:truncation)
-    #end
-    #config.before(:each) do
-    #  DatabaseCleaner.start
-    #end
-    #config.after(:each) do
-    #  DatabaseCleaner.clean
-    #end
+  config.include FactoryBot::Syntax::Methods
 
-    config.mock_with :rspec
-    # muted to allow database_cleaner to work
-    #
-    # If you're not using ActiveRecord, or you'd prefer not to run each of your
-    # examples within a transaction, remove the following line or assign false
-    # instead of true.
-    config.use_transactional_fixtures = true
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    ActiveJob::Base.queue_adapter = :test
 
-    # set to true (embrace the future)
-    #
-    # If true, the base class of anonymous controllers will be inferred
-    # automatically. This will be the default behavior in future versions of
-    # rspec-rails.
-    config.infer_base_class_for_anonymous_controllers = true
+    # this usually would go in the app/decorators folder but there's some load order issues with the dummy app
+    # and it's just way easier to do it here
+    Fe::Application.class_eval do
+      belongs_to :applicant, foreign_key: 'applicant_id', class_name: 'Fe::Person'
+    end
+    ApplicationController.class_eval do
+      # some views use current_person, and putting it in the dummy app's
+      # application_controller isn't working
+      def current_person
+      end
+      helper_method :current_person
+    end
+    Fe::Person.class_eval do
+      # defining apps will implement phone
+      def phone
+        "123-456-7890"
+      end
+      # defining apps will implement email
+      def email
+        "email@email.com"
+      end
+    end
 
-    # Run specs in random order to surface order dependencies. If you find an
-    # order dependency and want to debug it, you can fix the order by providing
-    # the seed, which is printed after each run.
-    #     --seed 1234
-    config.order = "random"
   end
-end
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.mock_with :rspec
+  # muted to allow database_cleaner to work
+  #
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = false
+
+  # set to true (embrace the future)
+  #
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  # always render views.  the more view code that gets run the more likely we are to
+  # discover crashes in testing than in production
+  config.render_views
 
-Spork.each_run do
-  # This code will be run each time you run your specs.
-  FactoryGirl.reload
+  config.include(Shoulda::Matchers::ActiveModel, type: :model)
+  config.include(Shoulda::Matchers::ActiveRecord, type: :model)
 end

data/spec/support/choices.xml

@@ -0,0 +1,6 @@
+<choices>
+  <choice>A</choice>
+  <value>1</value>
+  <choice>B</choice>
+  <value>0</value>
+</choices>