rdf-ldp 0.9.2 → 0.9.3

data/lib/rdf/ldp/spec/direct_container.rb

@@ -0,0 +1,245 @@
+require 'rdf/ldp/spec/container'
+
+# @todo: make this set of examples less opinionated about #add behavior.
+#   Break #add tests into another group shared between DirectContainer &
+#   IndirectContainer. This way other implementations can use these specs
+#   but make different intrepretations of loose parts in the LDP spec.
+shared_examples 'a DirectContainer' do
+  it_behaves_like 'a Container'
+
+  let(:uri)  { RDF::URI('http://ex.org/moomin') }
+  let(:repo) { RDF::Repository.new }
+  subject    { described_class.new(uri, repo) }
+
+  let(:has_member_statement) do
+    RDF::Statement(subject.subject_uri,
+                   RDF::Vocab::LDP.hasMemberRelation,
+                   RDF::Vocab::DC.hasPart)
+  end
+
+  let(:is_member_of_statement) do
+    RDF::Statement(subject.subject_uri,
+                   RDF::Vocab::LDP.isMemberOfRelation,
+                   RDF::Vocab::DC.isPartOf)
+  end
+
+  describe '#add' do
+    let(:added)     { described_class.new(added_uri, repo) }
+    let(:added_uri) { RDF::URI('http://ex.org/too-ticky') }
+
+    context 'when the membership resource does not exist' do
+      before do
+        subject.create(StringIO.new, 'application/n-triples')
+
+        subject.graph.update has_member_statement
+        subject.graph.update RDF::Statement(subject.subject_uri,
+                                            RDF::Vocab::LDP.membershipResource,
+                                            membership_resource_uri)
+      end
+
+      let(:membership_resource_uri) do
+        RDF::URI('http://example.com/moomin_resource')
+      end
+
+      it 'adds membership triple to the container' do
+        expect { subject.add(added) }
+          .to change { subject.graph.statements }
+          .to include subject.make_membership_triple(added_uri)
+      end
+    end
+
+    context 'when the membership resource exists' do
+      before { subject.create(StringIO.new, 'application/n-triples') }
+
+      it 'adds membership triple to container' do
+        expect(subject.add(added).graph)
+          .to have_statement subject.make_membership_triple(added_uri)
+      end
+
+      it 'updates last_modified for membership resource' do
+        expect { subject.add(added).graph }
+          .to change { subject.last_modified }
+      end
+
+      it 'updates etag for for membership resource' do
+        expect { subject.add(added).graph }
+          .to change { subject.etag }
+      end
+
+      it 'adds membership triple to container for custom membership resource' do
+        repo = RDF::Repository.new
+        subject = described_class.new(uri, repo)
+        mem_rs = RDF::LDP::RDFSource.new(RDF::URI('http://ex.org/mymble'),
+                                         repo)
+
+        g = RDF::Graph.new << RDF::Statement(subject.subject_uri,
+                                             RDF::Vocab::LDP.membershipResource,
+                                             mem_rs.subject_uri)
+
+        subject.create(StringIO.new(g.dump(:ntriples)), 'application/n-triples')
+        mem_rs.create(StringIO.new, 'application/n-triples')
+
+        subject.add(added)
+
+        expect(subject.graph)
+          .to have_statement subject.make_membership_triple(added_uri)
+      end
+
+      it 'adds membership triple to membership resource with #fragment' do
+        repo = RDF::Repository.new
+        subject = described_class.new(uri, repo)
+
+        mem_rs = subject.subject_uri / '#membership'
+
+        g = RDF::Graph.new << RDF::Statement(subject.subject_uri,
+                                             RDF::Vocab::LDP.membershipResource,
+                                             mem_rs)
+
+        subject.create(StringIO.new(g.dump(:ttl)), 'application/n-triples')
+        expect(subject.add(added).graph)
+          .to have_statement subject.make_membership_triple(added_uri)
+      end
+
+      it 'adds membership triple to container for LDP-NR membership resource' do
+        repo = RDF::Repository.new
+        container = described_class.new(uri, repo)
+
+        nr = RDF::LDP::NonRDFSource.new('http://example.org/moomin_file',
+                                        repo)
+
+        g = RDF::Graph.new << RDF::Statement(subject.subject_uri,
+                                             RDF::Vocab::LDP.membershipResource,
+                                             nr.to_uri)
+
+        container
+          .create(StringIO.new(g.dump(:ntriples)), 'application/n-triples')
+
+        nr.create(StringIO.new, 'application/n-triples')
+
+        container.add(added)
+        expect(container.graph)
+          .to have_statement container.make_membership_triple(added_uri)
+      end
+
+      context 'with multiple membership resources' do
+        it 'raises an error' do
+          subject.graph << RDF::Statement(subject.subject_uri,
+                                          RDF::Vocab::LDP.membershipResource,
+                                          subject.subject_uri)
+          subject.graph << RDF::Statement(subject.subject_uri,
+                                          RDF::Vocab::LDP.membershipResource,
+                                          (subject.subject_uri / 'moomin'))
+
+          expect { subject.add(added) }
+            .to raise_error RDF::LDP::RequestError
+          expect(subject.containment_triples).to be_empty
+        end
+      end
+    end
+  end
+
+  describe '#remove' do
+    let(:added)     { described_class.new(added_uri, repo) }
+    let(:added_uri) { RDF::URI('http://ex.org/too-ticky') }
+
+    context 'when the membership resource exists' do
+      before { subject.create(StringIO.new, 'application/n-triples') }
+
+      it 'removes membership triple to membership resource' do
+        subject.graph << subject.make_membership_triple(added_uri)
+        expect(subject.remove(added_uri).graph)
+          .not_to have_statement subject.make_membership_triple(added_uri)
+      end
+    end
+  end
+
+  describe '#membership_constant_uri' do
+    it 'when created defaults to #subject_uri' do
+      subject.create(StringIO.new, 'application/n-triples')
+      expect(subject.membership_constant_uri).to eq subject.subject_uri
+      expect(subject.graph)
+        .to have_statement RDF::Statement(subject.subject_uri,
+                                          RDF::Vocab::LDP.membershipResource,
+                                          subject.subject_uri)
+    end
+
+    it 'gives membership resource' do
+      membership_resource = (subject.subject_uri / '#too-ticky')
+      subject.graph << RDF::Statement(subject.subject_uri,
+                                      RDF::Vocab::LDP.membershipResource,
+                                      membership_resource)
+      expect(subject.membership_constant_uri).to eq membership_resource
+    end
+
+    it 'raises an error if multiple are present' do
+      membership_resource = (subject.subject_uri / '#too-ticky')
+      subject.graph << RDF::Statement(subject.subject_uri,
+                                      RDF::Vocab::LDP.membershipResource,
+                                      membership_resource)
+
+      subject.graph << RDF::Statement(subject.subject_uri,
+                                      RDF::Vocab::LDP.membershipResource,
+                                      subject.subject_uri)
+
+      expect { subject.membership_constant_uri }
+        .to raise_error RDF::LDP::RequestError
+    end
+  end
+
+  describe '#membership_predicate' do
+    it 'when created returns a uri' do
+      subject.create(StringIO.new, 'application/n-triples')
+      expect(subject.membership_predicate).to be_a RDF::URI
+    end
+
+    it 'gives assigned member relation predicate for hasMember' do
+      subject.graph << has_member_statement
+
+      expect(subject.membership_predicate).to eq RDF::Vocab::DC.hasPart
+    end
+
+    it 'gives assigned member relation predicate for isMemberOf' do
+      subject.graph << is_member_of_statement
+
+      expect(subject.membership_predicate).to eq RDF::Vocab::DC.isPartOf
+    end
+
+    it 'raises an error if multiple relation predicates are present' do
+      subject.graph << has_member_statement
+      subject.graph << is_member_of_statement
+
+      expect { subject.membership_predicate }
+        .to raise_error RDF::LDP::RequestError
+    end
+  end
+
+  describe '#make_membership_triple' do
+    context 'with hasMember' do
+      before do
+        g = RDF::Graph.new << has_member_statement
+        subject.create(StringIO.new(g.dump(:ntriples)), 'application/n-triples')
+      end
+
+      it 'is constant - predicate - derived' do
+        expect(subject.make_membership_triple(uri))
+          .to eq RDF::Statement(subject.membership_constant_uri,
+                                subject.membership_predicate,
+                                uri)
+      end
+    end
+
+    context 'with isMemberOf' do
+      before do
+        g = RDF::Graph.new << is_member_of_statement
+        subject.create(StringIO.new(g.dump(:ntriples)), 'application/n-triples')
+      end
+
+      it 'is derived - predicate - constant' do
+        expect(subject.make_membership_triple(uri))
+          .to eq RDF::Statement(uri,
+                                subject.membership_predicate,
+                                subject.membership_constant_uri)
+      end
+    end
+  end
+end

