@internetarchive/metadata-service 0.0.1-alpha.1

package/test/metadata-service.test.ts

@@ -0,0 +1,150 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expect } from '@open-wc/testing';
+
+import { MockResponseGenerator } from './mock-response-generator';
+import { MetadataResponse } from '../src/responses/metadata-response';
+import { Result } from '@internetarchive/result-type';
+import { MetadataBackendInterface } from '../src/backend/metadata-backend-interface';
+import {
+  MetadataServiceError,
+  MetadataServiceErrorType,
+} from '../src/metadata-service-error';
+import { MetadataService } from '../src/metadata-service';
+
+describe('MetadataService', () => {
+  it('can request metadata when requested', async () => {
+    class MockMetadataBackend implements MetadataBackendInterface {
+      async fetchMetadata(
+        identifier: string
+      ): Promise<Result<MetadataResponse, MetadataServiceError>> {
+        const responseGenerator = new MockResponseGenerator();
+        const mockResponse =
+          responseGenerator.generateMockMetadataResponse(identifier);
+        return { success: mockResponse };
+      }
+    }
+
+    const backend = new MockMetadataBackend();
+    const service = new MetadataService(backend);
+    const result = await service.fetchMetadata('foo');
+    expect(result.success?.metadata.identifier).to.equal('foo');
+  });
+
+  describe('requestMetadataValue', async () => {
+    class MockMetadataBackend implements MetadataBackendInterface {
+      response: any;
+      async fetchMetadata(
+        identifier: string,
+        keypath?: string
+      ): Promise<Result<any, MetadataServiceError>> {
+        return {
+          success: {
+            result: this.response,
+          },
+        };
+      }
+    }
+
+    it('can request a metadata value', async () => {
+      const backend = new MockMetadataBackend();
+      const service = new MetadataService(backend);
+
+      let expectedResult: any = 'foo';
+      backend.response = expectedResult;
+
+      let result = await service.fetchMetadataValue<typeof expectedResult>(
+        'foo',
+        'metadata'
+      );
+      expect(result.success).to.equal(expectedResult);
+
+      expectedResult = { foo: 'bar' };
+      backend.response = expectedResult;
+
+      result = await service.fetchMetadataValue<typeof expectedResult>(
+        'foo',
+        'metadata'
+      );
+      expect(result.success).to.equal(expectedResult);
+      expect(result.success.foo).to.equal('bar');
+    });
+  });
+
+  it('returns an error result if the item is not found', async () => {
+    class MockSearchBackend implements MetadataBackendInterface {
+      async fetchMetadata(
+        identifier: string
+      ): Promise<Result<MetadataResponse, MetadataServiceError>> {
+        // this is unfortunate.. instead of getting an http 404 error,
+        // we get an empty JSON object when an item is not found
+        return { success: {} as any };
+      }
+    }
+
+    const backend = new MockSearchBackend();
+    const service = new MetadataService(backend);
+    const result = await service.fetchMetadata('foo');
+    expect(result.error).to.not.equal(undefined);
+    expect(result.error?.type).to.equal(MetadataServiceErrorType.itemNotFound);
+
+    const valueResult = await service.fetchMetadataValue('foo', 'metadata');
+    expect(valueResult.error).to.not.equal(undefined);
+    expect(valueResult.error?.type).to.equal(
+      MetadataServiceErrorType.itemNotFound
+    );
+  });
+
+  it('returns the network error if one occurs', async () => {
+    class MockSearchBackend implements MetadataBackendInterface {
+      async fetchMetadata(
+        identifier: string
+      ): Promise<Result<MetadataResponse, MetadataServiceError>> {
+        const error = new MetadataServiceError(
+          MetadataServiceErrorType.networkError,
+          'network error'
+        );
+        return { error };
+      }
+    }
+
+    const backend = new MockSearchBackend();
+    const service = new MetadataService(backend);
+    const metadataResult = await service.fetchMetadata('foo');
+    expect(metadataResult.error).to.not.equal(undefined);
+    expect(metadataResult.error?.type).to.equal(
+      MetadataServiceErrorType.networkError
+    );
+    expect(metadataResult.error?.message).to.equal('network error');
+
+    const metadataValueResult = await service.fetchMetadataValue('foo', 'bar');
+    expect(metadataValueResult.error).to.not.equal(undefined);
+    expect(metadataValueResult.error?.type).to.equal(
+      MetadataServiceErrorType.networkError
+    );
+    expect(metadataValueResult.error?.message).to.equal('network error');
+  });
+
+  it('returns a decoding error if one occurs', async () => {
+    class MockSearchBackend implements MetadataBackendInterface {
+      async fetchMetadata(
+        identifier: string
+      ): Promise<Result<MetadataResponse, MetadataServiceError>> {
+        const error = new MetadataServiceError(
+          MetadataServiceErrorType.decodingError,
+          'decoding error'
+        );
+        return { error };
+      }
+    }
+
+    const backend = new MockSearchBackend();
+    const service = new MetadataService(backend);
+    const metadataResult = await service.fetchMetadata('foo');
+    expect(metadataResult.error).to.not.equal(undefined);
+    expect(metadataResult.error?.type).to.equal(
+      MetadataServiceErrorType.decodingError
+    );
+    expect(metadataResult.error?.message).to.equal('decoding error');
+  });
+});

