Refactor for batch results processing

Author: jazairi

app/models/normalize_primo.rb renamed to app/models/normalize_primo_record.rb

@@ -1,5 +1,5 @@
 # Transforms results from Primo Search API into normalized records
-class NormalizePrimo
+class NormalizePrimoRecord
   def initialize(record, query)
     @record = record
     @query = query

app/models/normalize_primo_results.rb

@@ -0,0 +1,21 @@
+# Batch normalization for Primo Search API results
+class NormalizePrimoResults
+  def initialize(results, query)
+    @results = results
+    @query = query
+  end
+
+  def normalize
+    return [] unless @results&.dig('docs')
+
+    @results['docs'].filter_map do |doc|
+      next unless doc['pnx']
+      
+      NormalizePrimoRecord.new(doc['pnx'], @query).normalize
+    end
+  end
+
+  def total_results
+    @results&.dig('info', 'total') || 0
+  end
+end

test/models/normalize_primo_test.rb renamed to test/models/normalize_primo_record_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class NormalizePrimoTest < ActiveSupport::TestCase
+class NormalizePrimoRecordTest < ActiveSupport::TestCase
   # Hopefully we won't need to create new records that often, but if it comes up, you can query the
   # Primo Search API, grab a result, and use the structure in the `pnx` field as a starting point.
   # From there, it's a manual process of filling in the data you need for the test assertions.
@@ -13,53 +13,53 @@ def minimal_record
   end
 
   test 'normalizes title' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'Testing the Limits of Knowledge', normalized['title']
   end
 
   test 'handles missing title' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_equal 'unknown title', normalized['title']
   end
 
   test 'normalizes creators' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     expected_creators = ['Smith, John A.', 'Jones, Mary B.', 'Brown, Robert C.']
     assert_equal expected_creators.sort, normalized['creators'].map { |c| c[:value] }.sort
   end
 
   test 'handles missing creators' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_empty normalized['creators']
   end
 
   test 'normalizes source' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'Primo', normalized['source']
   end
 
   test 'normalizes year' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal '2023', normalized['year']
   end
 
   test 'handles missing year' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['year']
   end
 
   test 'normalizes format' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'Book', normalized['format']
   end
 
   test 'handles missing format' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['format']
   end
 
   test 'normalizes links' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
 
     # First link should be the record link
     assert_equal 'full record', normalized['links'].first['kind']
@@ -69,144 +69,145 @@ def minimal_record
   end
 
   test 'handles missing links' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_empty normalized['links']
   end
 
   test 'normalizes citation' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'volume 2 issue 3', normalized['citation']
   end
 
   test 'handles missing citation' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['citation']
   end
 
   test 'normalizes container title' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'Journal of Testing', normalized['container']
   end
 
   test 'handles missing container title' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['container']
   end
 
   test 'normalizes identifier' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'MIT01000000001', normalized['identifier']
   end
 
   test 'normalizes summary' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'A comprehensive study of testing methodologies', normalized['summary']
   end
 
   test 'handles missing summary' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['summary']
   end
 
   test 'handles missing identifier' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['identifier']
   end
 
   test 'normalizes numbering' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'volume 2 issue 3', normalized['numbering']
   end
 
   test 'handles missing numbering' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['numbering']
   end
 
   test 'normalizes chapter numbering' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal '2023, pp. 123-145', normalized['chapter_numbering']
   end
 
   test 'handles missing chapter numbering' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['chapter_numbering']
   end
 
   test 'includes FRBRized dedup record link in links when available' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     record_link = normalized['links'].find { |link| link['kind'] == 'full record' }
     assert_not_nil record_link
-    # For frbrized records, should use dedup URL format
+
+    # For FRBRized records, should use dedup URL format
     assert_match %r{/discovery/search\?}, record_link['url']
     assert_match 'frbrgroupid', record_link['url']
   end
 
   test 'generates thumbnail from ISBN' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     expected_url = 'https://syndetics.com/index.php?client=primo&isbn=9781234567890/sc.jpg'
     assert_equal expected_url, normalized['thumbnail']
   end
 
   test 'handles missing ISBN for thumbnail' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['thumbnail']
   end
 
   test 'extracts publisher information' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'MIT Press', normalized['publisher']
   end
 
   test 'handles missing publisher' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['publisher']
   end
 
   test 'returns best location with call number' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     expected_location = ['Hayden Library Stacks', 'QA76.73.R83 2023']
     assert_equal expected_location, normalized['location']
   end
 
   test 'handles missing location' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['location']
   end
 
   test 'extracts subjects' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     expected_subjects = ['Computer Science', 'Software Testing']
     assert_equal expected_subjects, normalized['subjects']
   end
 
   test 'handles missing subjects' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_empty normalized['subjects']
   end
 
   test 'returns availability status' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert_equal 'available', normalized['availability']
   end
 
   test 'handles missing availability' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['availability']
   end
 
   test 'detects other availability when multiple holdings exist' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     assert normalized['other_availability']
   end
 
   test 'handles missing other availability' do
