Module: Bulkrax::EntrySpecHelper

Defined in:
lib/bulkrax/entry_spec_helper.rb

Overview

The purpose of this module is to provide some testing facilities for those that include the Bulkrax gem in their application.

This module came about through a desire to expose a quick means of vetting the accuracy of the different parsers.

Constant Summary collapse

ENTRY_TYPE_TO_METHOD_NAME_MAP = 
{
  entry: :entry_class,
  collection: :collection_entry_class,
  file_set: :file_set_entry_class
}.freeze
DEFAULT_ENTRY_CLASS_TO_SYMBOL_MAP = 
{
  'Bulkrax::OaiEntry' => :oai,
  'Bulkrax::XmlEntry' => :xml,
  'Bulkrax::CsvEntry' => :csv
}.freeze

Class Method Summary collapse

Class Method Details

.build_csv_entry_for(importer:, data:, identifier:, entry_class:, **_options) ⇒ Bulkrax::CsvEntry

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Note:

As a foible of this implementation, you’ll need to include along a CSV to establish the columns that you’ll parse (e.g. the first row



134
135
136
137
138
139
140
 
# File 'lib/bulkrax/entry_spec_helper.rb', line 134

def self.build_csv_entry_for(importer:, data:, identifier:, entry_class:, **_options)
  entry_class.new(
    importerexporter: importer,
    identifier: identifier,
    raw_metadata: data
  )
end

.build_oai_entry_for(importer:, data:, identifier:, entry_class:, **options) ⇒ Bulkrax::OaiEntry

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/bulkrax/entry_spec_helper.rb', line 148

def self.build_oai_entry_for(importer:, data:, identifier:, entry_class:, **options)
  # The raw record assumes we take the XML data, parse it and then send that to the
  # OAI::GetRecordResponse object.
  doc = XML::Parser.string(data)
  raw_record = OAI::GetRecordResponse.new(doc.parse)

  raw_metadata = {
    importer.parser.source_identifier.to_s => identifier,
    "data" => data,
    "collections" => options.fetch(:raw_metadata_collections, []),
    "children" => options.fetch(:raw_metadata_children, [])
  }

  entry_class.new(
    raw_record: raw_record,
    importerexporter: importer,
    identifier: identifier,
    raw_metadata: raw_metadata
  )
end

.build_xml_entry_for(importer:, data:, identifier:, entry_class:, **options) ⇒ Bulkrax::XmlEntry

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/bulkrax/entry_spec_helper.rb', line 175

def self.build_xml_entry_for(importer:, data:, identifier:, entry_class:, **options)
  raw_metadata = {
    importer.parser.source_identifier.to_s => identifier,
    "data" => data,
    "collections" => options.fetch(:raw_metadata_collections, []),
    "children" => options.fetch(:raw_metadata_children, [])
  }

  entry_class.new(
    importerexporter: importer,
    identifier: identifier,
    raw_metadata: raw_metadata
  )
end

.entry_class_to_symbol_map ⇒ Object

Present implementations of entry classes tend to inherit from the below listed class names. We’re not looking to register all descendents of the Bulkrax::Entry class, but instead find the ancestor where there is significant deviation.



93
94
95
 
# File 'lib/bulkrax/entry_spec_helper.rb', line 93

def self.entry_class_to_symbol_map
  @entry_class_to_symbol_map || DEFAULT_ENTRY_CLASS_TO_SYMBOL_MAP
end

.entry_class_to_symbol_map=(value) ⇒ Object 



97
98
99
 
# File 'lib/bulkrax/entry_spec_helper.rb', line 97

def self.entry_class_to_symbol_map=(value)
  @entry_class_to_symbol_map = value
end

.entry_for(data:, identifier:, parser_class_name:, type: :entry, **options) ⇒ Bulkrax::Entry

The purpose of this method is encapsulate the logic of creating the appropriate Bulkrax::Entry object based on the given data, identifier, and parser_class_name.

From that entry, you should be able to test how Bulkrax::Entry#build_metadata populates the Bulkrax::Entry#parsed_metadata variable. Other uses may emerge.

Since:

  • v5.0.1



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/bulkrax/entry_spec_helper.rb', line 35

def self.entry_for(data:, identifier:, parser_class_name:, type: :entry, **options)
  importer = importer_for(parser_class_name: parser_class_name, **options)
  entry_type_method_name = ENTRY_TYPE_TO_METHOD_NAME_MAP.fetch(type)
  entry_class = importer.parser.public_send(entry_type_method_name)

  # Using an instance of the entry_class to dispatch to different
  entry_for_dispatch = entry_class.new

  # Using the {is_a?} test we get the benefit of inspecting an object's inheritance path
  # (e.g. ancestry).  The logic, as implemented, also provides a mechanism for folks in their
  # applications to add a {class_name_entry_for}; something that I suspect isn't likely
  # but given the wide variety of underlying needs I could see happening and I want to encourage
  # patterned thinking to fold that different build method into this structure.
  key = entry_class_to_symbol_map.keys.detect { |class_name| entry_for_dispatch.is_a?(class_name.constantize) }

  # Yes, we'll raise an error if we didn't find a corresponding key.  And that's okay.
  symbol = entry_class_to_symbol_map.fetch(key)

  send("build_#{symbol}_entry_for",
       importer: importer,
       identifier: identifier,
       entry_class: entry_class,
       data: data,
       **options)
end

.exporter_for(parser_class_name:, parser_fields: {}, **options) ⇒ Bulkrax::Exporter 



67
68
69
70
71
72
73
74
75
76
 
# File 'lib/bulkrax/entry_spec_helper.rb', line 67

def self.exporter_for(parser_class_name:, parser_fields: {}, **options)
  Bulkrax::Exporter.new(
    name: options.fetch(:exporter_name, "Test importer for identifier"),
    user: options.fetch(:exporter_user, User.new(email: "[email protected]")),
    limit: options.fetch(:exporter_limit, 1),
    parser_klass: parser_class_name,
    field_mapping: options.fetch(:exporter_field_mappings) { Bulkrax.field_mappings.fetch(parser_class_name) },
    parser_fields: parser_fields
  )
end