data/lib/rdf/ldp/spec/indirect_container.rb

@@ -0,0 +1,152 @@
+require 'rdf/ldp/spec/direct_container'
+
+shared_examples 'an IndirectContainer' do
+  it_behaves_like 'a DirectContainer'
+
+  shared_context 'with a relation' do
+    before do
+      subject.create(StringIO.new(graph.dump(:ntriples)),
+                     'application/n-triples')
+    end
+
+    let(:graph) { RDF::Graph.new << inserted_content_statement }
+    let(:relation_predicate) { RDF::Vocab::DC.creator }
+
+    let(:inserted_content_statement) do
+      RDF::Statement(uri,
+                     RDF::Vocab::LDP.insertedContentRelation,
+                     relation_predicate)
+    end
+  end
+
+  describe '#inserted_content_relation' do
+    it 'returns a uri' do
+      subject.create(StringIO.new, 'application/n-triples')
+      expect(subject.inserted_content_relation).to be_a RDF::URI
+    end
+
+    context 'with a relation' do
+      include_context 'with a relation'
+
+      it 'gives the relation' do
+        expect(subject.inserted_content_relation).to eq relation_predicate
+      end
+
+      it 'raises an error when more than one exists' do
+        new_statement = inserted_content_statement.clone
+        new_statement.object = RDF::Vocab::DC.relation
+        subject.graph << new_statement
+        expect { subject.inserted_content_relation }
+          .to raise_error RDF::LDP::NotAcceptable
+      end
+    end
+  end
+
+  describe '#add' do
+    include_context 'with a relation'
+
+    subject { described_class.new(uri, repo) }
+
+    let(:repo) { RDF::Repository.new }
+    let(:resource_uri) { RDF::URI('http://example.org/too-ticky') }
+    let(:contained_resource) { RDF::LDP::RDFSource.new(resource_uri, repo) }
+
+    context 'when no derived URI is found' do
+      it 'raises NotAcceptable' do
+        expect { subject.add(contained_resource) }
+          .to raise_error RDF::LDP::NotAcceptable
+      end
+
+      it 'does not create the resource' do
+        begin; subject.add(contained_resource); rescue; end
+        expect(contained_resource).not_to exist
+      end
+    end
+
+    context 'with expected predicate' do
+      before { contained_resource.graph << statement }
+
+      let(:target_uri) { contained_resource.to_uri / '#me' }
+
+      let(:statement) do
+        RDF::Statement(contained_resource.to_uri,
+                       relation_predicate,
+                       target_uri)
+      end
+
+      it 'when membership resource does not exist raises NotAcceptable' do
+        new_resource = described_class.new(uri / 'new', repo)
+        expect { new_resource.add(contained_resource) }
+          .to raise_error RDF::LDP::NotAcceptable
+      end
+
+      context 'when the container exists' do
+        it 'adds membership triple' do
+          subject.add(contained_resource)
+          expect(subject.graph.statements)
+            .to include RDF::Statement(subject.to_uri,
+                                       subject.membership_predicate,
+                                       target_uri)
+        end
+
+        it 'for multiple predicates raises NotAcceptable' do
+          new_statement = statement.clone
+          new_statement.object = contained_resource.to_uri / '#you'
+          contained_resource.graph << new_statement
+          expect { subject.add(contained_resource) }
+            .to raise_error RDF::LDP::NotAcceptable
+        end
+
+        it 'for an LDP-NR raises NotAcceptable' do
+          nr_resource = RDF::LDP::NonRDFSource.new(resource_uri, repo)
+          expect { subject.add(nr_resource) }
+            .to raise_error RDF::LDP::NotAcceptable
+        end
+
+        context 'with membership resource' do
+          before do
+            subject.graph
+                   .delete([uri, RDF::Vocab::LDP.membershipResource, nil])
+            subject.graph << RDF::Statement(uri,
+                                            RDF::Vocab::LDP.membershipResource,
+                                            membership_resource)
+          end
+
+          let(:membership_resource) { uri }
+
+          it 'raises error when resource does not exist' do
+            new_resource = described_class.new(uri / 'new', repo)
+            expect { new_resource.add(contained_resource) }
+              .to raise_error RDF::LDP::NotAcceptable
+          end
+
+          context 'when the membership resource is not in the server' do
+            let(:membership_resource) { uri / '#me' }
+
+            it 'adds membership triple to container' do
+              contained_resource.create(StringIO.new, 'application/n-triples')
+              subject.add(contained_resource)
+
+              expect(subject.graph.statements)
+                .to include RDF::Statement(membership_resource,
+                                           subject.membership_predicate,
+                                           target_uri)
+            end
+
+            it 'removes membership triple to container' do
+              contained_resource.create(StringIO.new, 'application/n-triples')
+
+              subject.add(contained_resource)
+              subject.remove(contained_resource)
+
+              expect(subject.graph.statements)
+                .not_to include RDF::Statement(membership_resource,
+                                               subject.membership_predicate,
+                                               target_uri)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdf/ldp/spec/non_rdf_source.rb

