valkyrie 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2f8a25a4907164098b326abda6efecd2e8312c44
-  data.tar.gz: 527a724741b2be29ae313179b0d9d44acee1588c
+SHA256:
+  metadata.gz: f665fe8da6906565cf3773a62c028e0528d62074c50fd109bbd6dd438196f4fb
+  data.tar.gz: f0db72ec609cfa390a1cdaef4e03d8dd0834c25e51cbac8845a061dda7458281
 SHA512:
-  metadata.gz: 3e5d8ab1685035c009f3aece230c97189f51c5382e33bd45677afaf8464da3893fab299ea3c3cd7a35d71943db4c292379ac9531dbbf6f33df4c7e51bf6ddb9e
-  data.tar.gz: 532b506eed5ffd247c6dca88d01893190a56f5dcdd88ad6d38775ff93de8e2aa647d3397006d9aab7be4bba610fafae5523707c3135218d8b0a312fdbe236d56
+  metadata.gz: 797105358eece5769534d6c62cfd6599d1d3ceeb66e36b0a9ded3750f266fae69d57ec0e8929cc33b579066e7ecad862a249510c1fac551093723cfdbe66a711
+  data.tar.gz: 96ac6d47efa9dc4d00235ac4e0ffb00a63141f13ab89bc622bc0a7bd6161200df7622e6e03419840b3ae003a3f53b045ca8e33737c72ddd00e419e66927aafc0

data/.rubocop_todo.yml

@@ -1,6 +1,7 @@
 Metrics/ClassLength:
   Exclude:
     - 'lib/valkyrie/persistence/fedora/persister.rb'
