quby 5.3.0 → 5.3.1

data/spec/quby/answers/services/answer_validations_spec.rb

@@ -219,193 +219,190 @@ module Quby::Answers::Services
         end
 
         it 'skips validating questions that depend on unfilled questions' do
-          expect(answer.errors.messages[:v_depends_on2]).to be_blank
+          expect(answer.errors.messages_for(:v_depends_on2)).to be_blank
         end
 
         it 'adds an error if integers are formatted incorrectly' do
-          expect(answer.errors.messages[:v_invalid_integer]).to eq([
-            {message: "Invalid integer", valtype: :valid_integer}
-          ])
+          expect(answer.errors.messages_for(:v_invalid_integer)).to eq(["Invalid integer"])
         end
 
         it 'does not add an error if integers are formatted correctly' do
-          expect(answer.errors.messages[:v_valid_integer]).to_not eq([
-            {message: "Invalid integer", valtype: :valid_integer}
+          expect(answer.errors.messages_for(:v_valid_integer)).to_not eq([
+            "Invalid integer"
           ])
         end
 
         it 'adds an error if floats are formatted incorrectly' do
-          expect(answer.errors.messages[:v_invalid_float]).to eq([
-            {message: "Invalid float", valtype: :valid_float}
+          expect(answer.errors.messages_for(:v_invalid_float)).to eq([
+            "Invalid float"
           ])
         end
 
         it 'does not add an error if floats are formatted correctly' do
-          expect(answer.errors.messages[:v_valid_float]).to_not eq([
-            {message: "Invalid float", valtype: :valid_float}
+          expect(answer.errors.messages_for(:v_valid_float)).to_not eq([
+            "Invalid float"
           ])
         end
 
         it 'adds an error if an answer doesnt match a given regex' do
-          expect(answer.errors.messages[:v_invalid_regexp]).to eq([
-            {message: "Does not match expected pattern.", valtype: :regexp}
+          expect(answer.errors.messages_for(:v_invalid_regexp)).to eq([
+            "Does not match expected pattern."
           ])
         end
 
         it 'does not add an error if an answer matches a given regex' do
-          expect(answer.errors.messages[:v_valid_regexp]).to_not eq([
-            {message: "Does not match expected_pattern.", valtype: :regexp}
+          expect(answer.errors.messages_for(:v_valid_regexp)).to_not eq([
+            "Does not match expected_pattern."
           ])
         end
 
         it 'adds an error if a required question is unfilled' do
-          expect(answer.errors.messages[:v_required]).to eq([
-            {message: "Must be answered.", valtype: :requires_answer}
+          expect(answer.errors.messages_for(:v_required)).to eq([
+            "Must be answered."
           ])
         end
 
         it 'does not add an error if a required question is a child of an unchecked option' do
-          expect(answer.errors.messages[:v_child]).to_not eq([
-            {message: "Must be answered.", valtype: :requires_answer}
+          expect(answer.errors.messages_for(:v_child)).to_not eq([
+            "Must be answered."
           ])
         end
 
         it 'adds an error if a child of a filled option of a required question is not filled' do
-          expect(answer.errors.messages[:v_child2]).to eq([
-            {message: "Must be answered.", valtype: :requires_answer}
+          expect(answer.errors.messages_for(:v_child2)).to eq([
+            "Must be answered."
           ])
         end
 
         it 'does not adds an error if a required question is filled' do
-          expect(answer.errors.messages[:v_valid_required]).to_not eq([
-            {message: "Must be answered.", valtype: :requires_answer}
+          expect(answer.errors.messages_for(:v_valid_required)).to_not eq([
+            "Must be answered."
           ])
         end
 
         it 'adds an error if a value is under a given minimum' do
-          expect(answer.errors.messages[:v_under_minimum]).to eq([
-            {message: "Smaller than minimum", valtype: :minimum}
+          expect(answer.errors.messages_for(:v_under_minimum)).to eq([
+            "Smaller than minimum"
           ])
         end
 
         it 'does not add an error if a value is over a given minimum' do
-          expect(answer.errors.messages[:v_over_minimum]).to_not eq([
-            {message: "Smaller than minimum", valtype: :minimum}
+          expect(answer.errors.messages_for(:v_over_minimum)).to_not eq([
+            "Smaller than minimum"
           ])
         end
 
         it 'adds an error if a value exceeds given maximum' do
-          expect(answer.errors.messages[:v_over_maximum]).to eq([
-            {message: "Exceeds maximum", valtype: :maximum}
+          expect(answer.errors.messages_for(:v_over_maximum)).to eq([
+            "Exceeds maximum"
           ])
         end
 
         it 'does not add an error if a value is under a given maximum' do
-          expect(answer.errors.messages[:v_under_maximum]).to_not eq([
-            {message: "Exceeds maximum", valtype: :maximum}
+          expect(answer.errors.messages_for(:v_under_maximum)).to_not eq([
+            "Exceeds maximum"
           ])
         end
 
         it 'adds an error if a date exceeds given maximum' do
-          expect(answer.errors.messages[:v_date_range_over_maximum]).to eq([
-            {message: "Exceeds maximum", valtype: :maximum}
+          expect(answer.errors.messages_for(:v_date_range_over_maximum)).to eq([
+            "Exceeds maximum"
           ])
         end
 
         it 'does not add an error if a date is on a given maximum' do
-          expect(answer.errors.messages[:v_date_range_on_maximum]).to_not eq([
-            {message: "Exceeds maximum", valtype: :maximum}
+          expect(answer.errors.messages_for(:v_date_range_on_maximum)).to_not eq([
+            "Exceeds maximum"
           ])
         end
 
         it 'adds an error if a date is under a given minimum' do
-          expect(answer.errors.messages[:v_date_range_under_minimum]).to eq([
-            {message: "Smaller than minimum", valtype: :minimum}
+          expect(answer.errors.messages_for(:v_date_range_under_minimum)).to eq([
+            "Smaller than minimum"
           ])
         end
 
         it 'does not add an error if a date is on a given minimum' do
-          expect(answer.errors.messages[:v_date_range_on_minimum]).to_not eq([
-            {message: "Smaller than minimum", valtype: :minimum}
+          expect(answer.errors.messages_for(:v_date_range_on_minimum)).to_not eq([
+            "Smaller than minimum"
           ])
         end
 
         it 'adds an error if too many checkbox options are checked' do
-          expect(answer.errors.messages[:v_too_many_checked]).to eq([
-            {message: "Invalid combination of options.", valtype: :too_many_checked}
+          expect(answer.errors.messages_for(:v_too_many_checked)).to eq([
+            "Invalid combination of options."
           ])
         end
 
         it 'does not add an error if not too many checkbox options are checked' do
-          expect(answer.errors.messages[:v_not_too_many_checked]).to_not eq([
-            {message: "Invalid combination of options.", valtype: :too_many_checked}
+          expect(answer.errors.messages_for(:v_not_too_many_checked)).to_not eq([
+            "Invalid combination of options."
           ])
         end
 
         it 'adds an error if not enough checkbox options are checked' do
-          expect(answer.errors.messages[:v_not_all_checked]).to eq([
-            {message: "Invalid combination of options.", valtype: :not_all_checked}
+          expect(answer.errors.messages_for(:v_not_all_checked)).to eq([
+            "Invalid combination of options."
           ])
         end
 
         it 'does not add an error if enough checkbox options are checked' do
-          expect(answer.errors.messages[:v_all_checked]).to_not eq([
-            {message: "Invalid combination of options.", valtype: :not_all_checked}
+          expect(answer.errors.messages_for(:v_all_checked)).to_not eq([
+            "Invalid combination of options."
           ])
         end
 
         it 'adds an error if not enough answers are in a question group with a minimum' do
-          expect(answer.errors.messages[:v_answer_group_under_minimum]).to eq([
-            {message: "Needs at least 1 question(s) answered.", valtype: :answer_group_minimum}
+          expect(answer.errors.messages_for(:v_answer_group_under_minimum)).to eq([
+            "Needs at least 1 question(s) answered."
           ])
         end
 
         it 'does not add an error if enough answers are in a question group with a minimum' do
-          expect(answer.errors.messages[:v_answer_group_over_minimum]).to_not eq([
-            {message: "Needs at least 1 question(s) answered.", valtype: :answer_group_minimum}
+          expect(answer.errors.messages_for(:v_answer_group_over_minimum)).to_not eq([
+            "Needs at least 1 question(s) answered."
           ])
         end
 
         it 'adds an error if too many answers are in a question group with a maximum' do
-          expect(answer.errors.messages[:v_answer_group_over_maximum]).to eq([
-            {message: "Needs at most 1 question(s) answered.", valtype: :answer_group_maximum}
+          expect(answer.errors.messages_for(:v_answer_group_over_maximum)).to eq([
+            "Needs at most 1 question(s) answered."
           ])
         end
 
         it 'does not add an error if not too many answers are in a question group with a maximum' do
-          expect(answer.errors.messages[:v_answer_group_under_maximum]).to_not eq([
-            {message: "Needs at most 1 question(s) answered.", valtype: :answer_group_maximum}
+          expect(answer.errors.messages_for(:v_answer_group_under_maximum)).to_not eq([
+            "Needs at most 1 question(s) answered."
           ])
         end
 
         describe 'for checkboxes' do
           it 'adds an error if not enough answers are in a question group with a minimum' do
-            expect(answer.errors.messages[:v_check_answer_group_under_minimum]).to eq([
-              {message: "Needs at least 3 question(s) answered.", valtype: :answer_group_minimum}
+            expect(answer.errors.messages_for(:v_check_answer_group_under_minimum)).to eq([
+              "Needs at least 3 question(s) answered."
             ])
           end
 
           it 'does not add an error if enough answers are in a question group with a minimum' do
-            expect(answer.errors.messages[:v_check_answer_group_over_minimum]).to be_blank
+            expect(answer.errors.messages_for(:v_check_answer_group_over_minimum)).to be_blank
           end
 
           it 'adds an error if too many answers are in a question group with a maximum' do
-            expect(answer.errors.messages[:v_check_answer_group_over_maximum]).to eq([
-              {message: "Needs at most 1 question(s) answered.", valtype: :answer_group_maximum}
+            expect(answer.errors.messages_for(:v_check_answer_group_over_maximum)).to eq([
+              "Needs at most 1 question(s) answered."
             ])
           end
 
           it 'does not add an error if not too many answers are in a question group with a maximum' do
-            expect(answer.errors.messages[:v_check_answer_group_under_maximum]).to be_blank
+            expect(answer.errors.messages_for(:v_check_answer_group_under_maximum)).to be_blank
           end
 
           it 'adds an error on an empty required title question if a depended on checkbox option is checked' do
-            expect(answer.errors.messages[:v_depend_title]).to eq([{message: "Must be answered.",
-                                                                    valtype: :requires_answer}])
+            expect(answer.errors.messages_for(:v_depend_title)).to eq(["Must be answered."])
           end
 
           it 'does not add error on an empty required title question if a depended on checkbox option is unchecked' do
-            expect(answer.errors.messages[:v_depend2_title]).to be_blank
+            expect(answer.errors.messages_for(:v_depend2_title)).to be_blank
           end
         end
       end
@@ -419,7 +416,7 @@ module Quby::Answers::Services
 
         it 'skips requires_answer validations' do
           expect(answer.errors.messages.values.flatten).not_to be_empty
-          expect(answer.errors.messages.values.flatten.pluck(:valtype)).to_not include(:requires_answer)
+          expect(answer.errors.details.values.flatten.pluck(:valtype)).to_not include(:requires_answer)
         end
       end
     end

data/spec/quby/answers/services/answer_validator_spec.rb

@@ -92,7 +92,7 @@ module Quby::Answers::Services
 
           answer = build_answer(questionnaire: questionnaire, value: {v_ck: {v_ck_a1: 0, v_ck_a2: 0, v_ck_a3: 1}})
           validator(questionnaire: questionnaire, answer: answer).validate
-          expect(answer.errors[:v_ck]).to include(message: "Not enough options checked.", valtype: :minimum_checked_required)
+          expect(answer.errors.messages_for(:v_ck)).to include("Not enough options checked.")
 
           answer = build_answer(questionnaire: questionnaire, value: {v_ck: {v_ck_a1: 0, v_ck_a2: 0, v_ck_a3: 1}})
           allow(answer).to receive(:aborted).and_return(true)
@@ -109,9 +109,9 @@ module Quby::Answers::Services
 
           answer = build_answer(questionnaire: questionnaire, value: {v_1: nil, v_2: nil, v_3: 'bla'})
           validator(questionnaire: questionnaire, answer: answer).validate
-          expect(answer.errors[:v_1]).to include(message: "Needs at least 2 question(s) answered.", valtype: :answer_group_minimum)
-          expect(answer.errors[:v_2]).to include(message: "Needs at least 2 question(s) answered.", valtype: :answer_group_minimum)
-          expect(answer.errors[:v_3]).to include(message: "Needs at least 2 question(s) answered.", valtype: :answer_group_minimum)
+          expect(answer.errors.messages_for(:v_1)).to include("Needs at least 2 question(s) answered.")
+          expect(answer.errors.messages_for(:v_2)).to include("Needs at least 2 question(s) answered.")
+          expect(answer.errors.messages_for(:v_3)).to include("Needs at least 2 question(s) answered.")
 
           answer = build_answer(questionnaire: questionnaire, value: {v_1: nil, v_2: nil, v_3: 'bla'})
           allow(answer).to receive(:aborted).and_return(true)

data/spec/quby/answers/services/updates_answers_spec.rb

@@ -33,17 +33,23 @@ module Quby::Answers::Services
 
       context 'if the answer cannot be updated correctly' do
         before do
-          answer.send :add_error, double(key: :v_0), :valid_integer, "Oh no, ERROR!"
-          allow_server_side_validation_error(always: true)
+          answer.send :add_error, double(key: :v_1), :valid_integer, "Oh no, ERROR!"
+          # allow_server_side_validation_error(always: true)
         end
 
         it 'reports the error' do
           expect(Roqua::Support::Errors).to receive(:report) do |error|
             expect(error).to be_a(Quby::ValidationError)
-            expect(error.message).to eq('["V 0 {:message=>\"Oh no, ERROR!\", :valtype=>:valid_integer}"]')
+            expect(error.message).to eq('["V 1 Oh no, ERROR!"]')
           end
           updates_answers.update('v_0' => 'value')
         end
+
+        # See comment in UpdatesAnswers about why this is a thing.
+        it 'does not report the error if the answer was aborted' do
+          expect(Roqua::Support::Errors).not_to receive(:report)
+          updates_answers.update('v_0' => 'value', "aborted" => true)
+        end
       end
 
       it 'validates the answer' do

data/spec/quby/questionnaires/entities/questionnaire_spec.rb

@@ -427,8 +427,7 @@ module Quby::Questionnaires::Entities
         let(:options) { [{}] } # misses attributes
         it 'passes on errors from the score schema onto the questionnaire' do
           questionnaire.add_score_schema :totaal, 'Totaal', options
-          expected = ["Score schema 'totaal' subscore_schemas element #0 Key moet opgegeven zijn, Key is not a symbol\
-, Label moet opgegeven zijn, Export key moet opgegeven zijn, Export key is not a symbol"]
+          expected = ["Score schema 'totaal' subscore_schemas element #0 Key moet opgegeven zijn, Label moet opgegeven zijn, Export key moet opgegeven zijn, Key is not a symbol, Export key is not a symbol"]
           expect(questionnaire.errors.full_messages).to eq(expected)
         end
       end

data/spec/support/validation_helpers.rb

@@ -140,7 +140,7 @@ module ServerSideValidationHelpers
   end
 
   def expect_error_on(question_key, error_type)
-    result = answer.errors[question_key].map { |error| error[:valtype].to_s }
+    result = answer.errors.where(question_key).map { |error| error.options[:valtype].to_s }
     expect(result).to include(error_type.to_s)
   end