@@ -0,0 +1,138 @@
+require 'rdf/ldp/spec/resource'
+
+shared_examples 'a NonRDFSource' do
+  it_behaves_like 'a Resource'
+
+  subject { described_class.new(uri) }
+  let(:uri) { RDF::URI 'http://example.org/moomin' }
+
+  let(:contents) { StringIO.new('mummi') }
+
+  after { subject.destroy }
+
+  describe '#non_rdf_source?' do
+    it { is_expected.to be_non_rdf_source }
+  end
+
+  describe '#create' do
+    it 'writes the input to body' do
+      subject.create(contents, 'text/plain')
+      contents.rewind
+      expect(subject.to_response.each.to_a).to eq contents.each.to_a
+    end
+
+    it 'sets #content_type' do
+      expect { subject.create(StringIO.new(''), 'text/plain') }
+        .to change { subject.content_type }.to('text/plain')
+    end
+
+    it 'persists to resource' do
+      repo = RDF::Repository.new
+      saved = described_class.new(uri, repo)
+
+      saved.create(contents, 'text/plain')
+      contents.rewind
+
+      loaded = RDF::LDP::Resource.find(uri, repo)
+      expect(loaded.to_response.each.to_a).to eq contents.each.to_a
+    end
+
+    it 'creates an LDP::RDFSource' do
+      repo = RDF::Repository.new
+      saved = described_class.new(uri, repo)
+      description = RDF::LDP::RDFSource.new(subject.description_uri, repo)
+
+      expect { saved.create(contents, 'text/plain') }
+        .to change { description.exists? }.from(false).to(true)
+    end
+  end
+
+  describe '#update' do
+    before { subject.create(contents, 'text/plain') }
+
+    it 'writes the input to body' do
+      new_contents = StringIO.new('snorkmaiden')
+      expect { subject.update(new_contents, 'text/plain') }
+        .to change { subject.to_response.to_a }
+        .from(a_collection_containing_exactly('mummi'))
+        .to(a_collection_containing_exactly('snorkmaiden'))
+    end
+
+    it 'updates #content_type' do
+      expect { subject.update(contents, 'text/prs.moomin') }
+        .to change { subject.content_type }
+        .from('text/plain').to('text/prs.moomin')
+    end
+  end
+
+  describe '#description' do
+    it 'is not found' do
+      expect { subject.description }.to raise_error RDF::LDP::NotFound
+    end
+
+    context 'when it exists' do
+      before { subject.create(StringIO.new(''), 'text/plain') }
+
+      it 'is an RDFSource' do
+        expect(subject.description).to be_rdf_source
+      end
+
+      it 'is the description uri' do
+        expect(subject.description.to_uri).to eq subject.description_uri
+      end
+    end
+  end
+
+  describe '#description_uri' do
+    it 'is a uri' do
+      expect(subject.description_uri).to be_a RDF::URI
+    end
+  end
+
+  describe '#storage' do
+    it 'sets a default storage adapter' do
+      expect(subject.storage).to be_a RDF::LDP::NonRDFSource::FileStorageAdapter
+    end
+
+    it 'explicitly sets a storage adapter' do
+      class DummyAdapter < RDF::LDP::NonRDFSource::FileStorageAdapter
+      end
+
+      dummy_subject = described_class.new(uri, nil, DummyAdapter)
+      expect(dummy_subject.storage).to be_a DummyAdapter
+    end
+  end
+
+  describe '#to_response' do
+    it 'gives an empty response if it is new' do
+      expect(subject.to_response.to_a).to eq []
+    end
+
+    it 'does not create a non-existant file' do
+      subject.to_response
+      expect(subject.storage.send(:file_exists?)).to be false
+    end
+  end
+
+  describe '#destroy' do
+    before { subject.create(contents, 'text/plain') }
+
+    it 'deletes the content' do
+      expect { subject.destroy }
+        .to change { subject.to_response.to_a }
+        .from(a_collection_containing_exactly('mummi')).to([])
+    end
+
+    it 'marks resource as destroyed' do
+      expect { subject.destroy }
+        .to change { subject.destroyed? }.from(false).to(true)
+    end
+  end
+
+  describe '#content_type' do
+    it 'sets and gets a content_type' do
+      expect { subject.content_type = 'text/plain' }
+        .to change { subject.content_type }.to('text/plain')
+    end
+  end
+end