rdf-ldp 0.9.2 → 2.1.0

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

@@ -0,0 +1,337 @@
+require 'rdf/ldp/spec/rdf_source'
+
+shared_examples 'a Container' do
+  it_behaves_like 'an RDFSource'
+
+  let(:uri) { RDF::URI('http://ex.org/moomin') }
+  subject { described_class.new(uri) }
+
+  it { is_expected.to be_container }
+
+  describe '#container_class' do
+    it 'returns a uri' do
+      expect(subject.container_class).to be_a RDF::URI
+    end
+  end
+
+  describe '#containment_triples' do
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+
+    it 'returns a uri' do
+      subject.add_containment_triple(resource)
+      expect(subject.containment_triples)
+        .to contain_exactly(an_instance_of(RDF::Statement))
+    end
+  end
+
+  describe '#add' do
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+    before { subject.create(StringIO.new, 'application/n-triples') }
+
+    it 'returns self' do
+      expect(subject.add(resource)).to eq subject
+    end
+
+    it 'containment triple is added to graph' do
+      expect(subject.add(resource).graph)
+        .to include subject.make_containment_triple(resource)
+    end
+  end
+
+  describe '#add_containment_triple' do
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+
+    it 'returns self' do
+      expect(subject.add_containment_triple(resource)).to eq subject
+    end
+
+    it 'containment triple is added to graph' do
+      expect(subject.add_containment_triple(resource).graph)
+        .to include subject.make_containment_triple(resource)
+    end
+  end
+
+  describe '#remove_containment_triple' do
+    before { subject.add_containment_triple(resource) }
+
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+
+    it 'returns self' do
+      expect(subject.remove_containment_triple(resource)).to eq subject
+    end
+
+    it 'membership triple is added to graph' do
+      expect(subject.remove_containment_triple(resource).graph)
+        .not_to include subject.make_containment_triple(resource)
+    end
+
+    it 'updates last_modified for container' do
+      expect { subject.remove_containment_triple(resource) }
+        .to change { subject.last_modified }
+    end
+
+    it 'updates etag for container' do
+      expect { subject.remove_containment_triple(resource) }
+        .to change { subject.etag }
+    end
+  end
+
+  describe '#make_containment_triple' do
+    let(:resource) { uri / 'papa' }
+
+    it 'returns a statement' do
+      expect(subject.make_containment_triple(resource)).to be_a RDF::Statement
+    end
+
+    it 'statement subject *or* object is #subject_uri' do
+      sub = subject.make_containment_triple(resource).subject
+      obj = subject.make_containment_triple(resource).object
+      expect([sub, obj]).to include subject.subject_uri
+    end
+
+    it 'converts Resource classes to URI' do
+      sub = subject.make_containment_triple(subject).subject
+      obj = subject.make_containment_triple(subject).object
+      expect([sub, obj]).to include subject.subject_uri
+    end
+  end
+
+  describe '#request' do
+    let(:graph) { RDF::Graph.new }
+
+    let(:env) do
+      { 'rack.input' => StringIO.new(graph.dump(:ntriples)),
+        'CONTENT_TYPE' => 'application/n-triples' }
+    end
+
+    let(:statement) do
+      RDF::Statement(subject.subject_uri,
+                     RDF::Vocab::LDP.contains,
+                     'moomin')
+    end
+
+    context 'with :PATCH',
+            if: described_class.private_method_defined?(:patch) do
+
+      it 'raises conflict error when editing containment triples' do
+        patch_statement = statement.clone
+        patch_statement.object = 'snorkmaiden'
+        patch = '@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .' \
+                "\n\nAdd { #{statement.subject.to_base} " \
+                "#{statement.predicate.to_base} #{statement.object.to_base} } ."
+        env = { 'CONTENT_TYPE' => 'text/ldpatch',
+                'rack.input'   => StringIO.new(patch) }
+
+        expect { subject.request(:patch, 200, {}, env) }
+          .to raise_error RDF::LDP::Conflict
+      end
+    end
+
+    context 'with :PUT',
+            if: described_class.private_method_defined?(:put) do
+      context 'when PUTing containment triples' do
+        it 'when creating a resource raises a Conflict error' do
+          graph << statement
+
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'when resource exists raises a Conflict error' do
+          subject.create(StringIO.new, 'application/n-triples')
+          graph << statement
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'can put existing containment triple' do
+          subject.create(StringIO.new, 'application/n-triples')
+          subject.graph << statement
+          graph << statement
+          expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env).first)
+            .to eq 200
+        end
+
+        it 'writes data when putting existing containment triple' do
+          subject.create(StringIO.new, 'application/n-triples')
+          subject.graph << statement
+          graph << statement
+
+          new_st = RDF::Statement(RDF::URI('http://example.org/new_moomin'),
+                                  RDF::Vocab::DC.title,
+                                  'moomin')
+          graph << new_st
+          expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env).last.graph)
+            .to have_statement new_st
+        end
+
+        it 'raises conflict error when without existing containment triples' do
+          subject.create(StringIO.new, 'application/n-triples')
+          subject.graph << statement
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+      end
+    end
+
+    context 'when POST is implemented',
+            if: described_class.private_method_defined?(:post) do
+      let(:graph) { RDF::Graph.new }
+      before { subject.create(StringIO.new, 'application/n-triples') }
+
+      let(:env) do
+        { 'rack.input' => StringIO.new(graph.dump(:ntriples)),
+          'CONTENT_TYPE' => 'application/n-triples' }
+      end
+
+      it 'returns status 201' do
+        expect(subject.request(:POST, 200, {}, env).first).to eq 201
+      end
+
+      it 'gives created resource as body' do
+        expect(subject.request(:POST, 200, {}, env).last)
+          .to be_a RDF::LDP::Resource
+      end
+
+      it 'generates an id' do
+        expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+          .to be_starts_with subject.subject_uri.to_s
+      end
+
+      it 'adds containment statement to resource' do
+        expect { subject.request(:POST, 200, {}, env) }
+          .to change { subject.containment_triples.count }.from(0).to(1)
+      end
+
+      it 'updates last_modified for container' do
+        expect { subject.request(:POST, 200, {}, env) }
+          .to change { subject.last_modified }
+      end
+
+      it 'updates etag for container' do
+        expect { subject.request(:POST, 200, {}, env) }
+          .to change { subject.etag }
+      end
+
+      context 'with Container interaction model' do
+        it 'creates a basic container' do
+          env['HTTP_LINK'] = "<#{RDF::LDP::Container.to_uri}>;rel=\"type\""
+          expect(subject.request(:POST, 200, {}, env).last)
+            .to be_a RDF::LDP::Container
+        end
+
+        context 'BasicContainer' do
+          it 'creates a basic container' do
+            env['HTTP_LINK'] =
+              '<http://www.w3.org/ns/ldp#BasicContainer>;rel="type"'
+            expect(subject.request(:POST, 200, {}, env).last)
+              .to be_a RDF::LDP::Container
+          end
+        end
+
+        context 'DirectContainer' do
+          it 'creates a direct container' do
+            env['HTTP_LINK'] =
+              "<#{RDF::LDP::DirectContainer.to_uri}>;rel=\"type\""
+
+            expect(subject.request(:POST, 200, {}, env).last)
+              .to be_a RDF::LDP::DirectContainer
+          end
+        end
+
+        context 'IndirectContainer' do
+          it 'creates a indirect container' do
+            env['HTTP_LINK'] =
+              "<#{RDF::LDP::IndirectContainer.to_uri}>;rel=\"type\""
+
+            expect(subject.request(:POST, 200, {}, env).last)
+              .to be_a RDF::LDP::IndirectContainer
+          end
+        end
+      end
+
+      context 'with a Slug' do
+        it 'creates resource with Slug' do
+          env['HTTP_SLUG'] = 'snork'
+          expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+            .to eq subject.subject_uri / env['HTTP_SLUG']
+        end
+
+        it 'mints a uri when empty Slug is given' do
+          env['HTTP_SLUG'] = ''
+          expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+            .to be_starts_with subject.subject_uri
+        end
+
+        it 'raises a 409 Conflict when slug is already taken' do
+          env['HTTP_SLUG'] = 'snork'
+          subject.request(:POST, 200, {}, env)
+
+          expect { subject.request(:POST, 200, {}, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'raises a 409 Conflict when slug is already taken but destroyed' do
+          env['HTTP_SLUG'] = 'snork'
+          created = subject.request(:POST, 200, {}, env).last
+          allow(created).to receive(:destroyed?).and_return true
+
+          expect { subject.request(:POST, 200, {}, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'raises a 406 NotAcceptable if slug has a uri fragment `#`' do
+          env['HTTP_SLUG'] = 'snork#maiden'
+
+          expect { subject.request(:POST, 200, {}, env) }
+            .to raise_error RDF::LDP::NotAcceptable
+        end
+
+        it 'url-encodes Slug' do
+          env['HTTP_SLUG'] = 'snork maiden'
+          expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+            .to eq subject.subject_uri / 'snork%20maiden'
+        end
+      end
+
+      context 'with graph content' do
+        before do
+          graph << RDF::Statement(uri, RDF::Vocab::DC.title, 'moomin')
+          graph << RDF::Statement(RDF::Node.new, RDF::Vocab::DC.creator, 'tove')
+          graph <<
+            RDF::Statement(RDF::Node.new, RDF.type, RDF::Vocab::FOAF.Person)
+        end
+
+        it 'parses graph into created resource' do
+          expect(subject.request(:POST, 200, {}, env).last.to_response)
+            .to be_isomorphic_with graph
+        end
+
+        it 'adds a Location header' do
+          expect(subject.request(:POST, 200, {}, env)[1]['Location'])
+            .to start_with subject.subject_uri.to_s
+        end
+
+        context 'with quads' do
+          let(:graph) do
+            RDF::Graph.new(graph_name: subject.subject_uri,
+                           data: RDF::Repository.new)
+          end
+
+          let(:env) do
+            { 'rack.input' => StringIO.new(graph.dump(:nquads)),
+              'CONTENT_TYPE' => 'application/n-quads' }
+          end
+
+          it 'parses graph into created resource without regard for context' do
+            context_free_graph = RDF::Graph.new
+            context_free_graph << graph.statements
+
+            expect(subject.request(:POST, 200, {}, env).last.to_response)
+              .to be_isomorphic_with context_free_graph
+          end
+        end
+      end
+    end
+  end
+end

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