package/test/mock-response-generator.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class MockResponseGenerator {
+  generateMockMetadataResponse(identifier: string): any {
+    return {
+      created: 1586477049,
+      d1: 'ia600201.us.archive.org',
+      d2: 'ia800201.us.archive.org',
+      dir: '/27/items/rss-383924main_TWAN_09_04_09',
+      files: [
+        {
+          name: 'foo.jpg',
+          source: 'derivative',
+          format: 'Thumbnail',
+          original: 'foo.mp4',
+          md5: '48067b43a547d3e90cb433a04ba84d5d',
+          mtime: '1256675427',
+          size: '1135',
+          crc32: '40870038',
+          sha1: '6445c2a6f51c8314c1872ec1f7daf33c5cfabd06',
+        },
+        {
+          name: 'bar.jpg',
+          source: 'derivative',
+          format: 'Thumbnail',
+          original: 'bar.mp4',
+          md5: '5bf69912d7b796fe309cde32e61230bc',
+          mtime: '1256675429',
+          size: '6329',
+          crc32: 'ba5f361a',
+          sha1: 'cddab0e2daab29978e5efdeff735240a44aa7c80',
+        },
+      ],
+      files_count: 2,
+      item_last_updated: 1463797130,
+      item_size: 99872691,
+      metadata: {
+        feed_id:
+          '/0/rss_feeds/NASACast_Video/nasacast_video:sts128_landing/NASAcast_vodcast.rss',
+        mediatype: 'movies',
+        title: "NASA TV's This Week @NASA, September 4",
+        description: "NASA TV's This Week @NASA, September 4",
+        creator: 'NASA',
+        source: 'http://www.nasa.gov/multimedia/podcasting/twan_09_04_09.html',
+        date: '9/4/2009',
+        year: '2009',
+        rights: 'Public Domain',
+        language: 'en-us',
+        updater: 'BonnieReal',
+        updatedate: '2009-10-27 20:23:01',
+        identifier,
+        uploader: 'bonnie@archive.org',
+        addeddate: '2009-10-27 20:25:55',
+        publicdate: '2009-10-27 20:41:27',
+        collection: ['nasa', 'nasacastvideo'],
+        backup_location: 'ia903604_7',
+      },
+      server: 'ia800201.us.archive.org',
+      uniq: 162444403,
+      workable_servers: ['ia800201.us.archive.org', 'ia600201.us.archive.org'],
+    };
+  }
+}

package/test/models/file.test.ts

@@ -0,0 +1,10 @@
+import { expect } from '@open-wc/testing';
+
+import { File } from '../../src/models/file';
+
+describe('File', () => {
+  it('can be instantiated with an object', async () => {
+    const file = new File({ name: 'foo.jpg' });
+    expect(file.name).to.equal('foo.jpg');
+  });
+});

