cocina-models 0.67.0 → 0.69.0

data/lib/cocina/models.rb

@@ -22,6 +22,7 @@ class CocinaModelsInflector < Zeitwerk::Inflector
     'dro_access' => 'DROAccess',
     'dro_structural' => 'DROStructural',
     'request_dro_structural' => 'RequestDROStructural',
+    'rspec' => 'RSpec',
     'version' => 'VERSION'
   }.freeze
 
@@ -42,7 +43,7 @@ module Cocina
     # Raised when the type attribute is not valid.
     class UnknownTypeError < Error; end
 
-    # Raised when an error occurs validating against openapi.
+    # Raised when the type attribute is missing or an error occurs validating against openapi.
     class ValidationError < Error; end
 
     # Base class for Cocina Structs
@@ -56,14 +57,25 @@ module Cocina
       include Dry.Types()
     end
 
+    ##
+    # Alias for `Cocina::Models::Vocabulary.create`.
+    #
+    # @param (see Cocina::Models::Vocabulary#initialize)
+    # @return [Class]
+    # rubocop:disable Naming/MethodName
+    def self.Vocabulary(uri)
+      Vocabulary.create(uri)
+    end
+    # rubocop:enable Naming/MethodName
+
     # @param [Hash] dyn a ruby hash representation of the JSON serialization of a collection or DRO
     # @param [boolean] validate
     # @return [DRO,Collection,AdminPolicy]
     # @raises [UnknownTypeError] if a valid type is not found in the data
-    # @raises [KeyError] if a type field cannot be found in the data
+    # @raises [ValidationError] if a type field cannot be found in the data
     # @raises [ValidationError] if hash representation fails openapi validation
     def self.build(dyn, validate: true)
-      clazz = case dyn.fetch('type')
+      clazz = case type_for(dyn)
               when *DRO::TYPES
                 DRO
               when *Collection::TYPES
@@ -71,7 +83,7 @@ module Cocina
               when *AdminPolicy::TYPES
                 AdminPolicy
               else
-                raise UnknownTypeError, "Unknown type: '#{dyn.fetch('type')}'"
+                raise UnknownTypeError, "Unknown type: '#{dyn.with_indifferent_access.fetch('type')}'"
               end
       clazz.new(dyn, false, validate)
     end
@@ -80,10 +92,10 @@ module Cocina
     # @param [boolean] validate
     # @return [RequestDRO,RequestCollection,RequestAdminPolicy]
     # @raises [UnknownTypeError] if a valid type is not found in the data
-    # @raises [KeyError] if a type field cannot be found in the data
+    # @raises [ValidationError] if a type field cannot be found in the data
     # @raises [ValidationError] if hash representation fails openapi validation
     def self.build_request(dyn, validate: true)
-      clazz = case dyn.fetch('type')
+      clazz = case type_for(dyn)
               when *DRO::TYPES
                 RequestDRO
               when *Collection::TYPES
@@ -91,9 +103,16 @@ module Cocina
               when *AdminPolicy::TYPES
                 RequestAdminPolicy
               else
-                raise UnknownTypeError, "Unknown type: '#{dyn.fetch('type')}'"
+                raise UnknownTypeError, "Unknown type: '#{dyn.with_indifferent_access.fetch('type')}'"
               end
       clazz.new(dyn, false, validate)
     end
+
+    def self.type_for(dyn)
+      dyn.with_indifferent_access.fetch('type')
+    rescue KeyError
+      raise ValidationError, 'Type field not found'
+    end
+    private_class_method :type_for
   end
 end