+    - 'lib/valkyrie/persistence/fedora/query_service.rb'
     - 'lib/valkyrie/persistence/postgres/query_service.rb'
 
 Metrics/MethodLength:

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# v1.2.2 2018-10-05
+
+## Changes since last release
+
+* Fix consistency in adapter's responses to queries.
+  [ojlyytinen](https://github.com/ojlyytinen)
+
 # v1.2.1 2018-09-25
 
 ## Changes since last release

data/lib/valkyrie.rb

@@ -34,10 +34,20 @@ module Valkyrie
   require 'valkyrie/engine' if defined?(Rails)
   def config
     @config ||= Config.new(
-      YAML.safe_load(ERB.new(File.read(config_root_path.join("config", "valkyrie.yml"))).result)[environment]
+      config_hash
     )
   end
 
+  def config_file
+    return unless File.exist?(config_root_path.join("config", "valkyrie.yml"))
+    File.read(config_root_path.join("config", "valkyrie.yml"))
+  end
+
+  def config_hash
+    return {} unless config_file
+    YAML.safe_load(ERB.new(config_file).result)[environment]
+  end
+
   def environment
     Rails.env
   end
@@ -58,7 +68,16 @@ module Valkyrie
     @logger = logger
   end
 
+  def warn_about_standard_queries!
+    warn "[DEPRECATION] Please enable query normalization to avoid inconsistent results between different adapters by adding `standardize_query_results: true` to your environment block" \
+     " in config\/valkyrie.yml. This will be the behavior in Valkyrie 2.0."
+  end
+
   class Config < OpenStruct
+    def initialize(hsh = {})
+      super(defaults.merge(hsh))
+    end
+
     def metadata_adapter
       Valkyrie::MetadataAdapter.find(super.to_sym)
     end
@@ -66,7 +85,15 @@ module Valkyrie
     def storage_adapter
       Valkyrie::StorageAdapter.find(super.to_sym)
     end
+
+    private
+
+      def defaults
+        {
+          standardize_query_result: false
+        }
+      end
   end
 
-  module_function :config, :logger, :logger=, :config_root_path, :environment
+  module_function :config, :logger, :logger=, :config_root_path, :environment, :warn_about_standard_queries!, :config_file, :config_hash
 end

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

@@ -73,5 +73,10 @@ module Valkyrie::Persistence::Fedora
     def connection_prefix
       "#{connection.http.url_prefix}/#{base_path}"
     end
+
+    def standardize_query_result?
+      Valkyrie.warn_about_standard_queries! if Valkyrie.config.standardize_query_result != true
+      Valkyrie.config.standardize_query_result == true
+    end
   end
 end

data/lib/valkyrie/persistence/fedora/persister/model_converter.rb

@@ -238,7 +238,7 @@ module Valkyrie::Persistence::Fedora
             obj = calling_mapper.for(property.property).result
             # Append value directly if possible.
             if obj.respond_to?(:value)
-              ordered_list.insert_proxy_for_at(index, obj.value)
+              ordered_list.insert_proxy_for_at(index, proxy_for_value(obj.value))
             # If value is a nested object, take its graph and append it.
             elsif obj.respond_to?(:graph)
               append_to_graph(obj: obj, index: index, property: property.property)
@@ -247,6 +247,14 @@ module Valkyrie::Persistence::Fedora
           end
         end
 
+        def proxy_for_value(value)
+          if value.is_a?(RDF::Literal) && value.datatype == PermissiveSchema.valkyrie_id
+            ordered_list.adapter.id_to_uri(value)
+          else
+            value
+          end
+        end
+
         class NestedProperty
           attr_reader :value, :scope
           def initialize(value:, scope:)

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

@@ -29,6 +29,7 @@ module Valkyrie::Persistence::Fedora
 
     # (see Valkyrie::Persistence::Memory::QueryService#find_many_by_ids)
     def find_many_by_ids(ids:)
+      ids = ids.uniq if adapter.standardize_query_result?
       ids.map do |id|
         begin
           find_by(id: id)
@@ -42,6 +43,7 @@ module Valkyrie::Persistence::Fedora
     def find_parents(resource:)
       content = content_with_inbound(id: resource.id)
       parent_ids = content.graph.query([nil, RDF::Vocab::ORE.proxyFor, nil]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
+      parent_ids.uniq! if adapter.standardize_query_result?
       parent_ids.lazy.map do |id|
         find_by(id: id)
       end
@@ -111,11 +113,10 @@ module Valkyrie::Persistence::Fedora
     # *Also, an initial request is made to find the URIs of the resources referencing the resource in the query*
     def find_inverse_references_by(resource:, property:)
       ensure_persisted(resource)
-      content = content_with_inbound(id: resource.id)
-      property_uri =  adapter.schema.predicate_for(property: property, resource: nil)
-      ids = content.graph.query([nil, property_uri, nil]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
-      ids.lazy.map do |id|
-        find_by(id: id)
+      if ordered_property?(resource: resource, property: property)
+        find_inverse_references_by_ordered(resource: resource, property: property)
+      else
+        find_inverse_references_by_unordered(resource: resource, property: property)
       end
     end
 
@@ -126,6 +127,21 @@ module Valkyrie::Persistence::Fedora
 
     private
 
+      def find_inverse_references_by_unordered(resource:, property:)
+        content = content_with_inbound(id: resource.id)
+        property_uri = adapter.schema.predicate_for(property: property, resource: nil)
+        ids = content.graph.query([nil, property_uri, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
+        ids.uniq! if adapter.standardize_query_result?
+        ids.lazy.map { |id| find_by(id: id) }
+      end
+
+      def find_inverse_references_by_ordered(resource:, property:)
+        content = content_with_inbound(id: resource.id)
+        ids = content.graph.query([nil, ::RDF::Vocab::ORE.proxyFor, adapter.id_to_uri(resource.id)]).map(&:subject).map { |x| x.to_s.gsub(/#.*/, '') }.map { |x| adapter.uri_to_id(x) }
+        ids.uniq! if adapter.standardize_query_result?
+        ids.lazy.map { |id| find_by(id: id) }.select { |o| o[property].include?(resource.id) }
+      end
+
       # Ensures that an object is (or can be cast into a) Valkyrie::ID
       # @return [Valkyrie::ID]
       # @raise [ArgumentError]
@@ -151,5 +167,9 @@ module Valkyrie::Persistence::Fedora
       def ensure_persisted(resource)
         raise ArgumentError, 'resource is not saved' unless resource.persisted?
       end
+
+      def ordered_property?(resource:, property:)
+        resource.class.schema[property].meta.try(:[], :ordered)
+      end
   end
 end

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

@@ -29,5 +29,10 @@ module Valkyrie::Persistence::Memory
     def id
       @id ||= Valkyrie::ID.new(Digest::MD5.hexdigest(self.class.to_s))
     end
+
+    def standardize_query_result?
+      Valkyrie.warn_about_standard_queries! if Valkyrie.config.standardize_query_result != true
+      Valkyrie.config.standardize_query_result == true
+    end
   end
 end

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

@@ -44,6 +44,7 @@ module Valkyrie::Persistence::Memory
     # @raise [ArgumentError] Raised when any ID is not a String or a Valkyrie::ID
     # @return [Array<Valkyrie::Resource>] All requested objects that were found
     def find_many_by_ids(ids:)
+      ids = ids.uniq if adapter.standardize_query_result?
       ids.map do |id|
         begin
           find_by(id: id)
@@ -89,9 +90,15 @@ module Valkyrie::Persistence::Memory
     # @return [Array<Valkyrie::Resource>] All objects which are referenced by the
     #   `property` property on `resource`. Not necessarily in order.
     def find_references_by(resource:, property:)
-      Array.wrap(resource[property]).map do |id|
-        find_by(id: id)
-      end
+      refs = Array.wrap(resource[property]).map do |id|
+        begin
+          find_by(id: id)
+        rescue ::Valkyrie::Persistence::ObjectNotFoundError
+          nil
+        end
+      end.reject(&:nil?)
+      refs.uniq! if adapter.standardize_query_result? && !ordered_property?(resource: resource, property: property)
+      refs
     end
 
     # Get all resources which link to a resource with a given property.
@@ -147,5 +154,9 @@ module Valkyrie::Persistence::Memory
       def ensure_persisted(resource)
         raise ArgumentError, 'resource is not saved' unless resource.persisted?
       end
+
+      def ordered_property?(resource:, property:)
+        resource.class.schema[property].meta.try(:[], :ordered)
+      end
   end
 end

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

@@ -17,7 +17,8 @@ module Valkyrie::Persistence::Postgres
     # @return [Class] {Valkyrie::Persistence::Postgres::QueryService}
     def query_service
       @query_service ||= Valkyrie::Persistence::Postgres::QueryService.new(
-        resource_factory: resource_factory
+        resource_factory: resource_factory,
+        adapter: self
       )
     end
 
@@ -34,5 +35,10 @@ module Valkyrie::Persistence::Postgres
         Valkyrie::ID.new(Digest::MD5.hexdigest(to_hash))
       end
     end
+
+    def standardize_query_result?
+      Valkyrie.warn_about_standard_queries! if Valkyrie.config.standardize_query_result != true
+      Valkyrie.config.standardize_query_result == true
+    end
   end
 end

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

@@ -7,12 +7,13 @@ module Valkyrie::Persistence::Postgres
   #
   # @see Valkyrie::Persistence::Postgres::MetadataAdapter
   class QueryService
-    attr_reader :resource_factory
+    attr_reader :resource_factory, :adapter
     delegate :orm_class, to: :resource_factory
 
     # @param [ResourceFactory] resource_factory
-    def initialize(resource_factory:)
+    def initialize(adapter:, resource_factory:)
       @resource_factory = resource_factory
+      @adapter = adapter
     end
 
     # Retrieve all records for the resource and construct Valkyrie Resources
@@ -188,7 +189,7 @@ module Valkyrie::Persistence::Postgres
     # @return [String]
     def find_references_query
       <<-SQL
-        SELECT member.* FROM orm_resources a,
+        SELECT #{adapter.standardize_query_result? ? 'DISTINCT' : ''} member.* FROM orm_resources a,
         jsonb_array_elements(a.metadata->?) AS b(member)
         JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
       SQL

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

@@ -46,7 +46,8 @@ module Valkyrie::Persistence::Solr
     def query_service
       @query_service ||= Valkyrie::Persistence::Solr::QueryService.new(
         connection: connection,
-        resource_factory: resource_factory
+        resource_factory: resource_factory,
+        adapter: self
       )
     end
 
@@ -63,6 +64,11 @@ module Valkyrie::Persistence::Solr
       Valkyrie::Persistence::Solr::ResourceFactory.new(resource_indexer: resource_indexer, adapter: self)
     end
 
+    def standardize_query_result?
+      Valkyrie.warn_about_standard_queries! if Valkyrie.config.standardize_query_result != true
+      Valkyrie.config.standardize_query_result == true
+    end
+
     # Class modeling the indexer for cases where indexing is *not* performed
     class NullIndexer
       # @note this is a no-op

data/lib/valkyrie/persistence/solr/queries/find_members_query.rb

@@ -3,17 +3,18 @@ module Valkyrie::Persistence::Solr::Queries
   # Responsible for returning all members of a given resource as
   # {Valkyrie::Resource}s
   class FindMembersQuery
-    attr_reader :resource, :connection, :resource_factory, :model
+    attr_reader :resource, :connection, :resource_factory, :model, :standardize_query_result
 
     # @param [Valkyrie::Resource] resource
     # @param [RSolr::Client] connection
     # @param [ResourceFactory] resource_factory
     # @param [Class] model
-    def initialize(resource:, connection:, resource_factory:, model:)
+    def initialize(resource:, connection:, resource_factory:, model:, standardize_query_result:)
       @resource = resource
       @connection = connection
       @resource_factory = resource_factory
       @model = model
+      @standardize_query_result = standardize_query_result
     end
 
     # Iterate over each Solr Document and convert each Document into a Valkyrie Resource
@@ -28,15 +29,21 @@ module Valkyrie::Persistence::Solr::Queries
     # @yield [Valkyrie::Resource]
     def each
       return [] unless resource.id.present?
-      unordered_members.sort_by { |x| member_ids.index(x.id) }.each do |member|
-        yield member
+      if standardize_query_result
+        member_ids.map { |id| unordered_members.find { |member| member.id == id } }.reject(&:nil?).each do |member|
+          yield member
+        end
+      else
+        unordered_members.sort_by { |x| member_ids.index(x.id) }.each do |member|
+          yield member
+        end
       end
     end
 
     # Retrieving the Solr Documents for the member resources, construct Valkyrie Resources for each
     # @return [Array<Valkyrie::Resource>]
     def unordered_members
-      docs.map do |doc|
+      @unordered_members ||= docs.map do |doc|
         resource_factory.to_resource(object: doc)
       end
     end
@@ -55,7 +62,7 @@ module Valkyrie::Persistence::Solr::Queries
     # Access the IDs of the members for the Valkyrie Resource
     # @return [Array<Valkyrie::ID>]
     def member_ids
-      Array.wrap(resource.member_ids)
+      resource.respond_to?(:member_ids) ? Array.wrap(resource.member_ids) : []
     end
 
     # Generate the Solr join query using the id_ssi field

data/lib/valkyrie/persistence/solr/queries/find_ordered_references_query.rb

@@ -17,13 +17,13 @@ module Valkyrie::Persistence::Solr::Queries
 
     def each
       # map them off of the property to fix solr's deduplication
-      property_values.map { |id| unordered_members.find { |member| member.id == id } } .each do |value|
+      property_values.map { |id| unordered_members.find { |member| member.id == id } } .reject(&:nil?).each do |value|
         yield value
       end
     end
 
     def unordered_members
-      docs.map do |doc|
+      @unordered_members ||= docs.map do |doc|
         resource_factory.to_resource(object: doc)
       end
     end

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

@@ -3,12 +3,13 @@ module Valkyrie::Persistence::Solr
   require 'valkyrie/persistence/solr/queries'
   # Query Service for Solr MetadataAdapter.
   class QueryService
-    attr_reader :connection, :resource_factory
+    attr_reader :connection, :resource_factory, :adapter
     # @param [RSolr::Client] connection
     # @param [Valkyrie::Persistence::Solr::ResourceFactory] resource_factory
-    def initialize(connection:, resource_factory:)
+    def initialize(connection:, resource_factory:, adapter:)
       @connection = connection
       @resource_factory = resource_factory
+      @adapter = adapter
     end
 
     # Find resources by Valkyrie ID
@@ -65,7 +66,13 @@ module Valkyrie::Persistence::Solr
     # @param [Valkyrie::Resource] parent resource
     # @return [Array<Valkyrie::Resource>] member resources
     def find_members(resource:, model: nil)
-      Valkyrie::Persistence::Solr::Queries::FindMembersQuery.new(resource: resource, model: model, connection: connection, resource_factory: resource_factory).run
+      Valkyrie::Persistence::Solr::Queries::FindMembersQuery.new(
+        resource: resource,
+        model: model,
+        connection: connection,
+        resource_factory: resource_factory,
+        standardize_query_result: adapter.standardize_query_result?
+      ).run
     end
 
     # Find all of the resources referenced by a given Valkyrie Resource using a specific property

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

@@ -7,7 +7,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
       attribute :alternate_ids, Valkyrie::Types::Array
       attribute :title
       attribute :member_ids, Valkyrie::Types::Array
-      attribute :a_member_of
+      attribute :a_member_of, Valkyrie::Types::Array
       attribute :an_ordered_member_of, Valkyrie::Types::Array.meta(ordered: true)
     end
     class SecondResource < Valkyrie::Resource
@@ -22,6 +22,8 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   let(:persister) { adapter.persister }
   subject { adapter.query_service }
 
+  before { allow(Valkyrie.config).to receive(:standardize_query_result).and_return(true) }
+
   it { is_expected.to respond_to(:find_all).with(0).arguments }
   it { is_expected.to respond_to(:find_all_of_model).with_keywords(:model) }
   it { is_expected.to respond_to(:find_by).with_keywords(:id) }
@@ -139,6 +141,11 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     it 'raises an error if any id is not a Valkyrie::ID or a string' do
       expect { query_service.find_many_by_ids(ids: [resource.id, 123]) }.to raise_error ArgumentError
     end
+
+    it "removes duplicates" do
+      found = query_service.find_many_by_ids(ids: [resource.id, resource2.id, resource.id])
+      expect(found.map(&:id)).to contain_exactly resource.id, resource2.id
+    end
   end
 
   describe ".find_members" do
@@ -153,6 +160,13 @@ RSpec.shared_examples 'a Valkyrie query provider' do
         it "returns all a resource's members in order" do
           expect(subject.map(&:id).to_a).to eq [child2.id, child1.id]
         end
+
+        context "when something is member more than once" do
+          let(:parent) { persister.save(resource: resource_class.new(member_ids: [child1.id, child2.id, child1.id])) }
+          it "includes duplicates" do
+            expect(subject.map(&:id).to_a).to eq [child1.id, child2.id, child1.id]
+          end
+        end
       end
 
       context "when there's no resource ID" do
@@ -207,20 +221,39 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   end
 
   describe ".find_references_by" do
-    it "returns all references given in a property" do
-      parent = persister.save(resource: resource_class.new)
-      child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
-      persister.save(resource: resource_class.new)
+    context "when the property is unordered" do
+      it "returns all references given in a property" do
+        parent = persister.save(resource: resource_class.new)
+        parent2 = persister.save(resource: resource_class.new)
+        child = persister.save(resource: resource_class.new(a_member_of: [parent.id, parent2.id]))
+        persister.save(resource: resource_class.new)
 
-      expect(query_service.find_references_by(resource: child, property: :a_member_of).map(&:id).to_a).to eq [parent.id]
-    end
-    it "returns an empty array if there are none" do
-      child = persister.save(resource: resource_class.new)
-      expect(query_service.find_references_by(resource: child, property: :a_member_of).to_a).to eq []
+        expect(query_service.find_references_by(resource: child, property: :a_member_of).map(&:id).to_a).to contain_exactly parent.id, parent2.id
+      end
+
+      it "returns an empty array if there are none" do
+        child = persister.save(resource: resource_class.new)
+        expect(query_service.find_references_by(resource: child, property: :a_member_of).to_a).to eq []
+      end
+
+      it "removes duplicates" do
+        parent = persister.save(resource: resource_class.new)
+        child = persister.save(resource: resource_class.new(a_member_of: [parent.id, parent.id]))
+        persister.save(resource: resource_class.new)
+
+        expect(query_service.find_references_by(resource: child, property: :a_member_of).map(&:id).to_a).to contain_exactly parent.id
+      end
+
+      it "returns nothing if reference not found" do
+        child = persister.save(resource: resource_class.new(a_member_of: ["123123123"]))
+        persister.save(resource: resource_class.new)
+
+        expect(query_service.find_references_by(resource: child, property: :a_member_of).map(&:id).to_a).to eq []
+      end
     end
 
     context "when the property is ordered" do
-      it "returns all references in order" do
+      it "returns all references in order including duplicates" do
         parent = persister.save(resource: resource_class.new)
         parent2 = persister.save(resource: resource_class.new)
         child = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id, parent2.id, parent.id]))
@@ -228,23 +261,47 @@ RSpec.shared_examples 'a Valkyrie query provider' do
 
         expect(query_service.find_references_by(resource: child, property: :an_ordered_member_of).map(&:id).to_a).to eq [parent.id, parent2.id, parent.id]
       end
+
+      it "returns nothing if reference not found" do
+        child = persister.save(resource: resource_class.new(an_ordered_member_of: ["123123123"]))
+        persister.save(resource: resource_class.new)
+
+        expect(query_service.find_references_by(resource: child, property: :an_ordered_member_of).map(&:id).to_a).to eq []
+      end
     end
   end
 
   describe ".find_inverse_references_by" do
     context "when the resource is saved" do
-      it "returns everything which references the given resource by the given property" do
-        parent = persister.save(resource: resource_class.new)
-        child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
-        persister.save(resource: resource_class.new)
-        persister.save(resource: SecondResource.new)
+      context "when the property is unordered" do
+        it "returns everything which references the given resource by the given property" do
+          parent = persister.save(resource: resource_class.new)
+          parent2 = persister.save(resource: resource_class.new)
+          child = persister.save(resource: resource_class.new(a_member_of: [parent.id]))
+          child2 = persister.save(resource: resource_class.new(a_member_of: [parent.id, parent2.id, parent.id]))
+          persister.save(resource: resource_class.new)
+          persister.save(resource: SecondResource.new)
+
+          expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).map(&:id).to_a).to contain_exactly child.id, child2.id
+        end
 
-        expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).map(&:id).to_a).to eq [child.id]
+        it "returns an empty array if there are none" do
+          parent = persister.save(resource: resource_class.new)
+
+          expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a).to eq []
+        end
       end
