Fix issues with PATCH providing FQURI as subject; add test fpr PUTting a

tree.

lakesuperior/endpoints/ldp.py

@@ -74,6 +74,8 @@ def bp_url_value_preprocessor(endpoint, values):
 
 @ldp.route('/<path:uuid>', methods=['GET'])
 @ldp.route('/', defaults={'uuid': None}, methods=['GET'], strict_slashes=False)
+@ldp.route('/<path:uuid>/fcr:metadata', defaults={'force_rdf' : True},
+        methods=['GET'])
 def get_resource(uuid, force_rdf=False):
     '''
     Retrieve RDF or binary content.
@@ -100,7 +102,7 @@ def get_resource(uuid, force_rdf=False):
     else:
         out_headers.update(rsrc.head())
         if isinstance(rsrc, LdpRs) \
-                or request.headers['accept'] in accept_rdf \
+                or is_accept_hdr_rdf_parsable() \
                 or force_rdf:
             return (rsrc.get(), out_headers)
         else:
@@ -108,14 +110,6 @@ def get_resource(uuid, force_rdf=False):
                     attachment_filename=rsrc.filename)
 
 
-@ldp.route('/<path:uuid>/fcr:metadata', methods=['GET'])
-def get_metadata(uuid):
-    '''
-    Retrieve RDF metadata of a LDP-NR.
-    '''
-    return get_resource(uuid, force_rdf=True)
-
-
 @ldp.route('/<path:parent>', methods=['POST'])
 @ldp.route('/', defaults={'parent': None}, methods=['POST'],
         strict_slashes=False)
@@ -157,6 +151,8 @@ def post_resource(parent):
 
 
 @ldp.route('/<path:uuid>', methods=['PUT'])
+@ldp.route('/<path:uuid>/fcr:metadata', defaults={'force_rdf' : True},
+        methods=['PUT'])
 def put_resource(uuid):
     '''
     Add a new resource at a specified URI.
@@ -194,7 +190,10 @@ def patch_resource(uuid):
     Update an existing resource with a SPARQL-UPDATE payload.
     '''
     headers = std_headers
-    rsrc = Ldpc(uuid)
+    rsrc = LdpRs(uuid)
+    if request.mimetype != 'application/sparql-update':
+        return 'Provided content type is not a valid parsable format: {}'\
+                .format(request.mimetype), 415
 
     try:
         rsrc.patch(request.get_data().decode('utf-8'))
@@ -208,6 +207,11 @@ def patch_resource(uuid):
     return '', 204, headers
 
 
+@ldp.route('/<path:uuid>/fcr:metadata', methods=['PATCH'])
+def patch_resource_metadata(uuid):
+    return patch_resource(uuid)
+
+
 @ldp.route('/<path:uuid>', methods=['DELETE'])
 def delete_resource(uuid):
     '''
@@ -369,6 +373,17 @@ def set_post_put_params():
     return handling, disposition
 
 
+def is_accept_hdr_rdf_parsable():
+    '''
+    Check if any of the 'Accept' header values provided is a RDF parsable
+    format.
+    '''
+    for mimetype in request.accept_mimetypes.values():
+        if Ldpr.is_rdf_parsable(mimetype):
+            return True
+    return False
+
+
 def parse_repr_options(retr_opts):
     '''
     Set options to retrieve IMR.

lakesuperior/model/ldpr.py

@@ -18,8 +18,7 @@ from rdflib.term import URIRef, Literal
 from lakesuperior.dictionaries.namespaces import ns_collection as nsc
 from lakesuperior.dictionaries.srv_mgd_terms import  srv_mgd_subjects, \
         srv_mgd_predicates, srv_mgd_types
-from lakesuperior.exceptions import (IncompatibleLdpTypeError,
-        InvalidResourceError, ResourceNotExistsError, ServerManagedTermError)
+from lakesuperior.exceptions import *
 from lakesuperior.store_layouts.ldp_rs.base_rdf_layout import BaseRdfLayout
 from lakesuperior.toolbox import Toolbox
 
@@ -178,7 +177,8 @@ class Ldpr(metaclass=ABCMeta):
             # Create container and populate it with provided RDF data.
             provided_g = Graph().parse(data=stream.read().decode('utf-8'),
                     format=mimetype, publicID=urn)
-            provided_imr = Resource(provided_g, urn)
+            local_g = Toolbox().localize_graph(provided_g)
+            provided_imr = Resource(local_g, urn)
 
             if Ldpr.MBR_RSRC_URI in provided_g.predicates() and \
                     Ldpr.MBR_REL_URI in provided_g.predicates():
@@ -861,7 +861,7 @@ class Ldpr(metaclass=ABCMeta):
         if '/' not in str(uri):
             imr.graph.add((nsc['fcsystem'].root, nsc['fcrepo'].contains, uri))
 
-        self.rdfly.create_rsrc(imr)
+        self.rdfly.modify_dataset(add_trp=imr.graph)
 
 
     def _add_ldp_dc_ic_rel(self, cont_uri):
@@ -904,7 +904,7 @@ class Ldpr(metaclass=ABCMeta):
             add_g = self._check_mgd_terms(add_g)
             self._logger.debug('Adding DC/IC triples: {}'.format(
                 add_g.serialize(format='turtle').decode('utf-8')))
-            rsrc._modify_rsrc(self.RES_UPDATED, add_trp=add_g)
+            self._modify_rsrc(self.RES_UPDATED, add_trp=add_g)
 
 
     def _send_event_msg(self, remove_trp, add_trp, metadata):

lakesuperior/toolbox.py

@@ -74,6 +74,38 @@ class Toolbox:
         return URIRef(self.localize_string(str(uri)))
 
 
+    def localize_graph(self, g):
+        '''
+        Locbalize a graph.
+        '''
+        q = '''
+        CONSTRUCT {{ ?s ?p ?o . }} WHERE {{
+          {{
+            ?s ?p ?o .
+            FILTER (
+              STRSTARTS(str(?s), "{0}")
+              ||
+              STRSTARTS(str(?o), "{0}")
+              ||
+              STRSTARTS(str(?s), "{0}/")
+              ||
+              STRSTARTS(str(?o), "{0}/")
+            ) .
+          }}
+        }}'''.format(self.base_url)
+        flt_g = g.query(q)
+
+        for t in flt_g:
+            local_s = self.localize_term(t[0])
+            local_o = self.localize_term(t[2]) \
+                    if isinstance(t[2], URIRef) \
+                    else t[2]
+            g.remove(t)
+            g.add((local_s, t[1], local_o))
+
+        return g
+
+
     def globalize_string(self, s):
         '''Convert URNs into URIs in a string using the application base URI.
 
