valkyrie 1.1.2 → 1.2.0.rc1

data/lib/valkyrie/persistence/memory/query_service.rb

@@ -6,8 +6,10 @@ module Valkyrie::Persistence::Memory
     # @note Documentation for Query Services in general is maintained here.
     attr_reader :adapter, :query_handlers
     delegate :cache, to: :adapter
+
     # @param adapter [Valkyrie::Persistence::Memory::MetadataAdapter] The adapter which
     #   has the cache to query.
+    # @note Many query service methods are part of Valkyrie's public API, but instantiation itself is not
     def initialize(adapter:)
       @adapter = adapter
       @query_handlers = []

data/lib/valkyrie/persistence/optimistic_lock_token.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Valkyrie::Persistence
+  class OptimisticLockToken
+    attr_reader :adapter_id, :token
+
+    # @param [Valkyrie::ID] adapter_id
+    # @param [String, Integer] token for the adapter
+    def initialize(adapter_id:, token:)
+      @adapter_id = adapter_id
+      @token = token
+    end
+
+    # Serializing lock tokens makes them easy to cast to strings and back.
+    # Primary use case is for embedding one in a form as a hidden field
+    def serialize
+      "lock_token:#{adapter_id}:#{token}"
+    end
+    alias to_s serialize
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      return false unless adapter_id == other.adapter_id
+      token == other.token
+    end
+
+    # Deserializing lock tokens means that we can then use the adapter id and the lock token value
+    def self.deserialize(serialized_token)
+      token_parts = serialized_token.to_s.split(":", 3)
+      adapter_id = token_parts[1]
+      token = token_parts[2]
+      new(adapter_id: Valkyrie::ID.new(adapter_id), token: token)
+    end
+  end
+end

data/lib/valkyrie/persistence/postgres/metadata_adapter.rb

@@ -16,12 +16,21 @@ module Valkyrie::Persistence::Postgres
 
     # @return [Class] {Valkyrie::Persistence::Postgres::QueryService}
     def query_service
-      @query_service ||= Valkyrie::Persistence::Postgres::QueryService.new(adapter: self)
+      @query_service ||= Valkyrie::Persistence::Postgres::QueryService.new(
+        resource_factory: resource_factory
+      )
     end
 
     # @return [Class] {Valkyrie::Persistence::Postgres::ResourceFactory}
     def resource_factory
-      Valkyrie::Persistence::Postgres::ResourceFactory
+      @resource_factory ||= Valkyrie::Persistence::Postgres::ResourceFactory.new(adapter: self)
+    end
+
+    def id
+      @id ||= begin
+        to_hash = "#{resource_factory.orm_class.connection_config['host']}:#{resource_factory.orm_class.connection_config['database']}"
+        Valkyrie::ID.new(Digest::MD5.hexdigest(to_hash))
+      end
     end
   end
 end

data/lib/valkyrie/persistence/postgres/orm_converter.rb

@@ -3,9 +3,10 @@ module Valkyrie::Persistence::Postgres
   # Responsible for converting a
   # {Valkyrie::Persistence::Postgres::ORM::Resource} to a {Valkyrie::Resource}
   class ORMConverter
-    attr_reader :orm_object
-    def initialize(orm_object)
+    attr_reader :orm_object, :resource_factory
+    def initialize(orm_object, resource_factory:)
       @orm_object = orm_object
+      @resource_factory = resource_factory
     end
 
     # Create a new instance of the class described in attributes[:internal_resource]
@@ -17,7 +18,30 @@ module Valkyrie::Persistence::Postgres
     private
 
       def resource
-        resource_klass.new(attributes.merge(new_record: false))
+        resource_klass.new(
+          attributes.merge(
+            new_record: false,
+            Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
+          )
+        )
+      end
+
+      def lock_token
+        return lock_token_warning unless orm_object.class.column_names.include?("lock_version")
+        @lock_token ||=
+          Valkyrie::Persistence::OptimisticLockToken.new(
+            adapter_id: resource_factory.adapter_id,
+            token: orm_object.lock_version
+          )
+      end
+
+      def lock_token_warning
+        return nil unless resource_klass.optimistic_locking_enabled?
+        warn "[MIGRATION REQUIRED] You have loaded a resource from the Postgres adapter with " \
+             "optimistic locking enabled, but the necessary migrations have not been run. \n" \
+             "Please run `bin/rails valkyrie_engine:install:migrations && bin/rails db:migrate` " \
+             "to enable this feature for Postgres."
+        nil
       end
 
       def resource_klass