-    normalized = NormalizePrimo.new(minimal_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(minimal_record, 'test').normalize
     assert_nil normalized['other_availability']
   end
 
   test 'uses dedup URL as full record link for frbrized records' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     full_record_link = normalized['links'].find { |link| link['kind'] == 'full record' }
     assert_not_nil full_record_link
 
@@ -220,14 +221,14 @@ def minimal_record
     record_without_frbr = full_record.deep_dup
     record_without_frbr['pnx']['facets']['frbrtype'] = ['3']
 
-    normalized = NormalizePrimo.new(record_without_frbr, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record_without_frbr, 'test').normalize
     full_record_link = normalized['links'].find { |link| link['kind'] == 'full record' }
     assert_not_nil full_record_link
     assert_match %r{/discovery/fulldisplay\?}, full_record_link['url']
   end
 
   test 'includes expected link types when available' do
-    normalized = NormalizePrimo.new(full_record, 'test query').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test query').normalize
     link_kinds = normalized['links'].map { |link| link['kind'] }
 
     assert_includes link_kinds, 'full record'
@@ -239,7 +240,7 @@ def minimal_record
   test 'handles multiple creators with semicolons' do
     record = full_record.deep_dup
     record['pnx']['display']['creator'] = ['Smith, John A.; Doe, Jane B.']
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     creators = normalized['creators'].map { |c| c[:value] }
     assert_includes creators, 'Smith, John A.'
     assert_includes creators, 'Doe, Jane B.'
@@ -248,12 +249,12 @@ def minimal_record
   test 'sanitizes authors by removing $$ codes' do
     record = full_record.deep_dup
     record['pnx']['display']['creator'] = ['Smith, John A.$$QAuthor']
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     assert_equal 'Smith, John A.', normalized['creators'].first[:value]
   end
 
   test 'constructs author search links' do
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     creator_link = normalized['creators'].first[:link]
     assert_match 'discovery/search?query=creator,exact,', creator_link
     assert_match 'Smith%2C%20John%20A.', creator_link
@@ -270,7 +271,7 @@ def minimal_record
     test_cases.each do |input, expected|
       record = full_record.deep_dup
       record['pnx']['display']['type'] = [input]
-      normalized = NormalizePrimo.new(record, 'test').normalize
+      normalized = NormalizePrimoRecord.new(record, 'test').normalize
       assert_equal expected, normalized['format']
     end
   end
@@ -279,20 +280,20 @@ def minimal_record
     record = minimal_record.deep_dup
     record['pnx']['search'] = { 'creationdate' => ['2022'] }
 
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     assert_equal '2022', normalized['year']
   end
 
   test 'handles different citation formats' do
     # Test with just volume
     record = full_record.deep_dup
     record['pnx']['addata'] = { 'volume' => ['5'] }
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     assert_equal 'volume 5', normalized['citation']
 
     # Test with date and pages
     record['pnx']['addata'] = { 'date' => ['2023'], 'pages' => ['10-20'] }
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     assert_equal '2023, pp. 10-20', normalized['citation']
   end
 
@@ -301,7 +302,7 @@ def minimal_record
     record['pnx']['addata']['jtitle'] = ['Journal Title']
     record['pnx']['addata']['btitle'] = ['Book Title']
 
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     assert_equal 'Journal Title', normalized['container']
   end
 
@@ -310,20 +311,20 @@ def minimal_record
     record['pnx']['addata'].delete('jtitle')  # Remove jtitle
     record['pnx']['addata']['btitle'] = ['Book Title Only']
 
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     assert_equal 'Book Title Only', normalized['container']
   end
 
   test 'handles openurl server validation' do
     # Test with matching server
-    normalized = NormalizePrimo.new(full_record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(full_record, 'test').normalize
     openurl_link = normalized['links'].find { |link| link['kind'] == 'openurl' }
     assert_not_nil openurl_link
 
     # Test with mismatched server. Should log warning but still return URL
     record = full_record.deep_dup
     record['delivery']['almaOpenurl'] = 'https://different.server.com/openurl?param=value'
-    normalized = NormalizePrimo.new(record, 'test').normalize
+    normalized = NormalizePrimoRecord.new(record, 'test').normalize
     openurl_link = normalized['links'].find { |link| link['kind'] == 'openurl' }
     assert_not_nil openurl_link
   end