package/test/models/metadata-fields/list-field.test.ts

@@ -0,0 +1,64 @@
+import { expect } from '@open-wc/testing';
+import {
+  NumberListField,
+  StringListField,
+} from '../../../src/models/metadata-fields/field-types/list';
+
+describe('List Field', () => {
+  describe('String List Field', () => {
+    it('can parse individual values', () => {
+      const stringListField = new StringListField('foo');
+
+      expect(stringListField.value).to.equal('foo');
+      expect(stringListField.values).to.deep.equal(['foo']);
+      expect(stringListField.rawValue).to.equal('foo');
+    });
+
+    it('can parse lists', () => {
+      const stringListField = new StringListField('foo, bar, baz');
+
+      expect(stringListField.value).to.equal('foo');
+      expect(stringListField.values).to.deep.equal(['foo', 'bar', 'baz']);
+      expect(stringListField.rawValue).to.equal('foo, bar, baz');
+    });
+
+    it('can parse lists of lists', () => {
+      const stringListField = new StringListField([
+        'foo, bar, baz',
+        'beep, boop, bop',
+      ]);
+
+      expect(stringListField.value).to.equal('foo');
+      expect(stringListField.values).to.deep.equal([
+        'foo',
+        'bar',
+        'baz',
+        'beep',
+        'boop',
+        'bop',
+      ]);
+      expect(stringListField.rawValue).to.deep.equal([
+        'foo, bar, baz',
+        'beep, boop, bop',
+      ]);
+    });
+  });
+
+  describe('NumberListField', () => {
+    it('can parse lists of numbers', () => {
+      const listField = new NumberListField('1, 2, 3');
+
+      expect(listField.value).to.equal(1);
+      expect(listField.values).to.deep.equal([1, 2, 3]);
+      expect(listField.rawValue).to.equal('1, 2, 3');
+    });
+
+    it('can parse lists of lists', () => {
+      const listField = new NumberListField(['1, 2, 3', '4, 5, 6']);
+
+      expect(listField.value).to.equal(1);
+      expect(listField.values).to.deep.equal([1, 2, 3, 4, 5, 6]);
+      expect(listField.rawValue).to.deep.equal(['1, 2, 3', '4, 5, 6']);
+    });
+  });
+});

package/test/models/metadata-fields/metadata-field.test.ts