@@ -102,7 +134,6 @@ class Toolbox:
         '''
         Globalize a graph.
         '''
-        from lakesuperior.model.ldpr import Ldpr
         q = '''
         CONSTRUCT {{ ?s ?p ?o . }} WHERE {{
           {{

tests/endpoints/test_ldp.py

@@ -56,6 +56,22 @@ class TestLdp:
         assert self.client.put(path).status_code == 204
 
 
+    def test_put_tree(self, client):
+        '''
+        PUT a resource with several path segments.
+
+        The test should create intermediate path segments that are not
+        accessible to PUT but allow POST.
+        '''
+        path = '/ldp/test_tree/a/b/c/d/e/f/g'
+        self.client.put(path)
+
+        assert self.client.get(path).resp.status_code == 200
+
+        assert self.client.put('/ldp/test_tree/a').resp.status_code == 409
+        assert self.client.post('/ldp/test_tree/a').resp.status_code == 201
+
+
     def test_put_ldp_rs(self, client):
         '''
         PUT a resource with RDF payload and verify.
@@ -187,13 +203,15 @@ class TestLdp:
 
         uri = Toolbox().base_url + '/test_patch01'
 
-        self.client.patch(path,
-                data=open('tests/data/sparql_update/simple_insert.sparql'),
-                headers={'content-type' : 'application/sparql-update'})
+        with open('tests/data/sparql_update/simple_insert.sparql') as data:
+            resp = self.client.patch(path,
+                    data=data,
+                    headers={'content-type' : 'application/sparql-update'})
+
+        assert resp.status_code == 204
 
         resp = self.client.get(path)
         g = Graph().parse(data=resp.data, format='text/turtle')
-        print('Triples after first PATCH: {}'.format(set(g)))
         assert g[ URIRef(uri) : nsc['dc'].title : Literal('Hello') ]
 
         self.client.patch(path,
@@ -205,6 +223,52 @@ class TestLdp:
         assert g[ URIRef(uri) : nsc['dc'].title : Literal('Ciao') ]
 
 
+    def test_patch_ldp_nr_metadata(self):
+        '''
+        Test patching a LDP-NR metadata resource, both from the fcr:metadata
+        and the resource URIs.
+        '''
+        path = '/ldp/ldpnr01'
+
+        with open('tests/data/sparql_update/simple_insert.sparql') as data:
+            self.client.patch(path + '/fcr:metadata',
+                    data=data,
+                    headers={'content-type' : 'application/sparql-update'})
+
+        resp = self.client.get(path + '/fcr:metadata')
+        assert resp.status_code == 200
+
+        uri = Toolbox().base_url + '/ldpnr01'
+        g = Graph().parse(data=resp.data, format='text/turtle')
+        assert g[ URIRef(uri) : nsc['dc'].title : Literal('Hello') ]
+
+        with open(
+                'tests/data/sparql_update/delete+insert+where.sparql') as data:
+            patch_resp = self.client.patch(path,
+                    data=data,
+                    headers={'content-type' : 'application/sparql-update'})
+        assert patch_resp.status_code == 204
+
+        resp = self.client.get(path + '/fcr:metadata')
+        assert resp.status_code == 200
+
+        g = Graph().parse(data=resp.data, format='text/turtle')
+        assert g[ URIRef(uri) : nsc['dc'].title : Literal('Ciao') ]
+
+
+    def test_patch_ldp_nr(self, rnd_img):
+        '''
+        Verify that a PATCH using anything other than an
+        `application/sparql-update` MIME type results in an error.
+        '''
+        rnd_img['content'].seek(0)
+        resp = self.client.patch('/ldp/ldpnr01/fcr:metadata',
+                data=rnd_img,
+                headers={'content-type' : 'image/jpeg'})
+
+        assert resp.status_code == 415
+
+
     def test_delete(self):
         '''
         Test delete response codes.