validator job fix + more tests

lib/inferno/config/boot/validator.rb

@@ -7,11 +7,10 @@
     next if Sidekiq.server?
 
     Inferno::Repositories::TestSuites.new.all.each do |suite|
-      suite.fhir_validators.each do |name, validators, required_suite_options|
+      suite.fhir_validators.each do |name, validators|
         validators.each_with_index do |validator, index|
           if validator.is_a? Inferno::DSL::FHIRResourceValidation::Validator
-            Inferno::Jobs.perform(Inferno::Jobs::InvokeValidatorSession, suite.id, name.to_s, index,
-                                  required_suite_options)
+            Inferno::Jobs.perform(Inferno::Jobs::InvokeValidatorSession, suite.id, name.to_s, index)
           end
         end
       end

lib/inferno/db/migrations/010_add_validator_sessions.rb

@@ -2,7 +2,7 @@
   change do
     create_table :validator_sessions do
       column :id, String, primary_key: true, null: false, size: 36
-      column :validator_session_id,  String, null: false, size: 255#, unique: true
+      column :validator_session_id,  String, null: false, size: 255 # , unique: true
       column :test_suite_id, String, null: false, size: 255
       column :validator_name, String, null: false, size: 255
       column :suite_options, String, text: true

lib/inferno/dsl/fhir_resource_validation.rb

@@ -284,7 +284,6 @@ def operation_outcome_from_hl7_wrapped_response(response)
                                         validator_name: name.to_s, suite_options: requirements)
             @session_id = res['sessionId']
           end
-
 
           # assume for now that one resource -> one request
           issues = res['outcomes'][0]['issues']&.map do |i|

lib/inferno/jobs/invoke_validator_session.rb

@@ -3,7 +3,7 @@ module Jobs
     class InvokeValidatorSession
       include Sidekiq::Worker
 
-      def perform(suite_id, validator_name, validator_index, required_suite_options)
+      def perform(suite_id, validator_name, validator_index)
         suite = Inferno::Repositories::TestSuites.new.find suite_id
         validator = suite.fhir_validators[validator_name.to_sym][validator_index]
         response_body = validator.validate(FHIR::Patient.new, 'http://hl7.org/fhir/StructureDefinition/Patient')
@@ -12,7 +12,7 @@ def perform(suite_id, validator_name, validator_index, required_suite_options)
           session_id = res['sessionId']
           session_repo = Inferno::Repositories::ValidatorSessions.new
           session_repo.save(test_suite_id: suite_id, validator_session_id: session_id,
-                            validator_name:, suite_options: required_suite_options)
+                            validator_name:, suite_options: validator.requirements)
           validator.session_id = session_id
         else
           Inferno::Application['logger'].error("InvokeValidatorSession - error from validator: #{response_body}")

lib/inferno/repositories/validator_sessions.rb

