ld4l-ore_rdf 0.0.4

data/spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resource_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::AggregationResource::AddAggregatedResource' do
+
+  subject { LD4L::OreRDF::CreateAggregation.call(
+      title:       "Test Title",
+      description: "Test description of aggregation.",
+      owner:       LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith")) }
+
+  describe "#call" do
+    it "should return a LD4L::OreRDF::ProxyResource instance" do
+      proxy = LD4L::OreRDF::AddAggregatedResource.call( subject, RDF::URI("http://example.org/individual/b1") )
+      expect(proxy).to be_a(LD4L::OreRDF::ProxyResource)
+    end
+
+    it "should add a single resource to an empty set" do
+      subject.aggregates = []
+      LD4L::OreRDF::AddAggregatedResource.call( subject, RDF::URI("http://example.org/individual/b1") )
+      expect(subject.aggregates.first.rdf_subject).to eq RDF::URI("http://example.org/individual/b1")
+    end
+
+    it "should add a single resource to an existing set" do
+      subject.aggregates = RDF::URI("http://example.org/individual/b1" )
+      LD4L::OreRDF::AddAggregatedResource.call( subject, RDF::URI("http://example.org/individual/b2") )
+      expect(subject.aggregates[0].rdf_subject).to eq RDF::URI("http://example.org/individual/b1")
+      expect(subject.aggregates[1].rdf_subject).to eq RDF::URI("http://example.org/individual/b2")
+    end
+
+    it "should generate the resource instance for a single resource" do
+      proxy = LD4L::OreRDF::AddAggregatedResource.call( subject, RDF::URI("http://example.org/individual/b1" ))
+      expect(proxy.proxy_for.first.rdf_subject).to eq RDF::URI("http://example.org/individual/b1")
+      expect(proxy.proxy_in.first).to eq subject.aggregation_resource
+    end
+  end
+
+end

data/spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resources_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::AddAggregatedResources' do
+
+  subject { LD4L::OreRDF::CreateAggregation.call(
+      title:       "Test Title",
+      description: "Test description of aggregation.",
+      owner:       LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith")) }
+
+  describe "#call" do
+    it "should return an array" do
+      proxy_array = LD4L::OreRDF::AddAggregatedResources.call(
+          subject,
+          [RDF::URI("http://example.org/individual/b1"),
+           RDF::URI("http://example.org/individual/b2"),
+           RDF::URI("http://example.org/individual/b3")])
+      expect(proxy_array).to be_a(Array)
+    end
+
+    it "should return an array of LD4L::OreRDF::ProxyResource instances" do
+      proxy_array = LD4L::OreRDF::AddAggregatedResources.call(
+          subject,
+          [RDF::URI("http://example.org/individual/b1"),
+           RDF::URI("http://example.org/individual/b2"),
+           RDF::URI("http://example.org/individual/b3")])
+      proxy_array.each do |proxy|
+        expect(proxy).to be_a(LD4L::OreRDF::ProxyResource)
+      end
+    end
+
+    it "should add multiple resources to an empty set" do
+      subject.aggregates = []
+      LD4L::OreRDF::AddAggregatedResources.call(
+          subject,
+          [RDF::URI("http://example.org/individual/b1"),
+           RDF::URI("http://example.org/individual/b2"),
+           RDF::URI("http://example.org/individual/b3")])
+      aggregates = subject.aggregates
+      expect(aggregates).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b1"))
+      expect(aggregates).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b2"))
+      expect(aggregates).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b3"))
+    end
+
+    it "should add multiple resources to an existing set" do
+      subject.aggregates = RDF::URI("http://example.org/individual/b1")
+      LD4L::OreRDF::AddAggregatedResources.call(
+          subject,
+          [RDF::URI("http://example.org/individual/b2"),
+           RDF::URI("http://example.org/individual/b3"),
+           RDF::URI("http://example.org/individual/b4")])
+      aggregates = subject.aggregates
+      expect(aggregates).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b1"))
+      expect(aggregates).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b2"))
+      expect(aggregates).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b3"))
+      expect(aggregates).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b4"))
+    end
+
+    it "should return an array of resource instances for each of the multiple resources" do
+      proxy_array = LD4L::OreRDF::AddAggregatedResources.call(
+          subject,
+          [RDF::URI("http://example.org/individual/b1"),
+           RDF::URI("http://example.org/individual/b2"),
+           RDF::URI("http://example.org/individual/b3")])
+      proxy_array.each do |proxy|
+        expect(proxy).to be_a(LD4L::OreRDF::ProxyResource)
+        expect(proxy.proxy_in.first).to eq subject.aggregation_resource
+      end
+      results = []
+      proxy_array.each do |proxy|
+        results << proxy.proxy_for.first
+      end
+      expect(results).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b1"))
+      expect(results).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b2"))
+      expect(results).to include ActiveTriples::Resource.new(RDF::URI("http://example.org/individual/b3"))
+    end
+  end
+
+end

data/spec/ld4l/ore_rdf/services/aggregation/create_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::CreateAggregation' do
+
+  describe "#call" do
+    it "should create a LD4L::OreRDF::AggregationResource instance" do
+      aggregation = LD4L::OreRDF::CreateAggregation.call(
+          title:       "Test Title",
+          description: "Test description of aggregation.",
+          owner:       LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith"))
+      expect(aggregation).to be_a(LD4L::OreRDF::Aggregation)
+    end
+
+    it "should create a aggregation with passed in properties excluding an id" do
+      aggregation = LD4L::OreRDF::CreateAggregation.call(
+          title:       "Test Title",
+          description: "Test description of aggregation.",
+          owner:       LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith"))
+      expect(aggregation.rdf_subject.to_s).to start_with(
+          "#{LD4L::OreRDF::AggregationResource.base_uri}#{LD4L::OreRDF::AggregationResource.localname_prefix}")
+      expect(aggregation.title).to eq "Test Title"
+      expect(aggregation.description).to eq "Test description of aggregation."
+      expect(aggregation.owner.first.rdf_subject).to eq RDF::URI("http://vivo.cornell.edu/individual/JohnSmith")
+    end
+
+    it "should create a aggregation with partial id" do
+      aggregation = LD4L::OreRDF::CreateAggregation.call(
+          id:          "123",
+          title:       "Test Title",
+          description: "Test description of aggregation.",
+          owner:       LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith"))
+      expect(aggregation.rdf_subject.to_s).to eq "#{LD4L::OreRDF::AggregationResource.base_uri}123"
+      expect(aggregation.title).to eq "Test Title"
+      expect(aggregation.description).to eq "Test description of aggregation."
+      expect(aggregation.owner.first.rdf_subject).to eq RDF::URI("http://vivo.cornell.edu/individual/JohnSmith")
+    end
+
+    it "should create a aggregation with string uri id" do
+      aggregation = LD4L::OreRDF::CreateAggregation.call(
+          id:          "http://example.org/individual/vc123",
+          title:       "Test Title",
+          description: "Test description of aggregation.",
+          owner:       LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith"))
+      expect(aggregation.rdf_subject.to_s).to eq "http://example.org/individual/vc123"
+      expect(aggregation.title).to eq "Test Title"
+      expect(aggregation.description).to eq "Test description of aggregation."
+      expect(aggregation.owner.first.rdf_subject).to eq RDF::URI("http://vivo.cornell.edu/individual/JohnSmith")
+    end
+
+    it "should create a aggregation with URI id" do
+      aggregation = LD4L::OreRDF::CreateAggregation.call(
+          id:          RDF::URI("http://example.org/individual/vc123"),
+          title:       "Test Title",
+          description: "Test description of aggregation.",
+          owner:       LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith"))
+      expect(aggregation.rdf_subject.to_s).to eq "http://example.org/individual/vc123"
+      expect(aggregation.title).to eq "Test Title"
+      expect(aggregation.description).to eq "Test description of aggregation."
+      expect(aggregation.owner.first.rdf_subject).to eq RDF::URI("http://vivo.cornell.edu/individual/JohnSmith")
+    end
+  end
+end

data/spec/ld4l/ore_rdf/services/aggregation/destroy_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::DestroyAggregation' do
+
+  describe "#call" do
+
+    context "when aggregation hasn't been persisted" do
+      before do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+      after do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+
+      it "should return true if never persisted" do
+        id = "http::/example.org/NOT_PERSISTED"
+        aggregation = LD4L::OreRDF::CreateAggregation.call(
+            id:          id,
+            title:       "Unpersisted Aggregation",
+            description: "Test aggregation that isn't persisted." )
+        expect( LD4L::OreRDF::DestroyAggregation.call(aggregation) ).to be true
+        expect( LD4L::OreRDF::ResumeAggregation.call(id) ).to be nil
+      end
+
+    end
+
+    context "when aggregation doesn't have proxies" do
+      before do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+        @id = "http::/example.org/NO_PROXIES"
+        @aggregation = LD4L::OreRDF::CreateAggregation.call(
+            id:          @id,
+            title:       "No Proxy Aggregation",
+            description: "Test aggregation with no proxies." )
+        LD4L::OreRDF::PersistAggregation.call(@aggregation)
+        expect( LD4L::OreRDF::ResumeAggregation.call(@id).rdf_subject.to_s ).to eq @id
+      end
+      after do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+
+      it "should destroy aggregation resource and return true" do
+        expect( LD4L::OreRDF::DestroyAggregation.call(@aggregation) ).to be true
+        expect( LD4L::OreRDF::ResumeAggregation.call(@id) ).to eq nil
+      end
+    end
+
+    context "when aggregation has proxies" do
+      before do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+        @id1 = "http::/example.org/ag1"
+        @ag1 = LD4L::OreRDF::CreateAggregation.call(
+            id:          @id1,
+            title:       "Aggregation 1",
+            description: "Test aggregation with proxies." )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            @ag1,
+            [RDF::URI("http://example.org/individual/b11"),
+             RDF::URI("http://example.org/individual/b12"),
+             RDF::URI("http://example.org/individual/b13")])
+        LD4L::OreRDF::PersistAggregation.call(@ag1)
+        a1 = LD4L::OreRDF::ResumeAggregation.call(@id1)
+        expect( a1.aggregation_resource.rdf_subject.to_s ).to eq @id1
+        expect( a1.proxy_resources.length).to eq 3
+
+        @id2 = "http::/example.org/ag2"
+        @ag2 = LD4L::OreRDF::CreateAggregation.call(
+            id:          @id2,
+            title:       "Aggregation 2",
+            description: "Test description of aggregation 2.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            @ag2,
+            [RDF::URI("http://example.org/individual/b21"),
+             RDF::URI("http://example.org/individual/b22"),
+             RDF::URI("http://example.org/individual/b23")])
+        LD4L::OreRDF::PersistAggregation.call(@ag2)
+        a2 = LD4L::OreRDF::ResumeAggregation.call(@id2)
+        expect( a2.aggregation_resource.rdf_subject.to_s ).to eq @id2
+        expect( a2.proxy_resources.length).to eq 3
+
+        @id3 = "http::/example.org/ag3"
+        @ag3 = LD4L::OreRDF::CreateAggregation.call(
+            id:          @id3,
+            title:       "Aggregation 3",
+            description: "Test description of aggregation 3.",
+            owner:       p )
+        LD4L::OreRDF::PersistAggregation.call(@ag3)
+        a3 = LD4L::OreRDF::ResumeAggregation.call(@id3)
+        expect( a3.aggregation_resource.rdf_subject.to_s ).to eq @id3
+        expect( a3.proxy_resources.length).to eq 0
+      end
+      after do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+
+      context "and all parts are persisted" do
+        it "should destroy aggregation resource and all proxy resources and return true" do
+          expect( LD4L::OreRDF::DestroyAggregation.call(@ag1) ).to be true
+          expect( LD4L::OreRDF::ResumeAggregation.call(@id1) ).to eq nil
+
+          # verify other objects are unchanged
+          ag2 = LD4L::OreRDF::ResumeAggregation.call(@id2)
+          expect( ag2.rdf_subject.to_s ).to eq @id2
+          expect( ag2.proxy_resources.length).to eq 3
+
+          ag3 = LD4L::OreRDF::ResumeAggregation.call(@id3)
+          expect( ag3.rdf_subject.to_s ).to eq @id3
+          expect( ag3.proxy_resources.length).to eq 0
+        end
+      end
+
+      context "and some proxies are persisted" do
+        it "should destroy aggregation resource and persisted proxy resources and return true" do
+          LD4L::OreRDF::AddAggregatedResources.call(
+              @ag2,
+              [RDF::URI("http://example.org/individual/b24"),
+               RDF::URI("http://example.org/individual/b25")])
+          expect( @ag2.rdf_subject.to_s ).to eq @id2
+          expect( @ag2.proxy_resources.length).to eq 5
+
+          expect( LD4L::OreRDF::DestroyAggregation.call(@ag2) ).to be true
+          expect( LD4L::OreRDF::ResumeAggregation.call(@id2) ).to eq nil
+
+          # verify other objects are unchanged
+          ag1 = LD4L::OreRDF::ResumeAggregation.call(@id1)
+          expect( ag1.rdf_subject.to_s ).to eq @id1
+          expect( ag1.proxy_resources.length).to eq 3
+
+          ag3 = LD4L::OreRDF::ResumeAggregation.call(@id3)
+          expect( ag3.rdf_subject.to_s ).to eq @id3
+          expect( ag3.proxy_resources.length).to eq 0
+        end
+      end
+
+      context "and no proxies are persisted" do
+        it "should destroy aggregation resource and return true" do
+          LD4L::OreRDF::AddAggregatedResources.call(
+              @ag3,
+              [RDF::URI("http://example.org/individual/b31"),
+               RDF::URI("http://example.org/individual/b32")])
+          expect( @ag3.rdf_subject.to_s ).to eq @id3
+          expect( @ag3.proxy_resources.length).to eq 2
+
+          expect( LD4L::OreRDF::DestroyAggregation.call(@ag3) ).to be true
+          expect( LD4L::OreRDF::ResumeAggregation.call(@id3) ).to eq nil
+
+          # verify other objects are unchanged
+          ag1 = LD4L::OreRDF::ResumeAggregation.call(@id1)
+          expect( ag1.rdf_subject.to_s ).to eq @id1
+          expect( ag1.proxy_resources.length).to eq 3
+
+          ag2 = LD4L::OreRDF::ResumeAggregation.call(@id2)
+          expect( ag2.rdf_subject.to_s ).to eq @id2
+          expect( ag2.proxy_resources.length).to eq 3
+        end
+      end
+    end
+
+    context "when invalid parameters" do
+      it "should raise error if aggregation isn't LD4L::OreRDF::Aggregation" do
+        expect{ LD4L::OreRDF::DestroyAggregation.call('BAD VALUE') }.to raise_error(
+            ArgumentError,'aggregation must be an LD4L::OreRDF::Aggregation')
+        expect{ LD4L::OreRDF::DestroyAggregation.call(nil) }.to raise_error(
+            ArgumentError,'aggregation must be an LD4L::OreRDF::Aggregation')
+      end
+    end
+  end
+end

data/spec/ld4l/ore_rdf/services/aggregation/find_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::FindAggregations' do
+
+  describe "#call" do
+
+    context "when repository is empty" do
+      before do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+      it "should return an empty array" do
+        aggregations = LD4L::OreRDF::FindAggregations.call
+        expect(aggregations).to eq []
+      end
+    end
+
+    context "when repository has one aggregation" do
+      before do
+        p = LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith")
+        p.persist!
+
+        ag1 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag1",
+            title:       "Aggregation 1",
+            description: "Test description of aggregation 1.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag1,
+            [RDF::URI("http://example.org/individual/b11"),
+             RDF::URI("http://example.org/individual/b12"),
+             RDF::URI("http://example.org/individual/b13")])
+        LD4L::OreRDF::PersistAggregation.call(ag1)
+      end
+      after do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+
+      it "should return an array with 1 value" do
+        aggregations = LD4L::OreRDF::FindAggregations.call
+        expect(aggregations).to eq [ RDF::URI("http::/example.org/ag1") ]
+      end
+    end
+
+    context "when repository has multiple aggregations" do
+      before do
+        p = LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith")
+        p.persist!
+
+        ag1 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag1",
+            title:       "Aggregation 1",
+            description: "Test description of aggregation 1.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag1,
+            [RDF::URI("http://example.org/individual/b11"),
+             RDF::URI("http://example.org/individual/b12"),
+             RDF::URI("http://example.org/individual/b13")])
+        LD4L::OreRDF::PersistAggregation.call(ag1)
+
+        ag2 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag2",
+            title:       "Aggregation 2",
+            description: "Test description of aggregation 2.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag2,
+            [RDF::URI("http://example.org/individual/b21"),
+             RDF::URI("http://example.org/individual/b22"),
+             RDF::URI("http://example.org/individual/b23")])
+        LD4L::OreRDF::PersistAggregation.call(ag2)
+
+        ag3 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag3",
+            title:       "Aggregation 3",
+            description: "Test description of aggregation 3.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag3,
+            [RDF::URI("http://example.org/individual/b31"),
+             RDF::URI("http://example.org/individual/b32"),
+             RDF::URI("http://example.org/individual/b33")])
+        LD4L::OreRDF::PersistAggregation.call(ag3)
+      end
+      after do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+
+      xit "should find aggregation by rdf_subject" do
+
+
+        # TODO not sure how to write the criteria for this test
+
+
+        aggregations = LD4L::OreRDF::FindAggregations.call(:criteria => { :subject => "http::/example.org/ag3"})
+        expect(aggregations).not_to include "http::/example.org/ag1"
+        expect(aggregations).not_to include "http::/example.org/ag2"
+        expect(aggregations).to include "http::/example.org/ag3"
+        expect(aggregations.size).to eq 1
+      end
+
+      it "should find aggregation by literal criteria (aka title)" do
+        aggregations = LD4L::OreRDF::FindAggregations.call(:criteria => { RDF::DC.title => "Aggregation 2"})
+        expect(aggregations).not_to include "http::/example.org/ag1"
+        expect(aggregations).to include "http::/example.org/ag2"
+        expect(aggregations).not_to include "http::/example.org/ag3"
+        expect(aggregations.size).to eq 1
+      end
+
+      it "should find aggregation by rdf uri criteria (aka aggregates)" do
+        aggregations = LD4L::OreRDF::FindAggregations.call(
+            :criteria => { RDFVocabularies::ORE.aggregates => RDF::URI("http://example.org/individual/b32")})
+        expect(aggregations).not_to include "http::/example.org/ag1"
+        expect(aggregations).not_to include "http::/example.org/ag2"
+        expect(aggregations).to include "http::/example.org/ag3"
+        expect(aggregations.size).to eq 1
+      end
+
+      it "should return empty array when criteria (aka title) doesn't match any aggregations" do
+        aggregations = LD4L::OreRDF::FindAggregations.call(:criteria => { RDF::DC.title => "NON-EXISTENT TITLE"})
+        expect(aggregations).to eq []
+      end
+
+      it "should find all aggregations" do
+        aggregations = LD4L::OreRDF::FindAggregations.call
+        expect(aggregations).to include "http::/example.org/ag1"
+        expect(aggregations).to include "http::/example.org/ag2"
+        expect(aggregations).to include "http::/example.org/ag3"
+        expect(aggregations.size).to eq 3
+      end
+
+      it "should resume all aggregation & proxies when resume = true" do
+        aggregations = LD4L::OreRDF::FindAggregations.call(:resume => true)
+        ag_uris = ["http::/example.org/ag1","http::/example.org/ag2","http::/example.org/ag3"]
+        aggregations.each_key do |a|
+          expect(a).to be_kind_of(RDF::URI)
+          expect(aggregations[a]).to be_kind_of(LD4L::OreRDF::Aggregation)
+          expect(ag_uris).to include aggregations[a].aggregation_resource.rdf_subject.to_str
+        end
+        expect(aggregations.size).to eq 3
+      end
+
+      it "should return values for specified literal property in results when criteria specified" do
+        aggregations = LD4L::OreRDF::FindAggregations.call(
+            :criteria   => { RDF::DC.title => "Aggregation 2" },
+            :properties => { :description => RDF::DC.description } )
+        expect(aggregations).to eq ( { RDF::URI("http::/example.org/ag2") => {
+                                          :description => RDF::Literal("Test description of aggregation 2.") } } )
+      end
+
+      it "should return values for specified properties in results when criteria not specified" do
+        aggregations = LD4L::OreRDF::FindAggregations.call(
+            :properties => { :title => RDF::DC.title, :description => RDF::DC.description } )
+        expect(aggregations.size).to eq 3
+        expect(aggregations).to have_key RDF::URI("http::/example.org/ag1")
+        expect(aggregations).to have_key RDF::URI("http::/example.org/ag2")
+        expect(aggregations).to have_key RDF::URI("http::/example.org/ag3")
+        expect(aggregations[RDF::URI("http::/example.org/ag1")]).to eq( {
+            :title       => RDF::Literal("Aggregation 1"),
+            :description => RDF::Literal("Test description of aggregation 1.") } )
+        expect(aggregations[RDF::URI("http::/example.org/ag2")]).to eq( {
+            :title       => RDF::Literal("Aggregation 2"),
+            :description => RDF::Literal("Test description of aggregation 2.") } )
+        expect(aggregations[RDF::URI("http::/example.org/ag3")]).to eq( {
+            :title       => RDF::Literal("Aggregation 3"),
+            :description => RDF::Literal("Test description of aggregation 3.") } )
+      end
+
+
+      xit "should search another repository if specified" do
+        # TODO WRITE TEST
+      end
+    end
+
+    context "when arguments are invalid" do
+      it "should raise error when repository isn't a symbol" do
+        expect{ LD4L::OreRDF::FindAggregations.call(:repository => 'BAD VALUE') }.to raise_error(
+            ArgumentError,'repository must be a symbol')
+      end
+
+      it "should raise error when repository is a symbol, but isn't a registered repository" do
+        expect{ LD4L::OreRDF::FindAggregations.call(:repository => :nonexistent_repo) }.to raise_error(
+            ArgumentError,'repository must be a registered repository')
+      end
+
+      it "should raise error when resume is other than true or false" do
+        expect{ LD4L::OreRDF::FindAggregations.call(:resume => 'BAD VALUE') }.to raise_error(
+            ArgumentError,'resume must be true or false' )
+      end
+
+      xit "should raise error when criteria is other than nil or a Hash" do
+        expect{ LD4L::OreRDF::FindAggregations.call(:criteria => 'BAD VALUE') }.to raise_error(
+            ArgumentError,'criteria must be a hash of attribute-value pairs for searching for aggregations' )
+      end
+    end
+
+  end
+end