refactor: Bring lint config back to original strictness

2024-10-03 14:55:10 +00:00 · 2023-10-30 14:32:21 +01:00
parent 7a007dc466
commit 3bb3004abb
52 changed files with 239 additions and 132 deletions
--- a/test/integration/config/server-file.json
+++ b/test/integration/config/server-file.json
@@ -1,64 +1,64 @@
-{
-  "@context": "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^7.0.0/components/context.jsonld",
-  "import": [
-    "css:config/app/init/initialize-root.json",
-    "css:config/app/main/default.json",
-    "css:config/http/handler/default.json",
-    "css:config/http/middleware/default.json",
-    "css:config/http/notifications/disabled.json",
-    "css:config/http/server-factory/http.json",
-    "css:config/http/static/default.json",
-    "css:config/identity/access/public.json",
-
-    "css:config/identity/handler/default.json",
-    "css:config/identity/oidc/default.json",
-    "css:config/identity/ownership/token.json",
-    "css:config/identity/pod/static.json",
-    "css:config/ldp/authentication/dpop-bearer.json",
-    "css:config/ldp/authorization/webacl.json",
-    "css:config/ldp/handler/default.json",
-    "css:config/ldp/metadata-parser/default.json",
-    "css:config/ldp/metadata-writer/default.json",
-    "css:config/ldp/modes/default.json",
-    "css:config/storage/backend/file.json",
-    "css:config/storage/key-value/resource-store.json",
-    "css:config/storage/location/root.json",
-    "css:config/storage/middleware/default.json",
-    "css:config/util/auxiliary/acl.json",
-    "css:config/util/identifiers/suffix.json",
-    "css:config/util/index/default.json",
-    "css:config/util/logging/winston.json",
-    "css:config/util/representation-conversion/default.json",
-    "css:config/util/resource-locker/file.json",
-    "css:config/util/variables/default.json"
-  ],
-  "@graph": [
-    {
-      "@id": "urn:solid-server:test:Instances",
-      "@type": "RecordObject",
-      "record": [
-        {
-          "RecordObject:_record_key": "app",
-          "RecordObject:_record_value": { "@id": "urn:solid-server:default:App" }
-        },
-        {
-          "RecordObject:_record_key": "store",
-          "RecordObject:_record_value": { "@id": "urn:solid-server:default:ResourceStore_Backend" }
-        },
-        {
-          "RecordObject:_record_key": "locker",
-          "RecordObject:_record_value": { "@id": "urn:solid-server:default:FileSystemResourceLocker" }
-        }
-      ]
-    },
-    {
-      "@id": "urn:solid-server:default:EmailSender",
-      "@type": "BaseEmailSender",
-      "args_senderName": "Solid Server",
-      "args_emailConfig_host": "smtp.example.email",
-      "args_emailConfig_port": 587,
-      "args_emailConfig_auth_user": "alice@example.email",
-      "args_emailConfig_auth_pass": "NYEaCsqV7aVStRCbmC"
-    }
-  ]
-}
+{
+  "@context": "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^7.0.0/components/context.jsonld",
+  "import": [
+    "css:config/app/init/initialize-root.json",
+    "css:config/app/main/default.json",
+    "css:config/http/handler/default.json",
+    "css:config/http/middleware/default.json",
+    "css:config/http/notifications/disabled.json",
+    "css:config/http/server-factory/http.json",
+    "css:config/http/static/default.json",
+    "css:config/identity/access/public.json",
+
+    "css:config/identity/handler/default.json",
+    "css:config/identity/oidc/default.json",
+    "css:config/identity/ownership/token.json",
+    "css:config/identity/pod/static.json",
+    "css:config/ldp/authentication/dpop-bearer.json",
+    "css:config/ldp/authorization/webacl.json",
+    "css:config/ldp/handler/default.json",
+    "css:config/ldp/metadata-parser/default.json",
+    "css:config/ldp/metadata-writer/default.json",
+    "css:config/ldp/modes/default.json",
+    "css:config/storage/backend/file.json",
+    "css:config/storage/key-value/resource-store.json",
+    "css:config/storage/location/root.json",
+    "css:config/storage/middleware/default.json",
+    "css:config/util/auxiliary/acl.json",
+    "css:config/util/identifiers/suffix.json",
+    "css:config/util/index/default.json",
+    "css:config/util/logging/winston.json",
+    "css:config/util/representation-conversion/default.json",
+    "css:config/util/resource-locker/file.json",
+    "css:config/util/variables/default.json"
+  ],
+  "@graph": [
+    {
+      "@id": "urn:solid-server:test:Instances",
+      "@type": "RecordObject",
+      "record": [
+        {
+          "RecordObject:_record_key": "app",
+          "RecordObject:_record_value": { "@id": "urn:solid-server:default:App" }
+        },
+        {
+          "RecordObject:_record_key": "store",
+          "RecordObject:_record_value": { "@id": "urn:solid-server:default:ResourceStore_Backend" }
+        },
+        {
+          "RecordObject:_record_key": "locker",
+          "RecordObject:_record_value": { "@id": "urn:solid-server:default:FileSystemResourceLocker" }
+        }
+      ]
+    },
+    {
+      "@id": "urn:solid-server:default:EmailSender",
+      "@type": "BaseEmailSender",
+      "args_senderName": "Solid Server",
+      "args_emailConfig_host": "smtp.example.email",
+      "args_emailConfig_port": 587,
+      "args_emailConfig_auth_user": "alice@example.email",
+      "args_emailConfig_auth_pass": "NYEaCsqV7aVStRCbmC"
+    }
+  ]
+}
--- a/test/unit/authentication/BearerWebIdExtractor.test.ts
+++ b/test/unit/authentication/BearerWebIdExtractor.test.ts
@@ -25,7 +25,7 @@ describe('A BearerWebIdExtractor', (): void => {
  describe('on a request without Authorization header', (): void => {
    const request = {
      method: 'GET',
-      headers: { },
+      headers: {},
    } as any as HttpRequest;

    it('throws an error.', async(): Promise<void> => {
--- a/test/unit/authorization/AuthAuxiliaryReader.test.ts
+++ b/test/unit/authorization/AuthAuxiliaryReader.test.ts
@@ -44,7 +44,7 @@ describe('An AuthAuxiliaryReader', (): void => {

    const result = await reader.handle({ requestedModes, credentials });
    expect(result.get(acl1)).toEqual({ read: true, append: true, write: true, control: true });
-    expect(result.get(acl2)).toEqual({ });
+    expect(result.get(acl2)).toEqual({});

    const updatedMap = new IdentifierMap();
    updatedMap.set(subject1, new Set([ AclMode.control ]));
--- a/test/unit/authorization/ParentContainerReader.test.ts
+++ b/test/unit/authorization/ParentContainerReader.test.ts
@@ -39,7 +39,7 @@ describe('A ParentContainerReader', (): void => {

    const result = await reader.handle({ requestedModes, credentials });
    expect(result.get(target1)).toEqual({ create: true });
-    expect(result.get(target2)).toEqual({ });
+    expect(result.get(target2)).toEqual({});

    const updatedMap = new IdentifierSetMultiMap(requestedModes);
    updatedMap.set(parent1, AccessMode.append);
@@ -61,7 +61,7 @@ describe('A ParentContainerReader', (): void => {

    const result = await reader.handle({ requestedModes, credentials });
    expect(result.get(target1)).toEqual({ delete: true, write: true });
-    expect(result.get(target2)).toEqual({ });
+    expect(result.get(target2)).toEqual({});
    expect(result.get(target3)).toEqual({ write: true });

    const updatedMap = new IdentifierSetMultiMap(requestedModes);
--- a/test/unit/authorization/WebAclReader.test.ts
+++ b/test/unit/authorization/WebAclReader.test.ts
@@ -72,7 +72,7 @@ describe('A WebAclReader', (): void => {
  });

  it('handles all input.', async(): Promise<void> => {
-    await expect(reader.canHandle({ } as any)).resolves.toBeUndefined();
+    await expect(reader.canHandle({} as any)).resolves.toBeUndefined();
  });

  it('returns undefined permissions for undefined credentials.', async(): Promise<void> => {
--- a/test/unit/http/input/identifier/OriginalUrlExtractor.test.ts
+++ b/test/unit/http/input/identifier/OriginalUrlExtractor.test.ts
@@ -8,7 +8,7 @@ interface CreateExtractorArgs {
 }

 // Helper function for instantiating an OriginalUrlExtractor
-function createExtractor(args: CreateExtractorArgs = { }): OriginalUrlExtractor {
+function createExtractor(args: CreateExtractorArgs = {}): OriginalUrlExtractor {
  const identifierStrategy = new SingleRootIdentifierStrategy(args.baseUrl ?? 'http://test.com');
  const extractor = new OriginalUrlExtractor({ identifierStrategy, includeQueryString: args.includeQueryString });
  return extractor;
--- a/test/unit/http/output/BasicResponseWriter.test.ts
+++ b/test/unit/http/output/BasicResponseWriter.test.ts
@@ -60,7 +60,7 @@ describe('A BasicResponseWriter', (): void => {

  it('serializes metadata if there is metadata.', async(): Promise<void> => {
    result = { statusCode: 201, metadata: new RepresentationMetadata() };
-    metadataWriter.handle = jest.fn();
+    jest.spyOn(metadataWriter, 'handle').mockImplementation();
    await writer.handle({ response, result });
    expect(metadataWriter.handle).toHaveBeenCalledTimes(1);
    expect(metadataWriter.handle).toHaveBeenLastCalledWith({ response, metadata: result.metadata });
@@ -77,6 +77,7 @@ describe('A BasicResponseWriter', (): void => {
    result = { statusCode: 201, data };

    response = new PassThrough();
+    // eslint-disable-next-line jest/prefer-spy-on
    response.writeHead = jest.fn();

    const end = new Promise<void>((resolve): void => {
--- a/test/unit/http/output/metadata/AuxiliaryLinkMetadataWriter.test.ts
+++ b/test/unit/http/output/metadata/AuxiliaryLinkMetadataWriter.test.ts
@@ -30,13 +30,13 @@ describe('A LinkRelMetadataWriter', (): void => {
    const metadata = new RepresentationMetadata(identifier);

    await expect(writer.handle({ response, metadata })).resolves.toBeUndefined();
-    expect(response.getHeaders()).toEqual({ });
+    expect(response.getHeaders()).toEqual({});
  });

  it('does not add link headers for blank node identifiers.', async(): Promise<void> => {
    const response = createResponse() as HttpResponse;
    const metadata = new RepresentationMetadata();
    await expect(writer.handle({ response, metadata })).resolves.toBeUndefined();
-    expect(response.getHeaders()).toEqual({ });
+    expect(response.getHeaders()).toEqual({});
  });
 });
--- a/test/unit/http/output/metadata/ContentTypeMetadataWriter.test.ts
+++ b/test/unit/http/output/metadata/ContentTypeMetadataWriter.test.ts
@@ -15,7 +15,7 @@ describe('A ContentTypeMetadataWriter', (): void => {
  it('adds no header if there is no relevant metadata.', async(): Promise<void> => {
    const metadata = new RepresentationMetadata();
    await expect(writer.handle({ response, metadata })).resolves.toBeUndefined();
-    expect(response.getHeaders()).toEqual({ });
+    expect(response.getHeaders()).toEqual({});
  });

  it('adds a Content-Type header with parameters if present.', async(): Promise<void> => {
--- a/test/unit/http/output/metadata/RangeMetadataWriter.test.ts
+++ b/test/unit/http/output/metadata/RangeMetadataWriter.test.ts
@@ -37,7 +37,7 @@ describe('RangeMetadataWriter', (): void => {

  it('does nothing if there is no range metadata.', async(): Promise<void> => {
    await expect(writer.handle({ response, metadata })).resolves.toBeUndefined();
-    expect(response.getHeaders()).toEqual({ });
+    expect(response.getHeaders()).toEqual({});
  });

  it('adds a content-length header if the size is known.', async(): Promise<void> => {
--- a/test/unit/http/output/metadata/WacAllowMetadataWriter.test.ts
+++ b/test/unit/http/output/metadata/WacAllowMetadataWriter.test.ts
@@ -15,7 +15,7 @@ describe('A WacAllowMetadataWriter', (): void => {
  it('adds no header if there is no relevant metadata.', async(): Promise<void> => {
    const metadata = new RepresentationMetadata();
    await expect(writer.handle({ response, metadata })).resolves.toBeUndefined();
-    expect(response.getHeaders()).toEqual({ });
+    expect(response.getHeaders()).toEqual({});
  });

  it('adds a WAC-Allow header if there is relevant metadata.', async(): Promise<void> => {
--- a/test/unit/http/output/metadata/WwwAuthMetadataWriter.test.ts
+++ b/test/unit/http/output/metadata/WwwAuthMetadataWriter.test.ts
@@ -16,13 +16,13 @@ describe('A WwwAuthMetadataWriter', (): void => {
  it('adds no header if there is no relevant metadata.', async(): Promise<void> => {
    const metadata = new RepresentationMetadata();
    await expect(writer.handle({ response, metadata })).resolves.toBeUndefined();
-    expect(response.getHeaders()).toEqual({ });
+    expect(response.getHeaders()).toEqual({});
  });

  it('adds no header if the status code is not 401.', async(): Promise<void> => {
    const metadata = new RepresentationMetadata({ [HTTP.statusCodeNumber]: '403' });
    await expect(writer.handle({ response, metadata })).resolves.toBeUndefined();
-    expect(response.getHeaders()).toEqual({ });
+    expect(response.getHeaders()).toEqual({});
  });

  it('adds a WWW-Authenticate header if the status code is 401.', async(): Promise<void> => {
--- a/test/unit/identity/interaction/OidcControlHandler.test.ts
+++ b/test/unit/identity/interaction/OidcControlHandler.test.ts
@@ -12,6 +12,6 @@ describe('An OidcControlHandler', (): void => {
  });

  it('returns an empty object if there is no OIDC interaction.', async(): Promise<void> => {
-    await expect(handler.handle({ } as any)).resolves.toEqual({ json: { }});
+    await expect(handler.handle({} as any)).resolves.toEqual({ json: {}});
  });
 });
--- a/test/unit/identity/interaction/login/LogoutHandler.test.ts
+++ b/test/unit/identity/interaction/login/LogoutHandler.test.ts
@@ -27,7 +27,7 @@ describe('A LogoutHandler', (): void => {
    expect(outputMetadata?.get(SOLID_HTTP.terms.accountCookie)?.value).toBe(cookie);
    const date = outputMetadata?.get(SOLID_HTTP.terms.accountCookieExpiration);
    expect(date).toBeDefined();
-    expect(new Date(date!.value).getTime()).toBeLessThan(new Date().getTime());
+    expect(new Date(date!.value).getTime()).toBeLessThan(Date.now());
    expect(cookieStore.delete).toHaveBeenCalledTimes(1);
    expect(cookieStore.delete).toHaveBeenLastCalledWith(cookie);
  });
--- a/test/unit/identity/interaction/oidc/PromptHandler.test.ts
+++ b/test/unit/identity/interaction/oidc/PromptHandler.test.ts
@@ -17,7 +17,7 @@ describe('A PromptHandler', (): void => {
  });

  it('errors if there is no interaction.', async(): Promise<void> => {
-    await expect(handler.handle({ } as any)).rejects.toThrow(BadRequestHttpError);
+    await expect(handler.handle({} as any)).rejects.toThrow(BadRequestHttpError);
  });

  it('errors if the prompt is unsupported.', async(): Promise<void> => {
--- a/test/unit/logging/Logger.test.ts
+++ b/test/unit/logging/Logger.test.ts
@@ -3,7 +3,7 @@ import { BaseLogger, WrappingLogger } from '../../../src/logging/Logger';
 import type { LogMetadata, SimpleLogger } from '../../../src/logging/Logger';

 class DummyLogger extends BaseLogger {
-  log(): this {
+  public log(): this {
    return this;
  }
 }
--- a/test/unit/server/AuthorizingHttpHandler.test.ts
+++ b/test/unit/server/AuthorizingHttpHandler.test.ts
@@ -17,7 +17,7 @@ import { IdentifierMap, IdentifierSetMultiMap } from '../../../src/util/map/Iden
 import { SOLID_META } from '../../../src/util/Vocabularies';

 describe('An AuthorizingHttpHandler', (): void => {
-  const credentials = { };
+  const credentials = {};
  const target = { path: 'http://example.com/foo' };
  const requestedModes: AccessMap = new IdentifierSetMultiMap<AccessMode>(
    [[ target, new Set([ AccessMode.read, AccessMode.write ]) ]],
--- a/test/unit/storage/accessors/FileDataAccessor.test.ts
+++ b/test/unit/storage/accessors/FileDataAccessor.test.ts
@@ -485,7 +485,7 @@ describe('A FileDataAccessor', (): void => {
    });

    it('can delete the root container.', async(): Promise<void> => {
-      cache.data = { };
+      cache.data = {};
      await expect(accessor.deleteResource({ path: `${base}` })).resolves.toBeUndefined();
      expect(cache.data).toBeUndefined();
    });
--- a/test/unit/storage/accessors/SparqlDataAccessor.test.ts
+++ b/test/unit/storage/accessors/SparqlDataAccessor.test.ts
@@ -25,7 +25,7 @@ function simplifyQuery(query: string | string[]): string {
  if (Array.isArray(query)) {
    query = query.join(' ');
  }
-  return query.replace(/\n/gu, ' ').trim();
+  return query.replaceAll('\n', ' ').trim();
 }

 describe('A SparqlDataAccessor', (): void => {
--- a/test/unit/storage/conversion/BaseTypedRepresentationConverter.test.ts
+++ b/test/unit/storage/conversion/BaseTypedRepresentationConverter.test.ts
@@ -29,7 +29,7 @@ describe('A BaseTypedRepresentationConverter', (): void => {
  });

  it('can not handle input without a Content-Type.', async(): Promise<void> => {
-    const args: RepresentationConverterArgs = { representation: { metadata: { }}, preferences: {}} as any;
+    const args: RepresentationConverterArgs = { representation: { metadata: {}}, preferences: {}} as any;
    const converter = new CustomTypedRepresentationConverter('*/*', 'b/b');
    await expect(converter.canHandle(args)).rejects.toThrow(NotImplementedHttpError);
  });
--- a/test/unit/storage/conversion/ChainedConverter.test.ts
+++ b/test/unit/storage/conversion/ChainedConverter.test.ts
@@ -55,7 +55,7 @@ describe('A ChainedConverter', (): void => {

  it('needs at least 1 converter.', async(): Promise<void> => {
    expect((): any => new ChainedConverter([])).toThrow('At least 1 converter is required.');
-    expect(new ChainedConverter([ new DummyConverter({ }, { }) ])).toBeInstanceOf(ChainedConverter);
+    expect(new ChainedConverter([ new DummyConverter({}, {}) ])).toBeInstanceOf(ChainedConverter);
  });

  it('errors if there are no content-type or preferences.', async(): Promise<void> => {
@@ -106,7 +106,7 @@ describe('A ChainedConverter', (): void => {
    expect(result.metadata.contentType).toBe('b/b');
    expect(result.metadata.get(POSIX.terms.size)?.value).toBe('500');

-    args.preferences.type = { };
+    args.preferences.type = {};
    result = await converter.handle(args);
    expect(result.metadata.contentType).toBe('b/b');
    expect(result.metadata.get(POSIX.terms.size)?.value).toBe('500');
--- a/test/unit/storage/conversion/RdfToQuadConverter.test.ts
+++ b/test/unit/storage/conversion/RdfToQuadConverter.test.ts
@@ -43,7 +43,7 @@ describe('A RdfToQuadConverter', (): void => {
  });

  it('may not handle application/json to quad conversion.', async(): Promise<void> => {
-    await expect(converter.getOutputTypes('application/json')).resolves.toEqual({ });
+    await expect(converter.getOutputTypes('application/json')).resolves.toEqual({});
  });

  it('can handle turtle to quad conversions.', async(): Promise<void> => {
--- a/test/unit/storage/patch/RdfPatcher.test.ts
+++ b/test/unit/storage/patch/RdfPatcher.test.ts
@@ -39,7 +39,7 @@ describe('An RdfPatcher,', (): void => {
    };
    patcher.handle.mockImplementation(
      async(input: RepresentationPatcherInput<RdfDatasetRepresentation>):
-      Promise<RdfDatasetRepresentation> => Promise.resolve(input.representation!),
+      Promise<RdfDatasetRepresentation> => input.representation!,
    );

    rdfPatcher = new RdfPatcher(patcher);
--- a/test/util/Util.ts
+++ b/test/util/Util.ts
@@ -143,7 +143,7 @@ export function mockFileSystem(rootFilepath?: string, time?: Date): { data: any
      return { folder: cache, name: 'data' };
    }

-    const name = parts.slice(-1)[0];
+    const name = parts.at(-1) as string;
    parts = parts.slice(0, -1);
    let folder = cache.data;
    parts.forEach((part): any => {