valkyrie 0.1.0 → 1.0.0.rc1

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

@@ -7,4 +7,7 @@ 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 "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
 end

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

@@ -9,6 +9,7 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
       attribute :author
       attribute :member_ids
       attribute :nested_resource
+      attribute :single_value, Valkyrie::Types::String
     end
   end
   after do
@@ -24,7 +25,15 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
   it { is_expected.to respond_to(:delete).with_keywords(:resource) }
 
   it "can save a resource" do
-    expect(persister.save(resource: resource).id).not_to be_blank
+    expect(resource).not_to be_persisted
+    saved = persister.save(resource: resource)
+    expect(saved).to be_persisted
+    expect(saved.id).not_to be_blank
+  end
+
+  it "does not save non-array properties" do
+    resource.single_value = "A Single Value"
+    expect { persister.save(resource: resource) }.to raise_error ::Valkyrie::Persistence::UnsupportedDatatype
   end
 
   it "can save multiple resources at once" do
@@ -74,33 +83,87 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     expect(book.updated_at).not_to be_kind_of Array
   end
 
+  it "can handle Boolean RDF properties" do
+    boolean_rdf = RDF::Literal.new(false)
+    book = persister.save(resource: resource_class.new(title: [boolean_rdf]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly boolean_rdf
+  end
+
+  it "can handle custom-typed RDF properties" do
+    custom_rdf = RDF::Literal.new("Test", datatype: RDF::URI.parse("http://my_made_up_type"))
+    book = persister.save(resource: resource_class.new(title: [custom_rdf]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly custom_rdf
+  end
+
+  it "can handle Date RDF properties" do
+    date_rdf = RDF::Literal.new(Date.current)
+    book = persister.save(resource: resource_class.new(title: [date_rdf]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly date_rdf
+  end
+
+  it "can handle DateTime RDF properties" do
+    datetime_rdf = RDF::Literal.new(DateTime.current)
+    book = persister.save(resource: resource_class.new(title: [datetime_rdf]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly datetime_rdf
+  end
+
+  it "can handle Decimal RDF properties" do
+    decimal_rdf = RDF::Literal.new(BigDecimal(5.5, 10))
+    book = persister.save(resource: resource_class.new(title: [decimal_rdf]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly decimal_rdf
+  end
+
+  it "can handle Double RDF properties" do
+    double_rdf = RDF::Literal.new(5.5)
+    book = persister.save(resource: resource_class.new(title: [double_rdf]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly double_rdf
+  end
+
+  it "can handle Integer RDF properties" do
+    int_rdf = RDF::Literal.new(17)
+    book = persister.save(resource: resource_class.new(title: [int_rdf]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly int_rdf
+  end
+
   it "can handle language-typed RDF properties" do
-    book = persister.save(resource: resource_class.new(title: ["Test1", RDF::Literal.new("Test", language: :fr)]))
+    language_rdf = RDF::Literal.new("Test", language: :fr)
+    book = persister.save(resource: resource_class.new(title: ["Test1", language_rdf]))
     reloaded = query_service.find_by(id: book.id)
-    expect(reloaded.title).to contain_exactly "Test1", RDF::Literal.new("Test", language: :fr)
+    expect(reloaded.title).to contain_exactly "Test1", language_rdf
   end
 
-  it "can store Valkyrie::Ids" do
-    shared_title = persister.save(resource: resource_class.new(id: "test"))
-    book = persister.save(resource: resource_class.new(title: [shared_title.id, Valkyrie::ID.new("adapter://1"), "test"]))
+  it "can handle Time RDF properties" do
+    time_rdf = RDF::Literal.new(Time.current)
+    book = persister.save(resource: resource_class.new(title: [time_rdf]))
     reloaded = query_service.find_by(id: book.id)
-    expect(reloaded.title).to contain_exactly(shared_title.id, Valkyrie::ID.new("adapter://1"), "test")
-    expect([shared_title.id, Valkyrie::ID.new("adapter://1"), "test"]).to contain_exactly(*reloaded.title)
+    expect(reloaded.title).to contain_exactly time_rdf
   end
 
-  it "can store ::RDF::URIs" do
-    book = persister.save(resource: resource_class.new(title: [::RDF::URI("http://example.com")]))
+  #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
+  it "can store booleans" do
+    boolean = [false, true]
+    book = persister.save(resource: resource_class.new(title: boolean))
     reloaded = query_service.find_by(id: book.id)
-    expect(reloaded.title).to contain_exactly RDF::URI("http://example.com")
+    expect(reloaded.title).to contain_exactly(*boolean)
   end
 
-  it "can store integers" do
-    book = persister.save(resource: resource_class.new(title: [1]))
+  # Pending date support in Valkyrie
+  #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
+  xit "can store Dates" do
+    date = Date.current
+    book = persister.save(resource: resource_class.new(title: [date]))
     reloaded = query_service.find_by(id: book.id)
-    expect(reloaded.title).to contain_exactly 1
+    expect(reloaded.title).to contain_exactly date
   end
 
-  it "can store datetimes" do
+  it "can store DateTimes" do
     time1 = DateTime.current
     time2 = Time.current.in_time_zone
     book = persister.save(resource: resource_class.new(title: [time1], author: [time2]))
@@ -113,6 +176,66 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     expect(reloaded.author.first.zone).to eq('UTC')
   end
 
+  # Pending decimals support in Valkyrie
+  #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
+  xit "can store Decimals" do
+    decimal = BigDecimal(5.5, 10)
+    book = persister.save(resource: resource_class.new(title: [decimal]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly decimal
+  end
+
+  # Pending doubles support in Valkyrie
+  #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
+  xit "can store doubles" do
+    book = persister.save(resource: resource_class.new(title: [1.5]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly 1.5
+  end
+
+  it "can store integers" do
+    book = persister.save(resource: resource_class.new(title: [1]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly 1
+  end
+
+  # Pending time support in Valkyrie
+  #  currently millisecond precision is lost is postgres and solr
+  #
+  #  https://github.com/samvera-labs/valkyrie/wiki/Supported-Data-Types
+  xit "can store Times" do
+    time = Time.current
+    book = persister.save(resource: resource_class.new(title: [time]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly time.utc
+  end
+
+  it "can store ::RDF::URIs" do
+    book = persister.save(resource: resource_class.new(title: [::RDF::URI("http://example.com")]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly RDF::URI("http://example.com")
+  end
+
+  it "can store Valkyrie::IDs" do
+    shared_title = persister.save(resource: resource_class.new(id: "test"))
+    book = persister.save(resource: resource_class.new(title: [shared_title.id, Valkyrie::ID.new("adapter://1"), "test"]))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.title).to contain_exactly(shared_title.id, Valkyrie::ID.new("adapter://1"), "test")
+    expect([shared_title.id, Valkyrie::ID.new("adapter://1"), "test"]).to contain_exactly(*reloaded.title)
+  end
+
+  it "can override default id generation with a provided id" do
+    id = SecureRandom.uuid
+    book = persister.save(resource: resource_class.new(id: id))
+    reloaded = query_service.find_by(id: book.id)
+    expect(reloaded.id).to eq Valkyrie::ID.new(id)
+    expect(reloaded).to be_persisted
+    expect(reloaded.created_at).not_to be_blank
+    expect(reloaded.updated_at).not_to be_blank
+    expect(reloaded.created_at).not_to be_kind_of Array
+    expect(reloaded.updated_at).not_to be_kind_of Array
+  end
+
   context "parent tests" do
     let(:book) { persister.save(resource: resource_class.new) }
     let(:book2) { persister.save(resource: resource_class.new) }
@@ -151,4 +274,11 @@ RSpec.shared_examples 'a Valkyrie::Persister' do |*flags|
     persister.delete(resource: persisted)
     expect { query_service.find_by(id: persisted.id) }.to raise_error ::Valkyrie::Persistence::ObjectNotFoundError
   end
+
+  it "can delete all objects" do
+    resource2 = resource_class.new
+    persister.save_all(resources: [resource, resource2])
+    persister.wipe!
+    expect(query_service.find_all.to_a.length).to eq 0
+  end
 end

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

@@ -6,7 +6,7 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     class CustomResource < Valkyrie::Resource
       attribute :id, Valkyrie::Types::ID.optional
       attribute :title
-      attribute :member_ids
+      attribute :member_ids, Valkyrie::Types::Array
       attribute :a_member_of
     end
     class SecondResource < Valkyrie::Resource
@@ -18,14 +18,15 @@ RSpec.shared_examples 'a Valkyrie query provider' do
     Object.send(:remove_const, :SecondResource)
   end
   let(:resource_class) { CustomResource }
-  let(:query_service) { adapter.query_service }
+  let(:query_service) { adapter.query_service } unless defined? query_service
   let(:persister) { adapter.persister }
   subject { adapter.query_service }
 
   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) }
-  it { is_expected.to respond_to(:find_members).with_keywords(:resource) }
+  it { is_expected.to respond_to(:find_many_by_ids).with_keywords(:ids) }
+  it { is_expected.to respond_to(:find_members).with_keywords(:resource, :model) }
   it { is_expected.to respond_to(:find_references_by).with_keywords(:resource, :property) }
   it { is_expected.to respond_to(:find_inverse_references_by).with_keywords(:resource, :property) }
   it { is_expected.to respond_to(:find_parents).with_keywords(:resource) }
@@ -52,31 +53,117 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   end
 
   describe ".find_by" do
-    it "returns a resource by id" do
+    it "returns a resource by id or string representation of an id" do
       resource = persister.save(resource: resource_class.new)
 
-      expect(query_service.find_by(id: resource.id).id).to eq resource.id
+      found = query_service.find_by(id: resource.id)
+      expect(found.id).to eq resource.id
+      expect(found).to be_persisted
+
+      found = query_service.find_by(id: resource.id.to_s)
+      expect(found.id).to eq resource.id
+      expect(found).to be_persisted
     end
+
     it "returns a Valkyrie::Persistence::ObjectNotFoundError for a non-found ID" do
-      expect { query_service.find_by(id: "123123123") }.to raise_error ::Valkyrie::Persistence::ObjectNotFoundError
+      expect { query_service.find_by(id: Valkyrie::ID.new("123123123")) }.to raise_error ::Valkyrie::Persistence::ObjectNotFoundError
+    end
+
+    it 'raises an error if the id is not a Valkyrie::ID or a string' do
+      expect { query_service.find_by(id: 123) }.to raise_error ArgumentError
     end
   end
 
-  describe ".find_members" do
-    it "returns all a resource's members in order" do
-      child1 = persister.save(resource: resource_class.new)
-      child2 = persister.save(resource: resource_class.new)
-      parent = persister.save(resource: resource_class.new(member_ids: [child2.id, child1.id]))
+  describe ".find_many_by_ids" do
+    let!(:resource) { persister.save(resource: resource_class.new) }
+    let!(:resource2) { persister.save(resource: resource_class.new) }
+    let!(:resource3) { persister.save(resource: resource_class.new) }
+
+    it "returns an array of resources by ids or string representation ids" do
+      found = query_service.find_many_by_ids(ids: [resource.id, resource2.id])
+      expect(found.map(&:id)).to contain_exactly resource.id, resource2.id
 
-      expect(query_service.find_members(resource: parent).map(&:id).to_a).to eq [child2.id, child1.id]
-      expect(query_service.find_by(id: parent.id).member_ids).to eq [child2.id, child1.id]
+      found = query_service.find_many_by_ids(ids: [resource.id.to_s, resource2.id.to_s])
+      expect(found.map(&:id)).to contain_exactly resource.id, resource2.id
     end
-    it "doesn't error when there's no resource ID" do
-      parent = resource_class.new
-      expect(query_service.find_members(resource: parent).to_a).to eq []
+
+    it "returns a partial list for a non-found ID" do
+      found = query_service.find_many_by_ids(ids: [resource.id, Valkyrie::ID.new("123123123")])
+      expect(found.map(&:id)).to contain_exactly resource.id
     end
-    it "returns an empty array if there are none" do
-      expect(query_service.find_all.to_a).to eq []
+
+    it "returns an empty list if no ids were found" do
+      found = query_service.find_many_by_ids(ids: [Valkyrie::ID.new("you-cannot-find-me"), Valkyrie::ID.new("123123123")])
+      expect(found.map(&:id)).to eq []
+    end
+
+    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
+  end
+
+  describe ".find_members" do
+    context "without filtering by model" do
+      subject { query_service.find_members(resource: parent) }
+
+      context "when the object has members" do
+        let!(:child1) { persister.save(resource: resource_class.new) }
+        let!(:child2) { persister.save(resource: resource_class.new) }
+        let(:parent) { persister.save(resource: resource_class.new(member_ids: [child2.id, child1.id])) }
+
+        it "returns all a resource's members in order" do
+          expect(subject.map(&:id).to_a).to eq [child2.id, child1.id]
+        end
+      end
+
+      context "when there's no resource ID" do
+        let(:parent) { resource_class.new }
+
+        it "doesn't error" do
+          expect(subject).not_to eq nil
+          expect(subject.to_a).to eq []
+        end
+      end
+
+      context "when there are no members" do
+        let(:parent) { persister.save(resource: resource_class.new) }
+
+        it "returns an empty array" do
+          expect(subject.to_a).to eq []
+        end
+      end
+
+      context "when the model doesn't have member_ids" do
+        let(:parent) { persister.save(resource: SecondResource.new) }
+
+        it "returns an empty array" do
+          expect(subject.to_a).to eq []
+        end
+      end
+    end
+
+    context "filtering by model" do
+      subject { query_service.find_members(resource: parent, model: SecondResource) }
+
+      context "when the object has members" do
+        let(:child1) { persister.save(resource: SecondResource.new) }
+        let(:child2) { persister.save(resource: resource_class.new) }
+        let(:child3) { persister.save(resource: SecondResource.new) }
+        let(:parent) { persister.save(resource: resource_class.new(member_ids: [child3.id, child2.id, child1.id])) }
+
+        it "returns all a resource's members in order" do
+          expect(subject.map(&:id).to_a).to eq [child3.id, child1.id]
+        end
+      end
+
+      context "when there are no members that match the filter" do
+        let(:child1) { persister.save(resource: resource_class.new) }
+        let(:parent) { persister.save(resource: resource_class.new(member_ids: [child1.id])) }
+
+        it "returns an empty array" do
+          expect(subject.to_a).to eq []
+        end
+      end
     end
   end
 
@@ -95,18 +182,27 @@ RSpec.shared_examples 'a Valkyrie query provider' do
   end
 
   describe ".find_inverse_references_by" 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 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)
+
+        expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).map(&:id).to_a).to eq [child.id]
+      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).map(&:id).to_a).to eq [child.id]
+        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)
+    context "when the resource is not saved" do
+      it "raises an error" do
+        parent = resource_class.new
 
-      expect(query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a).to eq []
+        expect { query_service.find_inverse_references_by(resource: parent, property: :a_member_of).to_a }.to raise_error ArgumentError
+      end
     end
   end
 
@@ -124,5 +220,35 @@ RSpec.shared_examples 'a Valkyrie query provider' do
 
       expect(query_service.find_parents(resource: child1).to_a).to eq []
     end
+
+    context "when the model doesn't have member_ids" do
+      let(:child1) { persister.save(resource: SecondResource.new) }
+
+      it "returns an empty array if there are none" do
+        expect(query_service.find_parents(resource: child1).to_a).to eq []
+      end
+    end
+  end
+
+  describe ".register_query_handler" do
+    it "can register a query handler" do
+      class QueryHandler
+        def self.queries
+          [:find_by_user_id]
+        end
+
+        attr_reader :query_service
+        def initialize(query_service:)
+          @query_service = query_service
+        end
+
+        def find_by_user_id
+          1
+        end
+      end
+      query_service.custom_queries.register_query_handler(QueryHandler)
+      expect(query_service.custom_queries).to respond_to :find_by_user_id
+      expect(query_service.custom_queries.find_by_user_id).to eq 1
+    end
   end
 end

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

@@ -15,13 +15,14 @@ RSpec.shared_examples 'a Valkyrie::StorageAdapter' do
   subject { storage_adapter }
   it { is_expected.to respond_to(:handles?).with_keywords(:id) }
   it { is_expected.to respond_to(:find_by).with_keywords(:id) }
-  it { is_expected.to respond_to(:upload).with_keywords(:file, :resource) }
+  it { is_expected.to respond_to(:delete).with_keywords(:id) }
+  it { is_expected.to respond_to(:upload).with_keywords(:file, :resource, :original_filename) }
 
-  it "can upload, validate, and re-fetch a file" do
+  it "can upload, validate, re-fetch, and delete a file" do
     resource = CustomResource.new(id: "test")
     sha1 = Digest::SHA1.file(file).to_s
     size = file.size
-    expect(uploaded_file = storage_adapter.upload(file: file, resource: resource)).to be_kind_of Valkyrie::StorageAdapter::File
+    expect(uploaded_file = storage_adapter.upload(file: file, original_filename: 'foo.jpg', resource: resource)).to be_kind_of Valkyrie::StorageAdapter::File
 
     expect(uploaded_file).to respond_to(:checksum).with_keywords(:digests)
     expect(uploaded_file).to respond_to(:valid?).with_keywords(:size, :digests)
@@ -40,5 +41,9 @@ RSpec.shared_examples 'a Valkyrie::StorageAdapter' do
     expect(file.stream).to respond_to(:read)
     new_file = Tempfile.new
     expect { IO.copy_stream(file, new_file) }.not_to raise_error
+
+    storage_adapter.delete(id: uploaded_file.id)
+    expect { storage_adapter.find_by(id: uploaded_file.id) }.to raise_error Valkyrie::StorageAdapter::FileNotFound
+    expect { storage_adapter.find_by(id: Valkyrie::ID.new("noexist")) }.to raise_error Valkyrie::StorageAdapter::FileNotFound
   end
 end