@@ -117,8 +141,14 @@ module Valkyrie::Persistence::Postgres
           end
 
           def result
-            value.map do |value|
-              calling_mapper.for(value).result
+            # Cast single-valued arrays to the first value, let Types::Set and
+            # Types::Array handle converting it back.
+            if value.length == 1
+              calling_mapper.for(value.first).result
+            else
+              value.map do |value|
+                calling_mapper.for(value).result
+              end
             end
           end
         end

data/lib/valkyrie/persistence/postgres/persister.rb

@@ -6,23 +6,30 @@ module Valkyrie::Persistence::Postgres
   class Persister
     attr_reader :adapter
     delegate :resource_factory, to: :adapter
+
+    # @note (see Valkyrie::Persistence::Memory::Persister#initialize)
     def initialize(adapter:)
       @adapter = adapter
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#save)
     def save(resource:)
-      ensure_multiple_values!(resource)
       orm_object = resource_factory.from_resource(resource: resource)
       orm_object.save!
       resource_factory.to_resource(object: orm_object)
+    rescue ActiveRecord::StaleObjectError
+      raise Valkyrie::Persistence::StaleObjectError, resource.id.to_s
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#save_all)
     def save_all(resources:)
-      resources.map do |resource|
-        save(resource: resource)
+      resource_factory.orm_class.transaction do
+        resources.map do |resource|
+          save(resource: resource)
+        end
       end
+    rescue Valkyrie::Persistence::StaleObjectError
+      raise Valkyrie::Persistence::StaleObjectError
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#delete)
@@ -36,14 +43,5 @@ module Valkyrie::Persistence::Postgres
     def wipe!
       resource_factory.orm_class.delete_all
     end
-
-    private
-
-      def ensure_multiple_values!(resource)
-        bad_keys = resource.attributes.except(:internal_resource, :created_at, :updated_at, :new_record, :id).select do |_k, v|
-          !v.nil? && !v.is_a?(Array)
-        end
-        raise ::Valkyrie::Persistence::UnsupportedDatatype, "#{resource}: #{bad_keys.keys} have non-array values, which can not be persisted by Valkyrie. Cast to arrays." unless bad_keys.keys.empty?
-      end
   end
 end

data/lib/valkyrie/persistence/postgres/query_service.rb

@@ -7,11 +7,12 @@ module Valkyrie::Persistence::Postgres
   #
   # @see Valkyrie::Persistence::Postgres::MetadataAdapter
   class QueryService
-    attr_reader :adapter
-    delegate :resource_factory, to: :adapter
+    attr_reader :resource_factory
     delegate :orm_class, to: :resource_factory
-    def initialize(adapter:)
-      @adapter = adapter
+
+    # @note (see Valkyrie::Persistence::Memory::QueryService#initialize)
+    def initialize(resource_factory:)
+      @resource_factory = resource_factory
     end
 
     # (see Valkyrie::Persistence::Memory::QueryService#find_all)

data/lib/valkyrie/persistence/postgres/resource_converter.rb

@@ -13,8 +13,28 @@ module Valkyrie::Persistence::Postgres
     def convert!
       orm_class.find_or_initialize_by(id: resource.id && resource.id.to_s).tap do |orm_object|
         orm_object.internal_resource = resource.internal_resource
-        orm_object.metadata.merge!(resource.attributes.except(:id, :internal_resource, :created_at, :updated_at))
+        process_lock_token(orm_object)
+        orm_object.metadata.merge!(attributes)
       end
     end
+
+    def process_lock_token(orm_object)
+      return unless resource.respond_to?(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK)
+      postgres_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find do |token|
+        token.adapter_id == resource_factory.adapter_id
+      end
+      return unless postgres_token
+      orm_object.lock_version = postgres_token.token
+    end
+
+    # Convert attributes to all be arrays to better enable querying and
+    # "changing of minds" later on.
+    def attributes
+      Hash[
+        resource.attributes.except(:id, :internal_resource, :created_at, :updated_at).compact.map do |k, v|
+          [k, Array.wrap(v)]
+        end
+      ]
+    end
   end
 end

data/lib/valkyrie/persistence/postgres/resource_factory.rb