-      it "returns an empty array if there are none" do
-        parent = persister.save(resource: resource_class.new)
 
-        expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a).to eq []
+      context "when the property is ordered" do
+        it "returns everything which references the given resource by the given property" do
+          parent = persister.save(resource: resource_class.new)
+          child = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id]))
+          child2 = persister.save(resource: resource_class.new(an_ordered_member_of: [parent.id, parent.id]))
+          persister.save(resource: resource_class.new)
+          persister.save(resource: SecondResource.new)
+
+          expect(query_service.find_inverse_references_by(resource: parent, property: :an_ordered_member_of).map(&:id).to_a).to contain_exactly child.id, child2.id
+        end
       end
     end
     context "when the resource is not saved" do
@@ -265,12 +322,21 @@ RSpec.shared_examples 'a Valkyrie query provider' do
 
       expect(query_service.find_parents(resource: child1).map(&:id).to_a).to contain_exactly parent.id, parent2.id
     end
+
     it "returns an empty array if there are none" do
       child1 = persister.save(resource: resource_class.new)
 
       expect(query_service.find_parents(resource: child1).to_a).to eq []
     end
 
+    it "doesn't return same parent twice" do
+      child1 = persister.save(resource: resource_class.new)
+      parent = persister.save(resource: resource_class.new(member_ids: [child1.id, child1.id]))
+      parent2 = persister.save(resource: resource_class.new(member_ids: [child1.id]))
+
+      expect(query_service.find_parents(resource: child1).map(&:id).to_a).to contain_exactly parent.id, parent2.id
+    end
+
     context "when the model doesn't have member_ids" do
       let(:child1) { persister.save(resource: SecondResource.new) }
 

data/lib/valkyrie/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Valkyrie
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkyrie
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Trey Pendragon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-25 00:00:00.000000000 Z
+date: 2018-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -589,7 +589,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: An ORM using the Data Mapper pattern, specifically built to solve Digital