From 9a897668580c5d75e4197ca09272759ab4fb5998 Mon Sep 17 00:00:00 2001
From: Ruben Verborgh <ruben@verborgh.org>
Date: Tue, 22 Dec 2020 00:08:02 +0100
Subject: [PATCH] test: Avoid unnecessary nesting.

---
 test/.eslintrc.js                             |   3 +-
 .../AuthenticatedLdpHandler.test.ts           | 302 ++++++++--------
 test/integration/Authorization.test.ts        |   2 +-
 test/integration/FullConfig.acl.test.ts       | 178 +++++-----
 test/integration/FullConfig.noAuth.test.ts    | 326 +++++++++---------
 test/integration/SparqlStorage.test.ts        |  68 ++--
 6 files changed, 434 insertions(+), 445 deletions(-)

diff --git a/test/.eslintrc.js b/test/.eslintrc.js
index 0362681bf..585742262 100644
--- a/test/.eslintrc.js
+++ b/test/.eslintrc.js
@@ -12,10 +12,11 @@ module.exports = {
     'no-process-env': 'off',
 
     // We are not using Mocha
-    'mocha/no-nested-tests': 'off',
     'mocha/no-exports': 'off',
+    'mocha/no-nested-tests': 'off',
     'mocha/no-skipped-tests': 'off',
     'mocha/no-synchronous-tests': 'off',
+    'mocha/no-top-level-hooks': 'off',
 
     // Need these 2 to run tests for throwing non-Error objects
     '@typescript-eslint/no-throw-literal': 'off',
diff --git a/test/integration/AuthenticatedLdpHandler.test.ts b/test/integration/AuthenticatedLdpHandler.test.ts
index 513e85194..4056c1bf0 100644
--- a/test/integration/AuthenticatedLdpHandler.test.ts
+++ b/test/integration/AuthenticatedLdpHandler.test.ts
@@ -19,169 +19,163 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
     ) as HttpHandler;
   });
 