@@ -5,26 +5,30 @@ module Valkyrie::Persistence::Postgres
   # Provides access to generic methods for converting to/from
   # {Valkyrie::Resource} and {Valkyrie::Persistence::Postgres::ORM::Resource}.
   class ResourceFactory
-    class << self
-      # @param object [Valkyrie::Persistence::Postgres::ORM::Resource] AR
-      #   record to be converted.
-      # @return [Valkyrie::Resource] Model representation of the AR record.
-      def to_resource(object:)
-        ::Valkyrie::Persistence::Postgres::ORMConverter.new(object).convert!
-      end
+    attr_reader :adapter
+    delegate :id, to: :adapter, prefix: true
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    # @param object [Valkyrie::Persistence::Postgres::ORM::Resource] AR
+    #   record to be converted.
+    # @return [Valkyrie::Resource] Model representation of the AR record.
+    def to_resource(object:)
+      ::Valkyrie::Persistence::Postgres::ORMConverter.new(object, resource_factory: self).convert!
+    end
 
-      # @param resource [Valkyrie::Resource] Model to be converted to ActiveRecord.
-      # @return [Valkyrie::Persistence::Postgres::ORM::Resource] ActiveRecord
-      #   resource for the Valkyrie resource.
-      def from_resource(resource:)
-        ::Valkyrie::Persistence::Postgres::ResourceConverter.new(resource, resource_factory: self).convert!
-      end
+    # @param resource [Valkyrie::Resource] Model to be converted to ActiveRecord.
+    # @return [Valkyrie::Persistence::Postgres::ORM::Resource] ActiveRecord
+    #   resource for the Valkyrie resource.
+    def from_resource(resource:)
+      ::Valkyrie::Persistence::Postgres::ResourceConverter.new(resource, resource_factory: self).convert!
+    end
 
-      # Accessor for the ActiveRecord class which all Postgres resources are an
-      # instance of.
-      def orm_class
-        ::Valkyrie::Persistence::Postgres::ORM::Resource
-      end
+    # Accessor for the ActiveRecord class which all Postgres resources are an
+    # instance of.
+    def orm_class
+      ::Valkyrie::Persistence::Postgres::ORM::Resource
     end
   end
 end

data/lib/valkyrie/persistence/solr/metadata_adapter.rb

@@ -50,10 +50,14 @@ module Valkyrie::Persistence::Solr
       )
     end
 
+    def id
+      @id ||= Valkyrie::ID.new(Digest::MD5.hexdigest(connection.base_uri.to_s))
+    end
+
     # @return [Valkyrie::Persistence::Solr::ResourceFactory] A resource factory
     #   to convert a resource to a solr document and back.
     def resource_factory
-      Valkyrie::Persistence::Solr::ResourceFactory.new(resource_indexer: resource_indexer)
+      Valkyrie::Persistence::Solr::ResourceFactory.new(resource_indexer: resource_indexer, adapter: self)
     end
 
     class NullIndexer

data/lib/valkyrie/persistence/solr/model_converter.rb

@@ -40,13 +40,43 @@ module Valkyrie::Persistence::Solr
         "id": id,
         "join_id_ssi": "id-#{id}",
         "created_at_dtsi": created_at
-      }.merge(attribute_hash)
+      }.merge(add_single_values(attribute_hash)).merge(lock_hash)
     end
 
     private
 
+      def add_single_values(attribute_hash)
+        attribute_hash.select do |k, v|
+          field = k.to_s.split("_").last
+          property = k.to_s.gsub("_#{field}", "")
+          next true if multivalued?(field)
+          next false if property == "internal_resource"
+          next false if v.length > 1
+          true
+        end
+      end
+
+      def multivalued?(field)
+        field.end_with?('m', 'mv')
+      end
+
+      def lock_hash
+        return {} unless resource.optimistic_locking_enabled? && lock_token.present?
+        { _version_: lock_token }
+      end
+
+      def lock_token
+        @lock_token ||= begin
+          found_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+                        .find { |token| token.adapter_id == resource_factory.adapter_id }
+          return if found_token.nil?
+          found_token.token
+        end
+      end
+
       def attribute_hash
         properties.each_with_object({}) do |property, hsh|
+          next if property == Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK
           attr = resource_attributes[property]
           mapper_val = SolrMapperValue.for(Property.new(property, attr)).result
           unless mapper_val.respond_to?(:apply_to)