data/lib/cocina/rspec/matchers.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Provides RSpec matchers for Cocina models
+module Cocina
+  module RSpec
+    # Cocina-related RSpec matchers
+    module Matchers
+      extend ::RSpec::Matchers::DSL
+
+      # NOTE: each k/v pair in the hash passed to this matcher will need to be present in actual
+      matcher :cocina_object_with do |**kwargs|
+        kwargs.each do |cocina_section, expected|
+          match do |actual|
+            expected.all? do |expected_key, expected_value|
+              # NOTE: there's no better method on Hash that I could find for this.
+              #        #include? and #member? only check keys, not k/v pairs
+              actual.public_send(cocina_section).to_h.any? do |actual_key, actual_value|
+                if expected_value.is_a?(Hash) && actual_value.is_a?(Hash)
+                  expected_value.all? { |pair| actual_value.to_a.include?(pair) }
+                else
+                  actual_key == expected_key && actual_value == expected_value
+                end
+              end
+            end
+          end
+        end
+      end
+
+      alias_matcher :match_cocina_object_with, :cocina_object_with
+
+      # The `equal_cocina_model` matcher compares a JSON string as actual value
+      # against a Cocina model coerced to JSON as expected value. We want to compare
+      # these as JSON rather than as hashes, else we'll have to start
+      # deep-converting some values within the hashes, thinking of date/time values
+      # in particular. This matching behavior continues what dor-services-app was
+      # already doing before this custom matcher was written.
+      #
+      # Note, though, that when actual and expected values do *not* match, we coerce
+      # both values to hashes to allow the `super_diff` gem to highlight the areas
+      # that differ. This is easier to scan than two giant JSON strings.
+      matcher :equal_cocina_model do |expected|
+        match do |actual|
+          Cocina::Models.build(JSON.parse(actual)).to_json == expected.to_json
+        rescue NoMethodError
+          warn "Could not match cocina models because expected is not a valid JSON string: #{expected}"
+          false
+        end
+
+        failure_message do |actual|
+          SuperDiff::EqualityMatchers::Hash.new(
+            expected: expected.to_h.deep_symbolize_keys,
+            actual: JSON.parse(actual, symbolize_names: true)
+          ).fail
+        rescue StandardError => e
+          "ERROR in CocinaMatchers: #{e}"
+        end
+      end
+
+      matcher :cocina_object_with_types do |expected|
+        match do |actual|
+          return false if expected[:without_order] && !match_no_orders?
+
+          if expected[:content_type] && expected[:resource_types]
+            match_cocina_type?(actual, expected) && match_contained_cocina_types?(actual, expected)
+          elsif expected[:content_type] && expected[:viewing_direction]
+            match_cocina_type?(actual, expected) && match_cocina_viewing_direction?(actual, expected)
+          elsif expected[:content_type]
+            match_cocina_type?(actual, expected)
+          elsif expected[:resource_types]
+            match_contained_cocina_types?(actual, expected)
+          else
+            raise ArgumentError, 'must provide content_type and/or resource_types keyword args'
+          end
+        end
+
+        def match_no_orders?
+          actual.structural.hasMemberOrders.blank?
+        end
+
+        def match_cocina_type?(actual, expected)
+          actual.type == expected[:content_type]
+        end
+
+        def match_cocina_viewing_direction?(actual, expected)
+          actual.structural.hasMemberOrders.map(&:viewingDirection).all? do |viewing_direction|
+            viewing_direction == expected[:viewing_direction]
+          end
+        end
+
+        def match_contained_cocina_types?(actual, expected)
+          Array(actual.structural.contains).map(&:type).all? { |type| type.in?(expected[:resource_types]) }
+        end
+      end
+
+      matcher :cocina_admin_policy_with_registration_collections do |expected|
+        match do |actual|
+          actual.type == Cocina::Models::ObjectType.admin_policy &&
+            expected.all? { |collection_id| collection_id.in?(actual.administrative.collectionsForRegistration) }
+        end
+      end
+    end
+  end
+end

data/lib/cocina/rspec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+require 'rspec/matchers'
+if defined?(Rails)
+  require 'super_diff/rspec-rails'
+else
+  require 'super_diff/rspec'
+end
+require 'cocina/rspec/matchers'
+
+RSpec.configure do |config|
+  config.include Cocina::RSpec::Matchers
+end