@@ -20,14 +20,13 @@ def save(params)
 
         db.insert_conflict(
           target: [:test_suite_id,
-                  :suite_options,
-                  :validator_name],
+                   :suite_options,
+                   :validator_name],
           update: { validator_session_id:,
                     test_suite_id:,
                     suite_options:,
-                    validator_name: 
-                    }
-          ).insert(
+                    validator_name: }
+        ).insert(
           id: "#{validator_session_id}_#{validator_name}",
           validator_session_id:,
           test_suite_id:,
@@ -42,6 +41,7 @@ def find_validator_session_id(test_suite_id, validator_name, suite_options)
         session = self.class::Model
           .find(test_suite_id:, validator_name:, suite_options:)
         return nil if session.nil?
+
         time = Time.now
         session.update(last_accessed: time)
         session[:validator_session_id]

spec/inferno/repositories/validator_sessions_spec.rb

@@ -4,8 +4,10 @@
   let(:test_suite_id) { 'basic_suite' }
   let(:validator_session_id1) { 'basic_validator1' }
   let(:validator_session_id2) { 'basic_validator2' }
-  let(:suite_options1) { [Inferno::DSL::SuiteOption.new(id: :ig_version, value: '1')] }
-  let(:suite_options2) { [Inferno::DSL::SuiteOption.new(id: :ig_version, value: '2')] }
+  let(:validator_session_id3) { 'basic_validator3' }
+  let(:suite_options1) { { ig_version: '1', us_core_version: '4' } }
+  let(:suite_options2) { { ig_version: '2' } }
+  let(:suite_options_alt) { { us_core_version: '4', ig_version: '1' } }
   let(:session1_params) do
     {
       validator_session_id: validator_session_id1,
@@ -24,12 +26,36 @@
   end
   let(:session3_params) do
     {
-      validator_session_id: validator_session_id1,
-      validator_name: 'new_name',
+      validator_session_id: validator_session_id3,
+      validator_name:,
+      test_suite_id:,
+      suite_options: suite_options1
+    }
+  end
+  let(:session_params_alt1) do
+    {
+      validator_session_id: validator_session_id2,
+      validator_name:,
+      test_suite_id:,
+      suite_options: suite_options_alt
+    }
+  end
+  let(:session4_params) do
+    {
+      validator_session_id: validator_session_id2,
+      validator_name: 'alt name',
       test_suite_id:,
       suite_options: suite_options1
     }
   end
+  let(:session5_params) do
+    {
+      validator_session_id: validator_session_id2,
+      validator_name:,
+      test_suite_id: 'alt id',
+      suite_options: suite_options1
+    }
+  end
 
   describe '#create' do
     before do
@@ -58,8 +84,8 @@
         repo.save(session3_params)
         record = repo.db.first
         expect(repo.db.count).to eq(1)
-        expect(record[:validator_session_id]).to eq(validator_session_id1)
-        expect(record[:validator_name]).to eq('new_name')
+        expect(record[:validator_session_id]).to eq(validator_session_id3)
+        expect(record[:validator_name]).to eq('basic_name')
         expect(record[:test_suite_id]).to eq(test_suite_id)
       end
     end
@@ -72,24 +98,59 @@
 
     it 'single record' do
       record = repo.db.first
-      suite_options = JSON.generate(session1_params[:suite_options].map(&:to_hash))
+      # suite_options = JSON.generate(session1_params[:suite_options].map(&:to_hash))
       validator_id = repo.find_validator_session_id(session1_params[:test_suite_id],
-                                                    session1_params[:validator_name], suite_options)
+                                                    session1_params[:validator_name], session1_params[:suite_options])
       expect(record[:validator_session_id]).to eq(validator_id)
     end
 
-    it 'two record, discriminated by suite options' do
+    it 'two records, discriminated by suite options' do
       repo.save(session2_params)
       record = repo.db.first
       record2 = repo.db.all[1]
-      suite_options = JSON.generate(session1_params[:suite_options].map(&:to_hash))
-      suite_options2 = JSON.generate(session2_params[:suite_options].map(&:to_hash))
       validator_id = repo.find_validator_session_id(session1_params[:test_suite_id],
-                                                    session1_params[:validator_name], suite_options)
+                                                    session1_params[:validator_name], session1_params[:suite_options])
       validator_id2 = repo.find_validator_session_id(session2_params[:test_suite_id],
-                                                     session2_params[:validator_name], suite_options2)
+                                                     session2_params[:validator_name], session2_params[:suite_options])
       expect(record[:validator_session_id]).to eq(validator_id)
       expect(record2[:validator_session_id]).to eq(validator_id2)
     end
+
+    it 'updated validator session id, when reverse order suite options cause overwrite' do
+      repo.save(session_params_alt1)
+      record = repo.db.first
+      validator_id = repo.find_validator_session_id(session1_params[:test_suite_id],
+                                                    session1_params[:validator_name], session1_params[:suite_options])
+      validator_id_alt = repo.find_validator_session_id(session_params_alt1[:test_suite_id],
+                                                        session_params_alt1[:validator_name],
+                                                        session_params_alt1[:suite_options])
+      expect(validator_session_id2).to eq(validator_id)
+      expect(validator_session_id2).to eq(validator_id_alt)
+      expect(validator_session_id2).to eq(record[:validator_session_id])
+    end
+
+    it 'two records, discriminate by name' do
+      repo.save(session4_params)
+      record = repo.db.first
+      record4 = repo.db.all[1]
+      validator_id = repo.find_validator_session_id(session1_params[:test_suite_id],
+                                                    session1_params[:validator_name], session1_params[:suite_options])
+      validator_id4 = repo.find_validator_session_id(session4_params[:test_suite_id],
+                                                     session4_params[:validator_name], session4_params[:suite_options])
+      expect(record[:validator_session_id]).to eq(validator_id)
+      expect(record4[:validator_session_id]).to eq(validator_id4)
+    end
+
+    it 'two records, discriminate by suite id' do
+      repo.save(session5_params)
+      record = repo.db.first
+      record5 = repo.db.all[1]
+      validator_id = repo.find_validator_session_id(session1_params[:test_suite_id],
+                                                    session1_params[:validator_name], session1_params[:suite_options])
+      validator_id2 = repo.find_validator_session_id(session5_params[:test_suite_id],
+                                                     session5_params[:validator_name], session5_params[:suite_options])
+      expect(record[:validator_session_id]).to eq(validator_id)
+      expect(record5[:validator_session_id]).to eq(validator_id2)
+    end
   end
 end