rdf-ldp 0.9.2 → 0.9.3

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

@@ -0,0 +1,370 @@
+require 'rdf/ldp/spec/resource'
+
+shared_examples 'an RDFSource' do
+  it_behaves_like 'a Resource'
+
+  let(:uri) { RDF::URI('http://ex.org/moomin') }
+  subject { described_class.new('http://ex.org/moomin') }
+  it { is_expected.to be_rdf_source }
+  it { is_expected.not_to be_non_rdf_source }
+
+  describe '#parse_graph' do
+    it 'raises UnsupportedMediaType if no reader found' do
+      expect { subject.send(:parse_graph, StringIO.new('graph'), 'text/fake') }
+        .to raise_error RDF::LDP::UnsupportedMediaType
+    end
+
+    it 'raises BadRequest if graph cannot be parsed' do
+      expect do
+        subject.send(:parse_graph,
+                     StringIO.new('graph'),
+                     'application/n-triples')
+      end.to raise_error RDF::LDP::BadRequest
+    end
+
+    describe 'parsing the graph' do
+      let(:graph) { RDF::Repository.new }
+
+      before do
+        graph << RDF::Statement(RDF::URI('http://ex.org/moomin'),
+                                RDF.type,
+                                RDF::Vocab::FOAF.Person,
+                                graph_name: subject.subject_uri)
+
+        10.times do
+          graph << RDF::Statement(RDF::Node.new,
+                                  RDF::Vocab::DC.creator,
+                                  RDF::Node.new,
+                                  graph_name: subject.subject_uri)
+        end
+      end
+
+      it 'parses turtle' do
+        expect(subject.send(:parse_graph,
+                            StringIO.new(graph.dump(:ttl)),
+                            'text/turtle'))
+          .to be_isomorphic_with graph
+      end
+
+      it 'parses ntriples' do
+        expect(subject.send(:parse_graph,
+                            StringIO.new(graph.dump(:ntriples)),
+                            'application/n-triples'))
+          .to be_isomorphic_with graph
+      end
+    end
+  end
+
+  describe '#etag' do
+    before do
+      subject.graph << statement
+      other.graph << statement
+    end
+
+    let(:other) { described_class.new(RDF::URI('http://ex.org/blah')) }
+
+    let(:statement) do
+      RDF::Statement(RDF::URI('http://ex.org/m'),
+                     RDF::Vocab::DC.title,
+                     'moomin')
+    end
+
+    it 'is the same for equal graphs' do
+      expect(subject.etag).to eq other.etag
+    end
+
+    xit 'is different for different graphs' do
+      subject.graph <<
+        RDF::Statement(RDF::Node.new, RDF::Vocab::DC.title, 'mymble')
+      expect(subject.etag).not_to eq other.etag
+    end
+  end
+
+  describe '#create' do
+    let(:subject) { described_class.new(RDF::URI('http://ex.org/m')) }
+    let(:graph) { RDF::Graph.new }
+
+    it 'does not create when graph fails to parse' do
+      begin
+        subject.create(StringIO.new(graph.dump(:ttl)), 'text/moomin')
+      rescue; end
+
+      expect(subject).not_to exist
+    end
+
+    it 'returns itself' do
+      expect(subject.create(StringIO.new(graph.dump(:ttl)), 'text/turtle'))
+        .to eq subject
+    end
+
+    it 'yields a transaction' do
+      expect do |b|
+        subject.create(StringIO.new(graph.dump(:ttl)), 'text/turtle', &b)
+      end.to yield_with_args(be_kind_of(RDF::Transaction))
+    end
+
+    it 'interprets NULL URI as this resource' do
+      graph << RDF::Statement(RDF::URI(), RDF::Vocab::DC.title, 'moomin')
+
+      created =
+        subject.create(StringIO.new(graph.dump(:ttl)), 'text/turtle').graph
+
+      expect(created)
+        .to have_statement RDF::Statement(subject.subject_uri,
+                                          RDF::Vocab::DC.title,
+                                          'moomin')
+    end
+
+    it 'interprets Relative URIs as this based on this resource' do
+      graph << RDF::Statement(subject.subject_uri,
+                              RDF::Vocab::DC.isPartOf,
+                              RDF::URI('#moomin'))
+
+      created =
+        subject.create(StringIO.new(graph.dump(:ttl)), 'text/turtle').graph
+
+      expect(created)
+        .to have_statement RDF::Statement(subject.subject_uri,
+                                          RDF::Vocab::DC.isPartOf,
+                                          subject.subject_uri / '#moomin')
+    end
+  end
+
+  describe '#update' do
+    let(:statement) do
+      RDF::Statement(subject.subject_uri, RDF::Vocab::DC.title, 'moomin')
+    end
+
+    let(:graph) { RDF::Graph.new << statement }
+    let(:content_type) { 'text/turtle' }
+
+    shared_examples 'updating rdf_sources' do
+      it 'changes the response' do
+        expect { subject.update(StringIO.new(graph.dump(:ttl)), content_type) }
+          .to change { subject.to_response }
+      end
+
+      it 'changes etag' do
+        expect { subject.update(StringIO.new(graph.dump(:ttl)), content_type) }
+          .to change { subject.etag }
+      end
+
+      it 'yields a transaction' do
+        expect do |b|
+          subject.update(StringIO.new(graph.dump(:ttl)), content_type, &b)
+        end.to yield_with_args(be_kind_of(RDF::Transaction))
+      end
+
+      context 'with bad media type' do
+        it 'raises UnsupportedMediaType' do
+          graph_io = StringIO.new(graph.dump(:ttl))
+
+          expect { subject.update(graph_io, 'text/moomin') }
+            .to raise_error RDF::LDP::UnsupportedMediaType
+        end
+
+        it 'does not update #last_modified' do
+          modified = subject.last_modified
+          begin
+            subject.update(StringIO.new(graph.dump(:ttl)), 'text/moomin')
+          rescue; end
+
+          expect(subject.last_modified).to eq modified
+        end
+      end
+    end
+
+    include_examples 'updating rdf_sources'
+
+    context 'when it exists' do
+      before { subject.create(StringIO.new, 'application/n-triples') }
+
+      include_examples 'updating rdf_sources'
+    end
+  end
+
+  describe '#patch' do
+    it 'raises UnsupportedMediaType when no media type is given' do
+      expect { subject.request(:patch, 200, {}, {}) }
+        .to raise_error RDF::LDP::UnsupportedMediaType
+    end
+
+    it 'gives PreconditionFailed when trying to update with wrong Etag' do
+      env = { 'HTTP_IF_MATCH' => 'not an Etag' }
+      expect { subject.request(:PATCH, 200, { 'abc' => 'def' }, env) }
+        .to raise_error RDF::LDP::PreconditionFailed
+    end
+
+    context 'ldpatch' do
+      it 'raises BadRequest when invalid document' do
+        env = { 'CONTENT_TYPE' => 'text/ldpatch',
+                'rack.input'   => StringIO.new('---invalid---') }
+        expect { subject.request(:patch, 200, {}, env) }
+          .to raise_error RDF::LDP::BadRequest
+      end
+
+      it 'handles patch' do
+        statement =
+          RDF::Statement(subject.subject_uri, RDF::Vocab::FOAF.name, 'Moomin')
+        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 change { subject.graph.statements.to_a }
+          .to(contain_exactly(statement))
+      end
+    end
+
+    context 'sparql update' do
+      it 'raises BadRequest when invalid document' do
+        env = { 'CONTENT_TYPE' => 'application/sparql-update',
+                'rack.input'   => StringIO.new('---invalid---') }
+
+        expect { subject.request(:patch, 200, {}, env) }
+          .to raise_error RDF::LDP::BadRequest
+      end
+
+      it 'runs sparql update' do
+        update = "INSERT DATA { #{subject.subject_uri.to_base} "\
+                 "#{RDF::Vocab::DC.title.to_base} 'moomin' . }"
+
+        env = { 'CONTENT_TYPE' => 'application/sparql-update',
+                'rack.input'   => StringIO.new(update) }
+
+        expect { subject.request(:patch, 200, {}, env) }
+          .to change { subject.graph.count }.from(0).to(1)
+      end
+    end
+  end
+
+  describe '#graph' do
+    it 'has a graph' do
+      expect(subject.graph).to be_a RDF::Enumerable
+    end
+  end
+
+  describe '#subject_uri' do
+    let(:uri) { RDF::URI('http://ex.org/moomin') }
+
+    it 'has a uri getter' do
+      expect(subject.subject_uri).to eq uri
+    end
+
+    it 'aliases to #to_uri' do
+      expect(subject.to_uri).to eq uri
+    end
+  end
+
+  describe '#to_response' do
+    it 'gives the graph minus context' do
+      expect(subject.to_response.graph_name).to eq nil
+    end
+  end
+
+  describe '#request' do
+    context 'with :GET' do
+      it 'gives the subject' do
+        expect(subject.request(:GET, 200, { 'abc' => 'def' }, {}))
+          .to contain_exactly(200, a_hash_including('abc' => 'def'), subject)
+      end
+
+      it 'does not call the graph' do
+        expect(subject).not_to receive(:graph)
+        subject.request(:GET, 200, { 'abc' => 'def' }, {})
+      end
+
+      it 'returns 410 GONE when destroyed' do
+        allow(subject).to receive(:destroyed?).and_return true
+        expect { subject.request(:GET, 200, { 'abc' => 'def' }, {}) }
+          .to raise_error RDF::LDP::Gone
+      end
+    end
+
+    context 'with :DELETE' do
+      before { subject.create(StringIO.new, 'application/n-triples') }
+
+      it 'returns 204' do
+        expect(subject.request(:DELETE, 200, {}, {}).first).to eq 204
+      end
+
+      it 'returns an empty body' do
+        expect(subject.request(:DELETE, 200, {}, {}).last)
+          .to be_empty
+      end
+
+      it 'marks resource as destroyed' do
+        expect { subject.request(:DELETE, 200, {}, {}) }
+          .to change { subject.destroyed? }.from(false).to(true)
+      end
+    end
+
+    context 'with :PUT',
+            if: described_class.private_method_defined?(:put) do
+      let(:graph) { RDF::Graph.new }
+      let(:env) do
+        { 'rack.input' => StringIO.new(graph.dump(:ntriples)),
+          'CONTENT_TYPE' => 'application/n-triples' }
+      end
+
+      it 'creates the resource' do
+        expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+          .to change { subject.exists? }.from(false).to(true)
+      end
+
+      it 'responds 201' do
+        expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env).first)
+          .to eq 201
+      end
+
+      it 'returns the etag' do
+        expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env)[1]['ETag'])
+          .to eq subject.etag
+      end
+
+      context 'when subject exists' do
+        before { subject.create(StringIO.new, 'application/n-triples') }
+
+        it 'responds 200' do
+          expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env))
+            .to contain_exactly(200, a_hash_including('abc' => 'def'), subject)
+        end
+
+        it 'replaces the graph with the input' do
+          graph <<
+            RDF::Statement(subject.subject_uri, RDF::Vocab::DC.title, 'moomin')
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to change { subject.graph.statements.count }.to(1)
+        end
+
+        it 'updates the etag' do
+          graph <<
+            RDF::Statement(subject.subject_uri, RDF::Vocab::DC.title, 'moomin')
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to change { subject.etag }
+        end
+
+        it 'returns the etag' do
+          expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env)[1]['ETag'])
+            .to eq subject.etag
+        end
+
+        it 'gives PreconditionFailed when trying to update with wrong Etag' do
+          env['HTTP_IF_MATCH'] = 'not an Etag'
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to raise_error RDF::LDP::PreconditionFailed
+        end
+
+        it 'succeeds when giving correct Etag' do
+          graph <<
+            RDF::Statement(subject.subject_uri, RDF::Vocab::DC.title, 'moomin')
+          env['HTTP_IF_MATCH'] = subject.etag
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to change { subject.graph.statements.count }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,242 @@
+require 'rspec'
+require 'rdf/spec'
+require 'rdf/spec/matchers'
+require 'timecop'
+
+shared_examples 'a Resource' do
+  describe '.to_uri' do
+    it { expect(described_class.to_uri).to be_a RDF::URI }
+  end
+
+  subject { described_class.new(uri) }
+  let(:uri) { RDF::URI 'http://example.org/moomin' }
+
+  it { is_expected.to be_ldp_resource }
+  it { is_expected.to respond_to :container? }
+  it { is_expected.to respond_to :rdf_source? }
+  it { is_expected.to respond_to :non_rdf_source? }
+
+  it { subject.send(:set_last_modified) }
+
+  describe '#exists?' do
+    it 'does not exist' do
+      expect(subject).not_to exist
+    end
+
+    context 'while existing' do
+      before { subject.create(StringIO.new, 'application/n-triples') }
+
+      subject          { described_class.new(uri, repository) }
+      let(:repository) { RDF::Repository.new }
+
+      it 'exists' do
+        expect(subject).to exist
+      end
+
+      it 'is different from same URI with trailing /' do
+        expect(described_class.new(uri + '/', repository)).not_to exist
+      end
+    end
+  end
+
+  describe '#allowed_methods' do
+    it 'responds to all methods returned' do
+      subject.allowed_methods.each do |method|
+        expect(subject.respond_to?(method.downcase, true)).to be true
+      end
+    end
+
+    it 'includes the MUST methods' do
+      expect(subject.allowed_methods).to include(:GET, :OPTIONS, :HEAD)
+    end
+  end
+
+  describe '#create' do
+    it 'accepts two args' do
+      expect(described_class.instance_method(:create).arity).to eq 2
+    end
+
+    describe 'modified time' do
+      before { Timecop.freeze }
+      after  { Timecop.return }
+
+      it 'sets last_modified' do
+        subject.create(StringIO.new, 'text/turtle')
+        expect(subject.last_modified).to eq DateTime.now
+      end
+    end
+
+    it 'adds a type triple to metagraph' do
+      subject.create(StringIO.new, 'application/n-triples')
+      expect(subject.metagraph)
+        .to have_statement RDF::Statement(subject.subject_uri,
+                                          RDF.type,
+                                          described_class.to_uri)
+    end
+
+    it 'yields a transaction' do
+      expect { |b| subject.create(StringIO.new, 'application/n-triples', &b) }
+        .to yield_with_args(be_kind_of(RDF::Transaction))
+    end
+
+    it 'marks resource as existing' do
+      expect { subject.create(StringIO.new, 'application/n-triples') }
+        .to change { subject.exists? }.from(false).to(true)
+    end
+
+    it 'returns self' do
+      expect(subject.create(StringIO.new, 'application/n-triples'))
+        .to eq subject
+    end
+
+    it 'raises Conlict when already exists' do
+      subject.create(StringIO.new, 'application/n-triples')
+      expect { subject.create(StringIO.new, 'application/n-triples') }
+        .to raise_error RDF::LDP::Conflict
+    end
+  end
+
+  describe '#update' do
+    it 'accepts two args' do
+      expect(described_class.instance_method(:update).arity).to eq 2
+    end
+
+    it 'returns self' do
+      expect(subject.update(StringIO.new, 'application/n-triples'))
+        .to eq subject
+    end
+
+    it 'yields a changeset' do
+      expect { |b| subject.update(StringIO.new, 'application/n-triples', &b) }
+        .to yield_with_args(be_kind_of(RDF::Transaction))
+    end
+  end
+
+  describe '#destroy' do
+    it 'accepts no args' do
+      expect(described_class.instance_method(:destroy).arity).to eq 0
+    end
+  end
+
+  describe '#metagraph' do
+    it 'returns a graph' do
+      expect(subject.metagraph).to be_a RDF::Graph
+    end
+
+    it 'has the metagraph name for the resource' do
+      expect(subject.metagraph.graph_name).to eq subject.subject_uri / '#meta'
+    end
+  end
+
+  describe '#etag' do
+    before { subject.create(StringIO.new, 'application/n-triples') }
+
+    it 'has an etag' do
+      expect(subject.etag).to be_a String
+    end
+
+    it 'updates etag on change' do
+      expect { subject.update(StringIO.new, 'application/n-triples') }
+        .to change { subject.etag }
+    end
+  end
+
+  describe '#last_modified' do
+    it 'returns nil when no dc:modified triple is present' do
+      expect(subject.last_modified).to be_nil
+    end
+
+    it 'raises an error when exists without dc:modified triple is present' do
+      allow(subject).to receive(:exists?).and_return true
+      expect { subject.last_modified }.to raise_error RDF::LDP::RequestError
+    end
+
+    context 'with dc:modified triple' do
+      before do
+        subject.metagraph.update([subject.subject_uri,
+                                  RDF::Vocab::DC.modified,
+                                  datetime])
+      end
+
+      let(:datetime) { DateTime.now }
+
+      it 'returns date in `dc:modified`' do
+        expect(subject.last_modified).to eq datetime
+      end
+    end
+  end
+
+  describe '#to_response' do
+    it 'returns an object that responds to #each' do
+      expect(subject.to_response).to respond_to :each
+    end
+  end
+
+  describe '#request' do
+    it 'sends the message to itself' do
+      expect(subject).to receive(:blah)
+      subject.request(:BLAH, 200, {}, {})
+    end
+
+    it 'raises MethodNotAllowed when method is unimplemented' do
+      allow(subject).to receive(:not_implemented)
+        .and_raise NotImplementedError
+      expect { subject.request(:not_implemented, 200, {}, {}) }
+        .to raise_error(RDF::LDP::MethodNotAllowed)
+    end
+
+    [:GET, :OPTIONS, :HEAD].each do |method|
+      it "responds to #{method}" do
+        expect(subject.request(method, 200, {}, {}).size).to eq 3
+      end
+    end
+
+    [:PATCH, :POST, :PUT, :DELETE, :TRACE, :CONNECT].each do |method|
+      it "responds to or errors on #{method}" do
+        g = RDF::Graph.new << [RDF::Node.new, RDF.type, 'moomin']
+        env = { 'CONTENT_TYPE' => 'application/n-triples',
+                'rack.input'   => StringIO.new(g.dump(:ntriples)) }
+
+        begin
+          response = subject.request(method, 200, {}, env)
+          expect(response.size).to eq 3
+        rescue => e
+          expect(e).to be_a RDF::LDP::RequestError
+        end
+      end
+    end
+
+    describe 'HTTP headers' do
+      before { subject.create(StringIO.new, 'text/turtle') }
+      let(:headers) { subject.request(:GET, 200, {}, {})[1] }
+
+      it 'has ETag' do
+        expect(headers['ETag']).to eq subject.etag
+      end
+
+      it 'has Last-Modified' do
+        expect(headers['Last-Modified']).to eq subject.last_modified.httpdate
+      end
+
+      it 'has Allow' do
+        expect(headers['Allow']).to be_a String
+      end
+
+      it 'has Link' do
+        expect(headers['Link']).to be_a String
+      end
+    end
+
+    it 'responds to :GET' do
+      expect { subject.request(:GET, 200, {}, {}) }.not_to raise_error
+    end
+
+    it 'responds to :HEAD' do
+      expect { subject.request(:OPTIONS, 200, {}, {}) }.not_to raise_error
+    end
+
+    it 'responds to :OPTIONS' do
+      expect { subject.request(:OPTIONS, 200, {}, {}) }.not_to raise_error
+    end
+  end
+end