-  describe('with simple handlers', (): void => {
-    it('can add, read and delete data based on incoming requests.', async(): Promise<void> => {
-      // POST
-      let requestUrl = new URL('http://test.com/');
-      let response: MockResponse<any> = await call(
-        handler,
-        requestUrl,
-        'POST',
-        { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
-        [ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ],
-      );
-      expect(response.statusCode).toBe(201);
-      expect(response._getData()).toHaveLength(0);
-      const id = response._getHeaders().location;
-      expect(id).toContain(url.format(requestUrl));
+  it('can add, read and delete data based on incoming requests.', async(): Promise<void> => {
+    // POST
+    let requestUrl = new URL('http://test.com/');
+    let response: MockResponse<any> = await call(
+      handler,
+      requestUrl,
+      'POST',
+      { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
+      [ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ],
+    );
+    expect(response.statusCode).toBe(201);
+    expect(response._getData()).toHaveLength(0);
+    const id = response._getHeaders().location;
+    expect(id).toContain(url.format(requestUrl));
 
-      // GET
-      requestUrl = new URL(id);
-      response = await call(
-        handler,
-        requestUrl,
-        'GET',
-        { accept: 'text/turtle' },
-        [],
-      );
-      expect(response.statusCode).toBe(200);
-      expect(response._getData()).toContain(
-        '<http://test.com/s> <http://test.com/p> <http://test.com/o>.',
-      );
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+    // GET
+    requestUrl = new URL(id);
+    response = await call(
+      handler,
+      requestUrl,
+      'GET',
+      { accept: 'text/turtle' },
+      [],
+    );
+    expect(response.statusCode).toBe(200);
+    expect(response._getData()).toContain(
+      '<http://test.com/s> <http://test.com/p> <http://test.com/o>.',
+    );
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
 
-      // DELETE
-      response = await call(handler, requestUrl, 'DELETE', {}, []);
-      expect(response.statusCode).toBe(205);
-      expect(response._getData()).toHaveLength(0);
+    // DELETE
+    response = await call(handler, requestUrl, 'DELETE', {}, []);
+    expect(response.statusCode).toBe(205);
+    expect(response._getData()).toHaveLength(0);
 
-      // GET
-      response = await call(
-        handler,
-        requestUrl,
-        'GET',
-        { accept: 'text/turtle' },
-        [],
-      );
-      expect(response.statusCode).toBe(404);
-      expect(response._getData()).toContain('NotFoundHttpError');
-    });
+    // GET
+    response = await call(
+      handler,
+      requestUrl,
+      'GET',
+      { accept: 'text/turtle' },
+      [],
+    );
+    expect(response.statusCode).toBe(404);
+    expect(response._getData()).toContain('NotFoundHttpError');
   });
 
-  describe('with simple PATCH handlers', (): void => {
-    it('can handle simple SPARQL updates.', async(): Promise<void> => {
-      // POST
-      let requestUrl = new URL('http://test.com/');
-      let response: MockResponse<any> = await call(
-        handler,
-        requestUrl,
-        'POST',
-        { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
-        [ '<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.',
-          '<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.' ],
-      );
-      expect(response.statusCode).toBe(201);
-      expect(response._getData()).toHaveLength(0);
-      const id = response._getHeaders().location;
-      expect(id).toContain(url.format(requestUrl));
+  it('can handle simple SPARQL updates.', async(): Promise<void> => {
+    // POST
+    let requestUrl = new URL('http://test.com/');
+    let response: MockResponse<any> = await call(
+      handler,
+      requestUrl,
+      'POST',
+      { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
+      [ '<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.',
+        '<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.' ],
+    );
+    expect(response.statusCode).toBe(201);
+    expect(response._getData()).toHaveLength(0);
+    const id = response._getHeaders().location;
+    expect(id).toContain(url.format(requestUrl));
 
-      // PATCH
-      requestUrl = new URL(id);
-      response = await call(
-        handler,
-        requestUrl,
-        'PATCH',
-        { 'content-type': 'application/sparql-update', 'transfer-encoding': 'chunked' },
-        [ 'DELETE { <http://test.com/s1> <http://test.com/p1> <http://test.com/o1> }',
-          'INSERT {<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>}',
-          'WHERE {}',
-        ],
-      );
-      expect(response.statusCode).toBe(205);
-      expect(response._getData()).toHaveLength(0);
+    // PATCH
+    requestUrl = new URL(id);
+    response = await call(
+      handler,
+      requestUrl,
+      'PATCH',
+      { 'content-type': 'application/sparql-update', 'transfer-encoding': 'chunked' },
+      [ 'DELETE { <http://test.com/s1> <http://test.com/p1> <http://test.com/o1> }',
+        'INSERT {<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>}',
+        'WHERE {}',
+      ],
+    );
+    expect(response.statusCode).toBe(205);
+    expect(response._getData()).toHaveLength(0);
 
-      // GET
-      requestUrl = new URL(id);
-      response = await call(
-        handler,
-        requestUrl,
-        'GET',
-        { accept: 'text/turtle' },
-        [],
-      );
-      expect(response.statusCode).toBe(200);
-      expect(response._getBuffer().toString()).toContain(
+    // GET
+    requestUrl = new URL(id);
+    response = await call(
+      handler,
+      requestUrl,
+      'GET',
+      { accept: 'text/turtle' },
+      [],
+    );
+    expect(response.statusCode).toBe(200);
+    expect(response._getBuffer().toString()).toContain(
+      '<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.',
+    );
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+    const parser = new Parser();
+    const triples = parser.parse(response._getBuffer().toString());
+    expect(triples).toBeRdfIsomorphic([
+      quad(
+        namedNode('http://test.com/s2'),
+        namedNode('http://test.com/p2'),
+        namedNode('http://test.com/o2'),
+      ),
+      quad(
+        namedNode('http://test.com/s3'),
+        namedNode('http://test.com/p3'),
+        namedNode('http://test.com/o3'),
+      ),
+    ]);
+  });
+
+  it('should overwrite the content on PUT request.', async(): Promise<void> => {
+    // POST
+    let requestUrl = new URL('http://test.com/');
+    let response: MockResponse<any> = await call(
+      handler,
+      requestUrl,
+      'POST',
+      { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
+      [
+        '<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.',
         '<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.',
-      );
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
-      const parser = new Parser();
-      const triples = parser.parse(response._getBuffer().toString());
-      expect(triples).toBeRdfIsomorphic([
-        quad(
-          namedNode('http://test.com/s2'),
-          namedNode('http://test.com/p2'),
-          namedNode('http://test.com/o2'),
-        ),
-        quad(
-          namedNode('http://test.com/s3'),
-          namedNode('http://test.com/p3'),
-          namedNode('http://test.com/o3'),
-        ),
-      ]);
-    });
-  });
+      ],
+    );
+    expect(response.statusCode).toBe(201);
+    expect(response._getData()).toHaveLength(0);
+    const id = response._getHeaders().location;
+    expect(id).toContain(url.format(requestUrl));
 
-  describe('with simple PUT handlers', (): void => {
-    it('should overwrite the content on PUT request.', async(): Promise<void> => {
-      // POST
-      let requestUrl = new URL('http://test.com/');
-      let response: MockResponse<any> = await call(
-        handler,
-        requestUrl,
-        'POST',
-        { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
-        [
-          '<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.',
-          '<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.',
-        ],
-      );
-      expect(response.statusCode).toBe(201);
-      expect(response._getData()).toHaveLength(0);
-      const id = response._getHeaders().location;
-      expect(id).toContain(url.format(requestUrl));
+    // PUT
+    requestUrl = new URL(id);
+    response = await call(
+      handler,
+      requestUrl,
+      'PUT',
+      { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
+      [ '<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>.' ],
+    );
+    expect(response.statusCode).toBe(205);
+    expect(response._getData()).toHaveLength(0);
 
-      // PUT
-      requestUrl = new URL(id);
-      response = await call(
-        handler,
-        requestUrl,
-        'PUT',
-        { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
-        [ '<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>.' ],
-      );
-      expect(response.statusCode).toBe(205);
-      expect(response._getData()).toHaveLength(0);
-
-      // GET
-      requestUrl = new URL(id);
-      response = await call(
-        handler,
-        requestUrl,
-        'GET',
-        { accept: 'text/turtle' },
-        [],
-      );
-      expect(response.statusCode).toBe(200);
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
-      const parser = new Parser();
-      const triples = parser.parse(response._getData());
-      expect(triples).toBeRdfIsomorphic([
-        quad(
-          namedNode('http://test.com/s3'),
-          namedNode('http://test.com/p3'),
-          namedNode('http://test.com/o3'),
-        ),
-      ]);
-    });
+    // GET
+    requestUrl = new URL(id);
+    response = await call(
+      handler,
+      requestUrl,
+      'GET',
+      { accept: 'text/turtle' },
+      [],
+    );
+    expect(response.statusCode).toBe(200);
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+    const parser = new Parser();
+    const triples = parser.parse(response._getData());
+    expect(triples).toBeRdfIsomorphic([
+      quad(
+        namedNode('http://test.com/s3'),
+        namedNode('http://test.com/p3'),
+        namedNode('http://test.com/o3'),
+      ),
+    ]);
   });
 });
diff --git a/test/integration/Authorization.test.ts b/test/integration/Authorization.test.ts
index 84f059df8..6be5a7584 100644
--- a/test/integration/Authorization.test.ts
+++ b/test/integration/Authorization.test.ts
@@ -61,7 +61,7 @@ describe('A server with authorization', (): void => {
     expect(response.statusCode).toBe(205);
   });
 
-  it('can not create new entries if not allowed.', async(): Promise<void> => {
+  it('cannot create new entries if not allowed.', async(): Promise<void> => {
     await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'authenticated');
 
     // POST
diff --git a/test/integration/FullConfig.acl.test.ts b/test/integration/FullConfig.acl.test.ts
index 8a8b8d234..000b8a825 100644
--- a/test/integration/FullConfig.acl.test.ts
+++ b/test/integration/FullConfig.acl.test.ts
@@ -26,100 +26,98 @@ const stores: [string, any][] = [
   }],
 ];
 
-describe.each(stores)('A server using %s', (name, { storeUrn, setup, teardown }): void => {
-  describe('with acl', (): void => {
-    let handler: HttpHandler;
-    let aclHelper: AclTestHelper;
-    let fileHelper: FileTestHelper;
+describe.each(stores)('An LDP handler with auth using %s', (name, { storeUrn, setup, teardown }): void => {
+  let handler: HttpHandler;
+  let aclHelper: AclTestHelper;
+  let fileHelper: FileTestHelper;
 
-    beforeAll(async(): Promise<void> => {
-      // Set up the internal store
-      await setup();
-      const variables: Record<string, any> = {
-        'urn:solid-server:default:variable:baseUrl': BASE,
-        'urn:solid-server:default:variable:rootFilePath': rootFilePath,
-      };
-      const internalStore = await instantiateFromConfig(
-        storeUrn,
-        'auth-ldp-handler.json',
-        variables,
-      ) as ResourceStore;
-      variables['urn:solid-server:default:variable:store'] = internalStore;
+  beforeAll(async(): Promise<void> => {
+    // Set up the internal store
+    await setup();
+    const variables: Record<string, any> = {
+      'urn:solid-server:default:variable:baseUrl': BASE,
+      'urn:solid-server:default:variable:rootFilePath': rootFilePath,
+    };
+    const internalStore = await instantiateFromConfig(
+      storeUrn,
+      'auth-ldp-handler.json',
+      variables,
+    ) as ResourceStore;
+    variables['urn:solid-server:default:variable:store'] = internalStore;
 
-      // Create and initialize the HTTP handler and related components
-      let initializer: Initializer;
-      let store: ResourceStore;
-      const instances = await instantiateFromConfig(
-        'urn:solid-server:test:Instances',
-        'auth-ldp-handler.json',
-        variables,
-      ) as Record<string, any>;
-      ({ handler, store, initializer } = instances);
-      await initializer.handleSafe();
+    // Create and initialize the HTTP handler and related components
+    let initializer: Initializer;
+    let store: ResourceStore;
+    const instances = await instantiateFromConfig(
+      'urn:solid-server:test:Instances',
+      'auth-ldp-handler.json',
+      variables,
+    ) as Record<string, any>;
+    ({ handler, store, initializer } = instances);
+    await initializer.handleSafe();
 
-      // Create test helpers for manipulating the components
-      aclHelper = new AclTestHelper(store, BASE);
-      fileHelper = new FileTestHelper(handler, new URL(BASE));
+    // Create test helpers for manipulating the components
+    aclHelper = new AclTestHelper(store, BASE);
+    fileHelper = new FileTestHelper(handler, new URL(BASE));
 
-      // Write test resource
-      await store.setRepresentation({ path: `${BASE}/permanent.txt` }, {
-        binary: true,
-        data: guardStream(createReadStream(join(__dirname, '../assets/permanent.txt'))),
-        metadata: new RepresentationMetadata({ [CONTENT_TYPE]: 'text/plain' }),
-      });
-    });
-
-    afterAll(async(): Promise<void> => {
-      await teardown();
-    });
-
-    it('can add a file to the store, read it and delete it if allowed.', async():
-    Promise<void> => {
-      // Set acl
-      await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'agent');
-
-      // Create file
-      let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain');
-      const id = response._getHeaders().location;
-
-      // Get file
-      response = await fileHelper.getFile(id);
-      expect(response.statusCode).toBe(200);
-      expect(response._getBuffer().toString()).toContain('TESTFILE2');
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
-
-      // DELETE file
-      await fileHelper.deleteResource(id);
-      await fileHelper.shouldNotExist(id);
-    });
-
-    it('can not add a file to the store if not allowed.', async():
-    Promise<void> => {
-      // Set acl
-      await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'authenticated');
-
-      // Try to create file
-      const response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
-      expect(response.statusCode).toBe(401);
-    });
-
-    it('can not add/delete, but only read files if allowed.', async():
-    Promise<void> => {
-      // Set acl
-      await aclHelper.setSimpleAcl({ read: true, write: false, append: false }, 'agent');
-
-      // Try to create file
-      let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
-      expect(response.statusCode).toBe(401);
-
-      // GET permanent file
-      response = await fileHelper.getFile('http://test.com/permanent.txt');
-      expect(response._getBuffer().toString()).toContain('TEST');
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
-
-      // Try to delete permanent file
-      response = await fileHelper.deleteResource('http://test.com/permanent.txt', true);
-      expect(response.statusCode).toBe(401);
+    // Write test resource
+    await store.setRepresentation({ path: `${BASE}/permanent.txt` }, {
+      binary: true,
+      data: guardStream(createReadStream(join(__dirname, '../assets/permanent.txt'))),
+      metadata: new RepresentationMetadata({ [CONTENT_TYPE]: 'text/plain' }),
     });
   });
+
+  afterAll(async(): Promise<void> => {
+    await teardown();
+  });
+
+  it('can add a file to the store, read it and delete it if allowed.', async():
+  Promise<void> => {
+    // Set acl
+    await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'agent');
+
+    // Create file
+    let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain');
+    const id = response._getHeaders().location;
+
+    // Get file
+    response = await fileHelper.getFile(id);
+    expect(response.statusCode).toBe(200);
+    expect(response._getBuffer().toString()).toContain('TESTFILE2');
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+
+    // DELETE file
+    await fileHelper.deleteResource(id);
+    await fileHelper.shouldNotExist(id);
+  });
+
+  it('can not add a file to the store if not allowed.', async():
+  Promise<void> => {
+    // Set acl
+    await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'authenticated');
+
+    // Try to create file
+    const response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
+    expect(response.statusCode).toBe(401);
+  });
+
+  it('can not add/delete, but only read files if allowed.', async():
+  Promise<void> => {
+    // Set acl
+    await aclHelper.setSimpleAcl({ read: true, write: false, append: false }, 'agent');
+
+    // Try to create file
+    let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
+    expect(response.statusCode).toBe(401);
+
+    // GET permanent file
+    response = await fileHelper.getFile('http://test.com/permanent.txt');
+    expect(response._getBuffer().toString()).toContain('TEST');
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+
+    // Try to delete permanent file
+    response = await fileHelper.deleteResource('http://test.com/permanent.txt', true);
+    expect(response.statusCode).toBe(401);
+  });
 });
diff --git a/test/integration/FullConfig.noAuth.test.ts b/test/integration/FullConfig.noAuth.test.ts
index 0166c833a..ed5059424 100644
--- a/test/integration/FullConfig.noAuth.test.ts
+++ b/test/integration/FullConfig.noAuth.test.ts
@@ -23,204 +23,202 @@ const stores: [string, any][] = [
   }],
 ];
 
-describe.each(stores)('A server using %s', (name, { storeUrn, setup, teardown }): void => {
-  describe('without acl', (): void => {
-    let handler: HttpHandler;
-    let fileHelper: FileTestHelper;
+describe.each(stores)('An LDP handler without auth using %s', (name, { storeUrn, setup, teardown }): void => {
+  let handler: HttpHandler;
+  let fileHelper: FileTestHelper;
 
-    beforeAll(async(): Promise<void> => {
-      // Set up the internal store
-      await setup();
-      const variables: Record<string, any> = {
-        'urn:solid-server:default:variable:baseUrl': BASE,
-        'urn:solid-server:default:variable:rootFilePath': rootFilePath,
-      };
-      const internalStore = await instantiateFromConfig(
-        storeUrn,
-        'auth-ldp-handler.json',
-        variables,
-      ) as ResourceStore;
-      variables['urn:solid-server:default:variable:store'] = internalStore;
+  beforeAll(async(): Promise<void> => {
+    // Set up the internal store
+    await setup();
+    const variables: Record<string, any> = {
+      'urn:solid-server:default:variable:baseUrl': BASE,
+      'urn:solid-server:default:variable:rootFilePath': rootFilePath,
+    };
+    const internalStore = await instantiateFromConfig(
+      storeUrn,
+      'auth-ldp-handler.json',
+      variables,
+    ) as ResourceStore;
+    variables['urn:solid-server:default:variable:store'] = internalStore;
 
-      // Create and initialize the HTTP handler and related components
-      let initializer: Initializer;
-      const instances = await instantiateFromConfig(
-        'urn:solid-server:test:Instances',
-        'auth-ldp-handler.json',
-        variables,
-      ) as Record<string, any>;
-      ({ handler, initializer } = instances);
-      await initializer.handleSafe();
+    // Create and initialize the HTTP handler and related components
+    let initializer: Initializer;
+    const instances = await instantiateFromConfig(
+      'urn:solid-server:test:Instances',
+      'auth-ldp-handler.json',
+      variables,
+    ) as Record<string, any>;
+    ({ handler, initializer } = instances);
+    await initializer.handleSafe();
 
-      // Create test helpers for manipulating the components
-      fileHelper = new FileTestHelper(handler, new URL(BASE));
-    });
+    // Create test helpers for manipulating the components
+    fileHelper = new FileTestHelper(handler, new URL(BASE));
+  });
 
-    afterAll(async(): Promise<void> => {
-      await teardown();
-    });
+  afterAll(async(): Promise<void> => {
+    await teardown();
+  });
 
-    it('can add a file to the store, read it and delete it.', async():
-    Promise<void> => {
-      // POST
-      let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfile0.txt', 'text/plain');
-      const id = response._getHeaders().location;
+  it('can add a file to the store, read it and delete it.', async():
+  Promise<void> => {
+    // POST
+    let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfile0.txt', 'text/plain');
+    const id = response._getHeaders().location;
 
-      // GET
-      response = await fileHelper.getFile(id);
-      expect(response.statusCode).toBe(200);
-      expect(response._getBuffer().toString()).toContain('TESTFILE0');
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+    // GET
+    response = await fileHelper.getFile(id);
+    expect(response.statusCode).toBe(200);
+    expect(response._getBuffer().toString()).toContain('TESTFILE0');
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
 
-      // DELETE
-      await fileHelper.deleteResource(id);
-      await fileHelper.shouldNotExist(id);
-    });
+    // DELETE
+    await fileHelper.deleteResource(id);
+    await fileHelper.shouldNotExist(id);
+  });
 
-    it('can add and overwrite a file.', async(): Promise<void> => {
-      let response = await fileHelper.createFile('../assets/testfile0.txt', 'file.txt', 'text/plain');
-      const id = response._getHeaders().location;
+  it('can add and overwrite a file.', async(): Promise<void> => {
+    let response = await fileHelper.createFile('../assets/testfile0.txt', 'file.txt', 'text/plain');
+    const id = response._getHeaders().location;
 
-      // GET
-      response = await fileHelper.getFile(id);
-      expect(response.statusCode).toBe(200);
-      expect(response._getBuffer().toString()).toContain('TESTFILE0');
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+    // GET
+    response = await fileHelper.getFile(id);
+    expect(response.statusCode).toBe(200);
+    expect(response._getBuffer().toString()).toContain('TESTFILE0');
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
 
-      // PUT
-      response = await fileHelper.overwriteFile('../assets/testfile1.txt', id, 'text/plain');
+    // PUT
+    response = await fileHelper.overwriteFile('../assets/testfile1.txt', id, 'text/plain');
 
-      // GET
-      response = await fileHelper.getFile(id);
-      expect(response.statusCode).toBe(200);
-      expect(response._getBuffer().toString()).toContain('TESTFILE1');
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+    // GET
+    response = await fileHelper.getFile(id);
+    expect(response.statusCode).toBe(200);
+    expect(response._getBuffer().toString()).toContain('TESTFILE1');
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
 
-      // DELETE
-      await fileHelper.deleteResource(id);
-      await fileHelper.shouldNotExist(id);
-    });
+    // DELETE
+    await fileHelper.deleteResource(id);
+    await fileHelper.shouldNotExist(id);
+  });
 
-    it('can create a folder and delete it.', async(): Promise<void> => {
-      // POST
-      let response = await fileHelper.createFolder('secondfolder/');
-      const id = response._getHeaders().location;
+  it('can create a folder and delete it.', async(): Promise<void> => {
+    // POST
+    let response = await fileHelper.createFolder('secondfolder/');
+    const id = response._getHeaders().location;
 
-      // GET
-      response = await fileHelper.getFolder(id);
-      expect(response.statusCode).toBe(200);
-      expect(response.getHeaders().link).toEqual(
-        [ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ],
-      );
+    // GET
+    response = await fileHelper.getFolder(id);
+    expect(response.statusCode).toBe(200);
+    expect(response.getHeaders().link).toEqual(
+      [ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ],
+    );
 
-      // DELETE
-      await fileHelper.deleteResource(id);
-      await fileHelper.shouldNotExist(id);
-    });
+    // DELETE
+    await fileHelper.deleteResource(id);
+    await fileHelper.shouldNotExist(id);
+  });
 
-    it('can make a folder and put a file in it.', async(): Promise<void> => {
-      // Create folder
-      await fileHelper.createFolder('testfolder0/');
+  it('can make a folder and put a file in it.', async(): Promise<void> => {
+    // Create folder
+    await fileHelper.createFolder('testfolder0/');
 
-      // Create file
-      let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder0/testfile0.txt', 'text/plain');
-      const id = response._getHeaders().location;
+    // Create file
+    let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder0/testfile0.txt', 'text/plain');
+    const id = response._getHeaders().location;
 
-      // GET File
-      response = await fileHelper.getFile(id);
-      expect(response.statusCode).toBe(200);
-      expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
+    // GET File
+    response = await fileHelper.getFile(id);
+    expect(response.statusCode).toBe(200);
+    expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
 
-      // DELETE
-      await fileHelper.deleteResource(id);
-      await fileHelper.shouldNotExist(id);
-      await fileHelper.deleteResource('http://test.com/testfolder0/');
-      await fileHelper.shouldNotExist('http://test.com/testfolder0/');
-    });
+    // DELETE
+    await fileHelper.deleteResource(id);
+    await fileHelper.shouldNotExist(id);
+    await fileHelper.deleteResource('http://test.com/testfolder0/');
+    await fileHelper.shouldNotExist('http://test.com/testfolder0/');
+  });
 
-    it('cannot remove a folder when the folder contains a file.', async(): Promise<void> => {
-      // Create folder
-      let response = await fileHelper.createFolder('testfolder1/');
-      const folderId = response._getHeaders().location;
+  it('cannot remove a folder when the folder contains a file.', async(): Promise<void> => {
+    // Create folder
+    let response = await fileHelper.createFolder('testfolder1/');
+    const folderId = response._getHeaders().location;
 
-      // Create file
-      await fileHelper.createFile('../assets/testfile0.txt', 'testfolder1/testfile0.txt', 'text/plain');
+    // Create file
+    await fileHelper.createFile('../assets/testfile0.txt', 'testfolder1/testfile0.txt', 'text/plain');
 
-      // Try DELETE folder
-      response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
-      expect(response.statusCode).toBe(409);
-      expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
+    // Try DELETE folder
+    response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
+    expect(response.statusCode).toBe(409);
+    expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
 
-      // DELETE
-      await fileHelper.deleteResource('http://test.com/testfolder1/testfile0.txt');
-      await fileHelper.shouldNotExist('http://test.com/testfolder1/testfile0.txt');
-      await fileHelper.deleteResource(folderId);
-      await fileHelper.shouldNotExist(folderId);
-    });
+    // DELETE
+    await fileHelper.deleteResource('http://test.com/testfolder1/testfile0.txt');
+    await fileHelper.shouldNotExist('http://test.com/testfolder1/testfile0.txt');
+    await fileHelper.deleteResource(folderId);
+    await fileHelper.shouldNotExist(folderId);
+  });
 
-    it('cannot remove a folder when the folder contains a subfolder.', async(): Promise<void> => {
-      // Create folder
-      let response = await fileHelper.createFolder('testfolder2/');
-      const folderId = response._getHeaders().location;
+  it('cannot remove a folder when the folder contains a subfolder.', async(): Promise<void> => {
+    // Create folder
+    let response = await fileHelper.createFolder('testfolder2/');
+    const folderId = response._getHeaders().location;
 
-      // Create subfolder
-      response = await fileHelper.createFolder('testfolder2/subfolder0');
-      const subFolderId = response._getHeaders().location;
+    // Create subfolder
+    response = await fileHelper.createFolder('testfolder2/subfolder0');
+    const subFolderId = response._getHeaders().location;
 
-      // Try DELETE folder
-      response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
-      expect(response.statusCode).toBe(409);
-      expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
+    // Try DELETE folder
+    response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
+    expect(response.statusCode).toBe(409);
+    expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
 
-      // DELETE
-      await fileHelper.deleteResource(subFolderId);
-      await fileHelper.shouldNotExist(subFolderId);
-      await fileHelper.deleteResource(folderId);
-      await fileHelper.shouldNotExist(folderId);
-    });
+    // DELETE
+    await fileHelper.deleteResource(subFolderId);
+    await fileHelper.shouldNotExist(subFolderId);
+    await fileHelper.deleteResource(folderId);
+    await fileHelper.shouldNotExist(folderId);
+  });
 
-    it('can read the contents of a folder.', async(): Promise<void> => {
-      // Create folder
-      let response = await fileHelper.createFolder('testfolder3/');
-      const folderId = response._getHeaders().location;
+  it('can read the contents of a folder.', async(): Promise<void> => {
+    // Create folder
+    let response = await fileHelper.createFolder('testfolder3/');
+    const folderId = response._getHeaders().location;
 
-      // Create subfolder
-      response = await fileHelper.createFolder('testfolder3/subfolder0/');
-      const subFolderId = response._getHeaders().location;
+    // Create subfolder
+    response = await fileHelper.createFolder('testfolder3/subfolder0/');
+    const subFolderId = response._getHeaders().location;
 
-      // Create file
-      response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder3/testfile0.txt', 'text/plain');
-      const fileId = response._getHeaders().location;
+    // Create file
+    response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder3/testfile0.txt', 'text/plain');
+    const fileId = response._getHeaders().location;
 
-      response = await fileHelper.getFolder(folderId);
-      expect(response.statusCode).toBe(200);
-      expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/subfolder0/> .');
-      expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/testfile0.txt> .');
-      expect(response.getHeaders().link).toEqual(
-        [ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ],
-      );
+    response = await fileHelper.getFolder(folderId);
+    expect(response.statusCode).toBe(200);
+    expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/subfolder0/> .');
+    expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/testfile0.txt> .');
+    expect(response.getHeaders().link).toEqual(
+      [ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ],
+    );
 
-      // DELETE
-      await fileHelper.deleteResource(fileId);
-      await fileHelper.shouldNotExist(fileId);
-      await fileHelper.deleteResource(subFolderId);
-      await fileHelper.shouldNotExist(subFolderId);
-      await fileHelper.deleteResource(folderId);
-      await fileHelper.shouldNotExist(folderId);
-    });
+    // DELETE
+    await fileHelper.deleteResource(fileId);
+    await fileHelper.shouldNotExist(fileId);
+    await fileHelper.deleteResource(subFolderId);
+    await fileHelper.shouldNotExist(subFolderId);
+    await fileHelper.deleteResource(folderId);
+    await fileHelper.shouldNotExist(folderId);
+  });
 
-    it('can upload and delete a image.', async(): Promise<void> => {
-      let response = await fileHelper.createFile('../assets/testimage.png', 'image.png', 'image/png');
-      const fileId = response._getHeaders().location;
+  it('can upload and delete a image.', async(): Promise<void> => {
+    let response = await fileHelper.createFile('../assets/testimage.png', 'image.png', 'image/png');
+    const fileId = response._getHeaders().location;
 
-      // GET
-      response = await fileHelper.getFile(fileId);
-      expect(response.statusCode).toBe(200);
-      expect(response._getHeaders()['content-type']).toBe('image/png');
+    // GET
+    response = await fileHelper.getFile(fileId);
+    expect(response.statusCode).toBe(200);
+    expect(response._getHeaders()['content-type']).toBe('image/png');
 
-      // DELETE
-      await fileHelper.deleteResource(fileId);
-      await fileHelper.shouldNotExist(fileId);
-    });
+    // DELETE
+    await fileHelper.deleteResource(fileId);
+    await fileHelper.shouldNotExist(fileId);
   });
 });
diff --git a/test/integration/SparqlStorage.test.ts b/test/integration/SparqlStorage.test.ts
index 23cf7a955..5f84daa89 100644
--- a/test/integration/SparqlStorage.test.ts
+++ b/test/integration/SparqlStorage.test.ts
@@ -2,44 +2,42 @@ import type { HttpHandler, Initializer, ResourceStore } from '../../src/';
 import { describeIf, FileTestHelper } from '../util/TestHelpers';
 import { BASE, instantiateFromConfig } from './Config';
 
-describeIf('docker', 'a server with a SPARQL endpoint as storage', (): void => {
-  describe('without acl', (): void => {
-    let handler: HttpHandler;
-    let fileHelper: FileTestHelper;
+describeIf('docker', 'A server with a SPARQL endpoint as storage', (): void => {
+  let handler: HttpHandler;
+  let fileHelper: FileTestHelper;
 
-    beforeAll(async(): Promise<void> => {
-      // Set up the internal store
-      const variables: Record<string, any> = {
-        'urn:solid-server:default:variable:baseUrl': BASE,
-        'urn:solid-server:default:variable:sparqlEndpoint': 'http://localhost:4000/sparql',
-      };
-      const internalStore = await instantiateFromConfig(
-        'urn:solid-server:default:SparqlResourceStore',
-        'auth-ldp-handler.json',
-        variables,
-      ) as ResourceStore;
-      variables['urn:solid-server:default:variable:store'] = internalStore;
+  beforeAll(async(): Promise<void> => {
+    // Set up the internal store
+    const variables: Record<string, any> = {
+      'urn:solid-server:default:variable:baseUrl': BASE,
+      'urn:solid-server:default:variable:sparqlEndpoint': 'http://localhost:4000/sparql',
+    };
+    const internalStore = await instantiateFromConfig(
+      'urn:solid-server:default:SparqlResourceStore',
+      'auth-ldp-handler.json',
+      variables,
+    ) as ResourceStore;
+    variables['urn:solid-server:default:variable:store'] = internalStore;
 
-      // Create and initialize the HTTP handler and related components
-      let initializer: Initializer;
-      const instances = await instantiateFromConfig(
-        'urn:solid-server:test:Instances',
-        'auth-ldp-handler.json',
-        variables,
-      ) as Record<string, any>;
-      ({ handler, initializer } = instances);
-      await initializer.handleSafe();
+    // Create and initialize the HTTP handler and related components
+    let initializer: Initializer;
+    const instances = await instantiateFromConfig(
+      'urn:solid-server:test:Instances',
+      'auth-ldp-handler.json',
+      variables,
+    ) as Record<string, any>;
+    ({ handler, initializer } = instances);
+    await initializer.handleSafe();
 
-      // Create test helpers for manipulating the components
-      fileHelper = new FileTestHelper(handler, new URL(BASE));
-    });
+    // Create test helpers for manipulating the components
+    fileHelper = new FileTestHelper(handler, new URL(BASE));
+  });
 
-    it('can add a Turtle file to the store.', async():
-    Promise<void> => {
-      // POST
-      const response = await fileHelper.createFile('../assets/person.ttl', 'person', 'text/turtle');
-      const id = response._getHeaders().location;
-      expect(id).toBeTruthy();
-    });
+  it('can add a Turtle file to the store.', async():
+  Promise<void> => {
+    // POST
+    const response = await fileHelper.createFile('../assets/person.ttl', 'person', 'text/turtle');
+    const id = response._getHeaders().location;
+    expect(id).toBeTruthy();
   });
 });