@@ -272,7 +302,7 @@ module Valkyrie::Persistence::Solr
           if value.value.length > 1000
             [:tsim]
           else
-            [:tsim, :ssim, :tesim]
+            [:tsim, :ssim, :tesim, :tsi, :ssi, :tesi]
           end
         end
       end

data/lib/valkyrie/persistence/solr/orm_converter.rb

@@ -2,9 +2,10 @@
 module Valkyrie::Persistence::Solr
   # Responsible for converting hashes from Solr into a {Valkyrie::Resource}
   class ORMConverter
-    attr_reader :solr_document
-    def initialize(solr_document)
+    attr_reader :solr_document, :resource_factory
+    def initialize(solr_document, resource_factory:)
       @solr_document = solr_document
+      @resource_factory = resource_factory
     end
 
     def convert!
@@ -24,7 +25,11 @@ module Valkyrie::Persistence::Solr
     end
 
     def attributes
-      attribute_hash.merge("id" => id, internal_resource: internal_resource, created_at: created_at, updated_at: updated_at)
+      attribute_hash.merge("id" => id,
+                           internal_resource: internal_resource,
+                           created_at: created_at,
+                           updated_at: updated_at,
+                           Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => token)
     end
 
     def created_at
@@ -35,6 +40,14 @@ module Valkyrie::Persistence::Solr
       DateTime.parse(solr_document["timestamp"] || solr_document.fetch("created_at_dtsi").to_s).utc
     end
 
+    def token
+      Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: resource_factory.adapter_id, token: version)
+    end
+
+    def version
+      solr_document.fetch('_version_', nil)
+    end
+
     def id
       solr_document.fetch('id').sub(/^id-/, '')
     end
@@ -122,8 +135,12 @@ module Valkyrie::Persistence::Solr
       end
 
       def result
-        value.map do |element|
-          calling_mapper.for(element).result
+        if value.length == 1
+          calling_mapper.for(value.first).result
+        else
+          value.map do |element|
+            calling_mapper.for(element).result
+          end
         end
       end
     end

data/lib/valkyrie/persistence/solr/persister.rb

@@ -7,8 +7,10 @@ module Valkyrie::Persistence::Solr
   class Persister
     attr_reader :adapter
     delegate :connection, :resource_factory, to: :adapter
+
     # @param adapter [Valkyrie::Persistence::Solr::MetadataAdapter] The adapter with the
     #   configured solr connection.
+    # @note (see Valkyrie::Persistence::Memory::Persister#initialize)
     def initialize(adapter:)
       @adapter = adapter
     end

data/lib/valkyrie/persistence/solr/query_service.rb

@@ -4,8 +4,10 @@ module Valkyrie::Persistence::Solr
   # Query Service for Solr MetadataAdapter.
   class QueryService
     attr_reader :connection, :resource_factory
+
     # @param connection [RSolr::Client]
     # @param resource_factory [Valkyrie::Persistence::Solr::ResourceFactory]
+    # @note (see Valkyrie::Persistence::Memory::QueryService#initialize)
     def initialize(connection:, resource_factory:)
       @connection = connection
       @resource_factory = resource_factory

data/lib/valkyrie/persistence/solr/repository.rb

@@ -3,7 +3,7 @@ module Valkyrie::Persistence::Solr
   # Responsible for handling the logic for persisting or deleting multiple
   # objects into or out of solr.
   class Repository
-    COMMIT_PARAMS = { softCommit: true }.freeze
+    COMMIT_PARAMS = { softCommit: true, versions: true }.freeze
 
     attr_reader :resources, :connection, :resource_factory
     def initialize(resources:, connection:, resource_factory:)
@@ -15,15 +15,30 @@ module Valkyrie::Persistence::Solr
     def persist
       documents = resources.map do |resource|
         generate_id(resource) if resource.id.blank?
-        ensure_multiple_values!(resource)
         solr_document(resource)
       end
-      connection.add documents, params: COMMIT_PARAMS
+      results = add_documents(documents)
+      versions = results["adds"]&.each_slice(2)&.to_h
       documents.map do |document|
+        document["_version_"] = versions.fetch(document[:id])
         resource_factory.to_resource(object: document.stringify_keys)
       end
     end
 