@@ -0,0 +1,151 @@
+import {
+  FieldParserInterface,
+  FieldParserRawValue,
+} from '@internetarchive/field-parsers';
+import { expect } from '@open-wc/testing';
+import { MetadataField } from '../../../src/models/metadata-fields/metadata-field';
+
+describe('Metadata Field', () => {
+  it('can be properly instantiated with single value', () => {
+    class MockParser implements FieldParserInterface<string> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): string {
+        return rawValue;
+      }
+    }
+
+    const parser = new MockParser();
+    const metadataField = new MetadataField(parser, 'foo');
+
+    expect(metadataField.rawValue).to.equal('foo');
+    expect(metadataField.value).to.equal('foo');
+    expect(metadataField.values).to.deep.equal(['foo']);
+  });
+
+  it('can be properly instantiated with array value', () => {
+    class MockParser implements FieldParserInterface<string> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): string {
+        return rawValue;
+      }
+    }
+
+    const parser = new MockParser();
+    const metadataField = new MetadataField(parser, ['foo', 'bar', 'baz']);
+
+    expect(metadataField.rawValue).to.deep.equal(['foo', 'bar', 'baz']);
+    expect(metadataField.value).to.equal('foo');
+    expect(metadataField.values).to.deep.equal(['foo', 'bar', 'baz']);
+  });
+
+  it('properly casts values to expected parser type for single values', () => {
+    class MockFloatParser implements FieldParserInterface<number> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): number {
+        return parseFloat(rawValue);
+      }
+    }
+
+    const parser = new MockFloatParser();
+    const metadataField = new MetadataField(parser, '1.3');
+
+    expect(metadataField.rawValue).to.equal('1.3');
+    expect(metadataField.value).to.equal(1.3);
+    expect(metadataField.values).to.deep.equal([1.3]);
+  });
+
+  it('properly casts values to expected parser type for array values', () => {
+    class MockFloatParser implements FieldParserInterface<number> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): number {
+        return parseFloat(rawValue);
+      }
+    }
+
+    const parser = new MockFloatParser();
+    const metadataField = new MetadataField(parser, ['1.3', '2.4', '4.5']);
+
+    expect(metadataField.rawValue).to.deep.equal(['1.3', '2.4', '4.5']);
+    expect(metadataField.value).to.equal(1.3);
+    expect(metadataField.values).to.deep.equal([1.3, 2.4, 4.5]);
+  });
+
+  it('has no value if a raw value was not passed in', () => {
+    class MockFloatParser implements FieldParserInterface<number> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): number {
+        return rawValue;
+      }
+    }
+
+    const parser = new MockFloatParser();
+    const metadataField = new MetadataField(parser);
+
+    expect(metadataField.rawValue).to.equal(undefined);
+    expect(metadataField.value).to.equal(undefined);
+    expect(metadataField.values).to.deep.equal([]);
+  });
+
+  it('does not add value to values array if parsed value is undefined', () => {
+    class MockFloatParser implements FieldParserInterface<number> {
+      parseValue(rawValue: FieldParserRawValue): number | undefined {
+        return undefined;
+      }
+    }
+
+    const parser = new MockFloatParser();
+    const metadataField = new MetadataField(parser);
+
+    expect(metadataField.rawValue).to.equal(undefined);
+    expect(metadataField.value).to.equal(undefined);
+    expect(metadataField.values).to.deep.equal([]);
+  });
+
+  it('handles falsy `0` return values properly', () => {
+    class MockFloatParser implements FieldParserInterface<number> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): number {
+        return rawValue;
+      }
+    }
+
+    const parser = new MockFloatParser();
+    const metadataField = new MetadataField(parser, 0);
+
+    expect(metadataField.rawValue).to.equal(0);
+    expect(metadataField.value).to.equal(0);
+    expect(metadataField.values).to.deep.equal([0]);
+  });
+
+  it('handles falsy `false` return values properly', () => {
+    class MockFloatParser implements FieldParserInterface<number> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): number {
+        return rawValue;
+      }
+    }
+
+    const parser = new MockFloatParser();
+    const metadataField = new MetadataField(parser, false);
+
+    expect(metadataField.rawValue).to.equal(false);
+    expect(metadataField.value).to.equal(false);
+    expect(metadataField.values).to.deep.equal([false]);
+  });
+
+  it('handles falsy empty string return values properly', () => {
+    class MockFloatParser implements FieldParserInterface<number> {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parseValue(rawValue: any): number {
+        return rawValue;
+      }
+    }
+
+    const parser = new MockFloatParser();
+    const metadataField = new MetadataField(parser, '');
+
+    expect(metadataField.rawValue).to.equal('');
+    expect(metadataField.value).to.equal('');
+    expect(metadataField.values).to.deep.equal(['']);
+  });
+});

package/test/models/metadata.test.ts

@@ -0,0 +1,11 @@
+import { expect } from '@open-wc/testing';
+
+import { Metadata } from '../../src/models/metadata';
+
+describe('Metadata', () => {
+  it('properly instantiates metadata with identifier', async () => {
+    const json = { identifier: 'foo', collection: 'bar' };
+    const metadata = new Metadata(json);
+    expect(metadata.identifier).to.equal('foo');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "lib": ["es2017", "dom"],
+    "strict": true,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "outDir": "dist",
+    "sourceMap": true,
+    "inlineSources": true,
+    "declaration": true,
+    "rootDir": "./",
+  },
+  "include": [
+    "**/*.ts"
+  ],
+}

package/web-test-runner.config.mjs

@@ -0,0 +1,7 @@
+export default {
+  files: 'dist/**/test/**/*.test.js',
+  nodeResolve: true,
+  coverageConfig: {
+    exclude: ['./dist/test/**/*', './node_modules/**/*'],
+  },
+};