+    # @param [Array<Hash>] array of Solr documents
+    # @return [RSolr::HashWithResponse]
+    # rubocop:disable Style/IfUnlessModifier
+    def add_documents(documents)
+      connection.add documents, params: COMMIT_PARAMS
+    rescue RSolr::Error::Http => exception
+      # Error 409 conflict is returned when versions do not match
+      if exception.response[:status] == 409
+        handle_409
+      end
+      raise exception
+    end
+    # rubocop:enable Style/IfUnlessModifier
+
     def delete
       connection.delete_by_id resources.map { |resource| resource.id.to_s }, params: COMMIT_PARAMS
       resources
@@ -38,11 +53,9 @@ module Valkyrie::Persistence::Solr
       resource.id = SecureRandom.uuid
     end
 
-    def ensure_multiple_values!(resource)
-      bad_keys = resource.attributes.except(:internal_resource, :alternate_ids, :created_at, :updated_at, :new_record, :id).select do |_k, v|
-        !v.nil? && !v.is_a?(Array)
-      end
-      raise ::Valkyrie::Persistence::UnsupportedDatatype, "#{resource}: #{bad_keys.keys} have non-array values, which can not be persisted by Valkyrie. Cast to arrays." unless bad_keys.keys.empty?
+    def handle_409
+      raise Valkyrie::Persistence::StaleObjectError if resources.count > 1
+      raise Valkyrie::Persistence::StaleObjectError, resources.first.id.to_s
     end
   end
 end

data/lib/valkyrie/persistence/solr/resource_factory.rb

@@ -5,16 +5,19 @@ module Valkyrie::Persistence::Solr
   class ResourceFactory
     require 'valkyrie/persistence/solr/orm_converter'
     require 'valkyrie/persistence/solr/model_converter'
-    attr_reader :resource_indexer
-    def initialize(resource_indexer:)
+    attr_reader :resource_indexer, :adapter
+    delegate :id, to: :adapter, prefix: true
+
+    def initialize(resource_indexer:, adapter:)
       @resource_indexer = resource_indexer
+      @adapter = adapter
     end
 
     # @param object [Hash] The solr document in a hash to convert to a
     #   resource.
     # @return [Valkyrie::Resource]
     def to_resource(object:)
-      ORMConverter.new(object).convert!
+      ORMConverter.new(object, resource_factory: self).convert!
     end
 
     # @param resource [Valkyrie::Resource] The resource to convert to a solr hash.

data/lib/valkyrie/persistence.rb

@@ -25,17 +25,24 @@ module Valkyrie
   # @see lib/valkyrie/specs/shared_specs/persister.rb
   #
   module Persistence
+    require 'valkyrie/persistence/optimistic_lock_token'
     require 'valkyrie/persistence/custom_query_container'
     require 'valkyrie/persistence/memory'
-    require 'valkyrie/persistence/postgres'
-    require 'valkyrie/persistence/solr'
-    require 'valkyrie/persistence/fedora'
     require 'valkyrie/persistence/composite_persister'
     require 'valkyrie/persistence/delete_tracking_buffer'
     require 'valkyrie/persistence/buffered_persister'
+    autoload :Postgres, 'valkyrie/persistence/postgres'
+    autoload :Solr, 'valkyrie/persistence/solr'
+    autoload :Fedora, 'valkyrie/persistence/fedora'
     class ObjectNotFoundError < StandardError
     end
     class UnsupportedDatatype < StandardError
     end
+    class StaleObjectError < StandardError
+    end
+
+    module Attributes
+      OPTIMISTIC_LOCK = :optimistic_lock_token
+    end
   end
 end

data/lib/valkyrie/resource/access_controls.rb

@@ -6,7 +6,6 @@ module Valkyrie
     # @example
     #     class CustomResource < Valkyrie::Resource
     #       include Valkyrie::Resource::AccessControls
-    #       attribute :id, Valkyrie::Types::ID.optional
     #       attribute :title
     #       attribute :member_ids
     #       attribute :nested_resource

data/lib/valkyrie/resource.rb

@@ -4,7 +4,6 @@ module Valkyrie
   # The base resource class for all Valkyrie metadata objects.
   # @example Define a resource
   #   class Book < Valkyrie::Resource
-  #     attribute :id, Valkyrie::Types::ID.optional
   #     attribute :member_ids, Valkyrie::Types::Array
   #     attribute :author
   #   end
@@ -23,10 +22,11 @@ module Valkyrie
     def self.inherited(subclass)
       super(subclass)
       subclass.constructor_type :schema
-      subclass.attribute :internal_resource, Valkyrie::Types::Any.default(subclass.to_s)
-      subclass.attribute :created_at, Valkyrie::Types::DateTime.optional
-      subclass.attribute :updated_at, Valkyrie::Types::DateTime.optional
-      subclass.attribute :new_record, Types::Bool.default(true)
+      subclass.attribute :id, Valkyrie::Types::ID.optional, internal: true
+      subclass.attribute :internal_resource, Valkyrie::Types::Any.default(subclass.to_s), internal: true
+      subclass.attribute :created_at, Valkyrie::Types::DateTime.optional, internal: true
+      subclass.attribute :updated_at, Valkyrie::Types::DateTime.optional, internal: true
+      subclass.attribute :new_record, Types::Bool.default(true), internal: true
     end
 
     # @return [Array<Symbol>] Array of fields defined for this class.
@@ -34,16 +34,27 @@ module Valkyrie
       schema.keys.without(:new_record)
     end
 
-    # Define an attribute.
+    # Define an attribute. Attributes are used to describe resources.
     # @param name [Symbol]
     # @param type [Dry::Types::Type]
     # @note Overridden from {Dry::Struct} to make the default type
     #   {Valkyrie::Types::Set}
-    def self.attribute(name, type = Valkyrie::Types::Set.optional)
+    # @todo Remove ability to override built in attributes.
+    def self.attribute(name, type = Valkyrie::Types::Set.optional, internal: false)
+      if reserved_attributes.include?(name.to_sym) && schema[name] && !internal
+        warn "#{name} is a reserved attribute in Valkyrie::Resource and defined by it. You can remove your definition of `attribute :#{name}`. " \
+             "For now your version will be used, but in the next major version the type will be overridden. " \
+             "Called from #{Gem.location_of_caller.join(':')}"
+        schema.delete(name)
+      end
       define_method("#{name}=") do |value|
         instance_variable_set("@#{name}", self.class.schema[name].call(value))
       end
-      super
+      super(name, type)
+    end
+
+    def self.reserved_attributes
+      [:id, :internal_resource, :created_at, :updated_at, :new_record]
     end
 
     # @return [ActiveModel::Name]
@@ -62,6 +73,18 @@ module Valkyrie
       @_human_readable_type = val
     end
 
+    def self.enable_optimistic_locking
+      attribute(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK, Valkyrie::Types::Set.of(Valkyrie::Types::OptimisticLockToken))
+    end
+
+    def self.optimistic_locking_enabled?
+      schema.key?(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK)
+    end
+
+    def optimistic_locking_enabled?
+      self.class.optimistic_locking_enabled?
+    end
+
     # @return [Hash] Hash of attributes
     def attributes
       to_h

data/lib/valkyrie/specs/shared_specs/change_set_persister.rb

@@ -4,7 +4,6 @@ RSpec.shared_examples 'a Valkyrie::ChangeSetPersister' do |*_flags|
     raise 'adapter must be set with `let(:change_set_persister)`' unless defined? change_set_persister
     class CustomResource < Valkyrie::Resource
       include Valkyrie::Resource::AccessControls
-      attribute :id, Valkyrie::Types::ID.optional
       attribute :title
       attribute :member_ids
       attribute :nested_resource

data/lib/valkyrie/specs/shared_specs/metadata_adapter.rb

@@ -7,7 +7,16 @@ RSpec.shared_examples 'a Valkyrie::MetadataAdapter' do |passed_adapter|
   subject { passed_adapter || adapter }
   it { is_expected.to respond_to(:persister).with(0).arguments }
   it { is_expected.to respond_to(:query_service).with(0).arguments }
+  it { is_expected.to respond_to(:id).with(0).arguments }
   it "caches query_service so it can register custom queries" do
     expect(subject.query_service.custom_queries.query_handlers.object_id).to eq subject.query_service.custom_queries.query_handlers.object_id
   end
+
+  describe "#id" do
+    it "is a valid string representation of an MD5 hash" do
+      expect(adapter.id).to be_a Valkyrie::ID
+      expect(adapter.id.to_s.length).to eq 32
+      expect(adapter.id.to_s).to match(/^[a-f,0-9]+$/)
+    end
+  end
 end