671 lines
21 KiB
TypeScript
671 lines
21 KiB
TypeScript
import { randomUUID, createHash } from 'node:crypto';
|
|
import { readFile, mkdtemp, rm } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import { Readable } from 'node:stream';
|
|
import { NotFoundException, UnprocessableEntityException } from '@nestjs/common';
|
|
import { UploadSessionStatus } from '@prisma/client';
|
|
import { AppConfigService } from '../config/config.service';
|
|
import { DeviceAuthService } from '../auth/device-auth.service';
|
|
import { LocalFilesystemStorageService } from '../storage/storage.service';
|
|
import { OwnerContext } from '../users/owner-context.service';
|
|
import { UploadsService } from './uploads.service';
|
|
|
|
type MockState = ReturnType<typeof createPrismaMock>['state'];
|
|
|
|
function createPrismaMock() {
|
|
const users = new Map<string, any>();
|
|
const devices = new Map<string, any>();
|
|
const tracks = new Map<string, any>();
|
|
const audioAssets = new Map<string, any>();
|
|
const artworkAssets = new Map<string, any>();
|
|
const uploadSessions = new Map<string, any>();
|
|
const libraryEvents = new Map<bigint, any>();
|
|
let nextLibraryEventId = 1n;
|
|
|
|
const defaultUser = {
|
|
id: randomUUID(),
|
|
slug: 'default-owner',
|
|
displayName: 'Default Owner',
|
|
isDefault: true,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
};
|
|
users.set(defaultUser.id, defaultUser);
|
|
|
|
const prismaMock: any = {
|
|
$queryRawUnsafe: jest.fn().mockResolvedValue([{ '?column?': 1 }]),
|
|
$transaction: jest.fn().mockImplementation(async (callback: any) => callback(prismaMock)),
|
|
user: {
|
|
upsert: jest.fn().mockResolvedValue(defaultUser),
|
|
},
|
|
device: {
|
|
findUnique: jest.fn().mockImplementation(async ({ where }) => {
|
|
return devices.get(where.id) ?? null;
|
|
}),
|
|
create: jest.fn().mockImplementation(async ({ data }) => {
|
|
const record = {
|
|
id: data.id ?? randomUUID(),
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
...data,
|
|
};
|
|
devices.set(record.id, record);
|
|
return record;
|
|
}),
|
|
update: jest.fn().mockImplementation(async ({ where, data }) => {
|
|
const current = devices.get(where.id);
|
|
const updated = {
|
|
...current,
|
|
...data,
|
|
updatedAt: new Date(),
|
|
};
|
|
devices.set(where.id, updated);
|
|
return updated;
|
|
}),
|
|
},
|
|
track: {
|
|
findUnique: jest.fn().mockImplementation(async ({ where }) => {
|
|
return tracks.get(where.id) ?? null;
|
|
}),
|
|
findMany: jest.fn().mockImplementation(async ({ where }) => {
|
|
return [...tracks.values()]
|
|
.filter((track) => {
|
|
const userMatches = where?.userId ? track.userId === where.userId : true;
|
|
const statusMatches = where?.status ? track.status === where.status : true;
|
|
return userMatches && statusMatches;
|
|
})
|
|
.sort((lhs, rhs) => lhs.createdAt.getTime() - rhs.createdAt.getTime());
|
|
}),
|
|
create: jest.fn().mockImplementation(async ({ data }) => {
|
|
const now = new Date();
|
|
const record = {
|
|
id: randomUUID(),
|
|
primaryAudioAssetId: null,
|
|
artworkAssetId: null,
|
|
albumArtist: null,
|
|
genre: null,
|
|
discNumber: null,
|
|
trackNumber: null,
|
|
year: null,
|
|
deletedAt: null,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
...data,
|
|
};
|
|
tracks.set(record.id, record);
|
|
return record;
|
|
}),
|
|
update: jest.fn().mockImplementation(async ({ where, data }) => {
|
|
const current = tracks.get(where.id);
|
|
const updated = {
|
|
...current,
|
|
...data,
|
|
updatedAt: new Date(),
|
|
};
|
|
tracks.set(where.id, updated);
|
|
return updated;
|
|
}),
|
|
},
|
|
audioAsset: {
|
|
findUnique: jest.fn().mockImplementation(async ({ where }) => {
|
|
if (where.id) {
|
|
return audioAssets.get(where.id) ?? null;
|
|
}
|
|
|
|
const composite = where.userId_sha256;
|
|
if (!composite) {
|
|
return null;
|
|
}
|
|
|
|
return (
|
|
[...audioAssets.values()].find(
|
|
(asset) =>
|
|
asset.userId === composite.userId &&
|
|
asset.sha256 === composite.sha256,
|
|
) ?? null
|
|
);
|
|
}),
|
|
create: jest.fn().mockImplementation(async ({ data }) => {
|
|
const record = {
|
|
id: randomUUID(),
|
|
bitRateKbps: null,
|
|
sampleRateHz: null,
|
|
channels: null,
|
|
createdAt: new Date(),
|
|
...data,
|
|
};
|
|
audioAssets.set(record.id, record);
|
|
return record;
|
|
}),
|
|
update: jest.fn().mockImplementation(async ({ where, data }) => {
|
|
const current = audioAssets.get(where.id);
|
|
const updated = {
|
|
...current,
|
|
...data,
|
|
};
|
|
audioAssets.set(where.id, updated);
|
|
return updated;
|
|
}),
|
|
},
|
|
artworkAsset: {
|
|
findFirst: jest.fn().mockImplementation(async ({ where }) => {
|
|
return (
|
|
[...artworkAssets.values()].find(
|
|
(asset) =>
|
|
asset.userId === where.userId &&
|
|
asset.sha256 === where.sha256,
|
|
) ?? null
|
|
);
|
|
}),
|
|
create: jest.fn().mockImplementation(async ({ data }) => {
|
|
const record = {
|
|
id: randomUUID(),
|
|
createdAt: new Date(),
|
|
...data,
|
|
};
|
|
artworkAssets.set(record.id, record);
|
|
return record;
|
|
}),
|
|
update: jest.fn().mockImplementation(async ({ where, data }) => {
|
|
const current = artworkAssets.get(where.id);
|
|
const updated = {
|
|
...current,
|
|
...data,
|
|
};
|
|
artworkAssets.set(where.id, updated);
|
|
return updated;
|
|
}),
|
|
},
|
|
uploadSession: {
|
|
create: jest.fn().mockImplementation(async ({ data }) => {
|
|
const now = new Date();
|
|
const record = {
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
completedAt: null,
|
|
finalizedAt: null,
|
|
trackId: null,
|
|
audioAssetId: null,
|
|
...data,
|
|
};
|
|
uploadSessions.set(record.id, record);
|
|
return record;
|
|
}),
|
|
findUnique: jest.fn().mockImplementation(async ({ where }) => {
|
|
return uploadSessions.get(where.id) ?? null;
|
|
}),
|
|
update: jest.fn().mockImplementation(async ({ where, data }) => {
|
|
const current = uploadSessions.get(where.id);
|
|
const updated = {
|
|
...current,
|
|
...data,
|
|
updatedAt: new Date(),
|
|
};
|
|
uploadSessions.set(where.id, updated);
|
|
return updated;
|
|
}),
|
|
},
|
|
libraryEvent: {
|
|
create: jest.fn().mockImplementation(async ({ data }) => {
|
|
const record = {
|
|
id: nextLibraryEventId,
|
|
payloadVersion: 1,
|
|
createdAt: new Date(),
|
|
...data,
|
|
};
|
|
libraryEvents.set(record.id, record);
|
|
nextLibraryEventId += 1n;
|
|
return record;
|
|
}),
|
|
findFirst: jest.fn().mockImplementation(async ({ where }) => {
|
|
const filteredEvents = [...libraryEvents.values()].filter((event) =>
|
|
where?.userId ? event.userId === where.userId : true,
|
|
);
|
|
return filteredEvents.sort((lhs, rhs) => Number(rhs.id - lhs.id))[0] ?? null;
|
|
}),
|
|
},
|
|
state: {
|
|
defaultUser,
|
|
users,
|
|
devices,
|
|
tracks,
|
|
audioAssets,
|
|
artworkAssets,
|
|
uploadSessions,
|
|
libraryEvents,
|
|
},
|
|
};
|
|
|
|
return {
|
|
prismaMock,
|
|
state: prismaMock.state,
|
|
};
|
|
}
|
|
|
|
function createAppConfig(storageRoot: string): AppConfigService {
|
|
return {
|
|
maxUploadSizeBytes: 10 * 1024 * 1024,
|
|
storageRoot,
|
|
} as AppConfigService;
|
|
}
|
|
|
|
function createUploadRequest(data: Buffer): any {
|
|
const request = Readable.from([data]) as any;
|
|
request.headers = {
|
|
'content-type': 'audio/mpeg',
|
|
'content-length': String(data.length),
|
|
};
|
|
return request;
|
|
}
|
|
|
|
function sampleMp3Bytes(seed: string): Buffer {
|
|
return Buffer.concat([
|
|
Buffer.from('ID3', 'ascii'),
|
|
Buffer.from([0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21]),
|
|
Buffer.from(seed, 'utf8'),
|
|
]);
|
|
}
|
|
|
|
function sha256Hex(data: Buffer): string {
|
|
return createHash('sha256').update(data).digest('hex');
|
|
}
|
|
|
|
function sampleArtworkBytes(): Buffer {
|
|
return Buffer.from(
|
|
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2P8z8DwHwAFgwJ/lBi4NwAAAABJRU5ErkJggg==',
|
|
'base64',
|
|
);
|
|
}
|
|
|
|
describe('UploadsService', () => {
|
|
let prismaMock: any;
|
|
let state: MockState;
|
|
let storageRoot: string;
|
|
let storageService: LocalFilesystemStorageService;
|
|
let service: UploadsService;
|
|
let ownerContext: OwnerContext;
|
|
let deviceAuthService: {
|
|
resolveCurrentDevice: jest.Mock;
|
|
};
|
|
|
|
beforeEach(async () => {
|
|
const mock = createPrismaMock();
|
|
prismaMock = mock.prismaMock;
|
|
state = mock.state;
|
|
storageRoot = await mkdtemp(join(tmpdir(), 'velody-upload-spec-'));
|
|
storageService = new LocalFilesystemStorageService(createAppConfig(storageRoot));
|
|
ownerContext = {
|
|
resolve: jest.fn().mockResolvedValue({
|
|
userId: state.defaultUser.id,
|
|
}),
|
|
} as OwnerContext;
|
|
deviceAuthService = {
|
|
resolveCurrentDevice: jest.fn().mockImplementation(async (deviceId?: string) => {
|
|
if (!deviceId) {
|
|
throw new NotFoundException('Device not found');
|
|
}
|
|
|
|
const device = state.devices.get(deviceId);
|
|
|
|
if (!device || device.userId !== state.defaultUser.id) {
|
|
throw new NotFoundException('Device not found');
|
|
}
|
|
|
|
return {
|
|
deviceId: device.id,
|
|
userId: device.userId,
|
|
};
|
|
}),
|
|
};
|
|
service = new UploadsService(
|
|
prismaMock,
|
|
createAppConfig(storageRoot),
|
|
storageService,
|
|
ownerContext,
|
|
deviceAuthService as unknown as DeviceAuthService,
|
|
);
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await rm(storageRoot, { recursive: true, force: true });
|
|
});
|
|
|
|
function seedDevice() {
|
|
const deviceId = randomUUID();
|
|
const device = {
|
|
id: deviceId,
|
|
userId: state.defaultUser.id,
|
|
platform: 'MACOS',
|
|
deviceName: 'Velody Mac',
|
|
appVersion: '0.1.0',
|
|
installTokenHash: sha256Hex(Buffer.from(deviceId, 'utf8')),
|
|
lastSeenAt: new Date(),
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
};
|
|
state.devices.set(deviceId, device);
|
|
return device;
|
|
}
|
|
|
|
it('returns upload_required for a new sha during prepare', async () => {
|
|
const device = seedDevice();
|
|
const bytes = sampleMp3Bytes('prepare-new-sha');
|
|
|
|
const response = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256: sha256Hex(bytes),
|
|
originalFilename: 'track.mp3',
|
|
sizeBytes: bytes.length,
|
|
});
|
|
|
|
expect(response.status).toBe('upload_required');
|
|
expect(response.uploadId).toBeDefined();
|
|
expect(response.nextOffset).toBe(0);
|
|
expect(state.uploadSessions.size).toBe(1);
|
|
});
|
|
|
|
it('does not reuse foreign-owner audio assets during prepare', async () => {
|
|
const device = seedDevice();
|
|
const bytes = sampleMp3Bytes('foreign-owner-asset');
|
|
const sha256 = sha256Hex(bytes);
|
|
|
|
state.audioAssets.set(randomUUID(), {
|
|
id: randomUUID(),
|
|
userId: randomUUID(),
|
|
trackId: randomUUID(),
|
|
sha256,
|
|
storageKey: 'users/foreign/audio/foreign-owner-asset.mp3',
|
|
originalFilename: 'foreign-owner-asset.mp3',
|
|
mimeType: 'audio/mpeg',
|
|
fileExtension: 'mp3',
|
|
fileSizeBytes: BigInt(bytes.length),
|
|
durationMs: 180000,
|
|
sourceDeviceId: randomUUID(),
|
|
createdAt: new Date(),
|
|
});
|
|
|
|
const response = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'foreign-owner-asset.mp3',
|
|
sizeBytes: bytes.length,
|
|
});
|
|
|
|
expect(response.status).toBe('upload_required');
|
|
});
|
|
|
|
it('rejects an upload whose bytes do not match the prepared sha', async () => {
|
|
const device = seedDevice();
|
|
const uploadedBytes = sampleMp3Bytes('wrong-sha-upload');
|
|
const response = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256: sha256Hex(sampleMp3Bytes('different-bytes')),
|
|
originalFilename: 'mismatch.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
await expect(
|
|
service.uploadFile(response.uploadId!, createUploadRequest(uploadedBytes)),
|
|
).rejects.toBeInstanceOf(UnprocessableEntityException);
|
|
|
|
const session = state.uploadSessions.get(response.uploadId!);
|
|
expect(session.status).toBe(UploadSessionStatus.FAILED);
|
|
});
|
|
|
|
it('stores valid MP3 bytes under the deterministic user storage path', async () => {
|
|
const device = seedDevice();
|
|
const uploadedBytes = sampleMp3Bytes('valid-upload');
|
|
const sha256 = sha256Hex(uploadedBytes);
|
|
const response = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'valid-upload.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
const status = await service.uploadFile(
|
|
response.uploadId!,
|
|
createUploadRequest(uploadedBytes),
|
|
);
|
|
|
|
expect(status.status).toBe(UploadSessionStatus.COMPLETED);
|
|
|
|
const storedBytes = await readFile(
|
|
join(storageRoot, 'users', state.defaultUser.id, 'audio', `${sha256}.mp3`),
|
|
);
|
|
expect(storedBytes.equals(uploadedBytes)).toBe(true);
|
|
});
|
|
|
|
it('finalize creates track, audio_asset, and library_event records', async () => {
|
|
const device = seedDevice();
|
|
const uploadedBytes = sampleMp3Bytes('finalize-records');
|
|
const sha256 = sha256Hex(uploadedBytes);
|
|
const response = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'finalize-records.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
await service.uploadFile(response.uploadId!, createUploadRequest(uploadedBytes));
|
|
const finalizeResponse = await service.finalize(response.uploadId!, {
|
|
title: 'Finalize Track',
|
|
artist: 'Velody',
|
|
album: 'Milestone 6',
|
|
durationMs: 245000,
|
|
});
|
|
|
|
expect(finalizeResponse.trackId).toBeDefined();
|
|
expect(finalizeResponse.assetId).toBeDefined();
|
|
expect(state.tracks.size).toBe(1);
|
|
expect(state.audioAssets.size).toBe(1);
|
|
expect(state.libraryEvents.size).toBe(1);
|
|
|
|
const track = [...state.tracks.values()][0];
|
|
const audioAsset = [...state.audioAssets.values()][0];
|
|
const libraryEvent = [...state.libraryEvents.values()][0];
|
|
|
|
expect(track.userId).toBe(state.defaultUser.id);
|
|
expect(audioAsset.userId).toBe(state.defaultUser.id);
|
|
expect(libraryEvent.userId).toBe(state.defaultUser.id);
|
|
|
|
const session = state.uploadSessions.get(response.uploadId!);
|
|
expect(session.finalizedAt).toBeInstanceOf(Date);
|
|
expect(session.trackId).toBe(finalizeResponse.trackId);
|
|
expect(session.audioAssetId).toBe(finalizeResponse.assetId);
|
|
});
|
|
|
|
it('finalize with embedded artwork creates and links an artwork asset', async () => {
|
|
const device = seedDevice();
|
|
const uploadedBytes = sampleMp3Bytes('finalize-with-artwork');
|
|
const artworkBytes = sampleArtworkBytes();
|
|
const sha256 = sha256Hex(uploadedBytes);
|
|
const artworkSHA256 = sha256Hex(artworkBytes);
|
|
const response = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'finalize-with-artwork.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
await service.uploadFile(response.uploadId!, createUploadRequest(uploadedBytes));
|
|
const finalizeResponse = await service.finalize(response.uploadId!, {
|
|
title: 'Artwork Track',
|
|
artist: 'Velody',
|
|
album: 'Milestone 8.1',
|
|
durationMs: 245000,
|
|
artwork: {
|
|
dataBase64: artworkBytes.toString('base64'),
|
|
sha256: artworkSHA256,
|
|
mimeType: 'image/png',
|
|
width: 1,
|
|
height: 1,
|
|
},
|
|
});
|
|
|
|
expect(finalizeResponse.trackId).toBeDefined();
|
|
expect(state.artworkAssets.size).toBe(1);
|
|
|
|
const track = [...state.tracks.values()][0];
|
|
const artworkAsset = [...state.artworkAssets.values()][0];
|
|
expect(track.artworkAssetId).toBe(artworkAsset.id);
|
|
expect(artworkAsset.userId).toBe(state.defaultUser.id);
|
|
expect(artworkAsset.sha256).toBe(artworkSHA256);
|
|
expect(artworkAsset.mimeType).toBe('image/png');
|
|
|
|
const storedBytes = await readFile(
|
|
join(storageRoot, 'users', state.defaultUser.id, 'artwork', `${artworkSHA256}.png`),
|
|
);
|
|
expect(storedBytes.equals(artworkBytes)).toBe(true);
|
|
});
|
|
|
|
it('returns exists from prepare after a successful upload and finalize', async () => {
|
|
const device = seedDevice();
|
|
const uploadedBytes = sampleMp3Bytes('duplicate-handling');
|
|
const sha256 = sha256Hex(uploadedBytes);
|
|
const firstPrepare = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'duplicate-handling.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
await service.uploadFile(
|
|
firstPrepare.uploadId!,
|
|
createUploadRequest(uploadedBytes),
|
|
);
|
|
const finalizeResponse = await service.finalize(firstPrepare.uploadId!, {
|
|
title: 'Duplicate Track',
|
|
artist: 'Velody',
|
|
album: 'Milestone 6',
|
|
durationMs: 123000,
|
|
});
|
|
|
|
const secondPrepare = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'duplicate-handling.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
expect(secondPrepare.status).toBe('exists');
|
|
expect(secondPrepare.uploadId).toBeDefined();
|
|
expect(secondPrepare.trackId).toBe(finalizeResponse.trackId);
|
|
expect(secondPrepare.assetId).toBe(finalizeResponse.assetId);
|
|
});
|
|
|
|
it('finalize on an exists prepare attaches artwork to an existing audio asset without re-uploading bytes', async () => {
|
|
const device = seedDevice();
|
|
const uploadedBytes = sampleMp3Bytes('duplicate-artwork-update');
|
|
const artworkBytes = sampleArtworkBytes();
|
|
const sha256 = sha256Hex(uploadedBytes);
|
|
const artworkSHA256 = sha256Hex(artworkBytes);
|
|
|
|
const firstPrepare = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'duplicate-artwork-update.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
await service.uploadFile(
|
|
firstPrepare.uploadId!,
|
|
createUploadRequest(uploadedBytes),
|
|
);
|
|
const firstFinalize = await service.finalize(firstPrepare.uploadId!, {
|
|
title: 'Duplicate Artwork Track',
|
|
artist: 'Velody',
|
|
album: 'Milestone 8.1',
|
|
durationMs: 123000,
|
|
});
|
|
|
|
const secondPrepare = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'duplicate-artwork-update.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
expect(secondPrepare.status).toBe('exists');
|
|
expect(secondPrepare.uploadId).toBeDefined();
|
|
|
|
const secondFinalize = await service.finalize(secondPrepare.uploadId!, {
|
|
title: 'Duplicate Artwork Track',
|
|
artist: 'Velody',
|
|
album: 'Milestone 8.1',
|
|
durationMs: 123000,
|
|
artwork: {
|
|
dataBase64: artworkBytes.toString('base64'),
|
|
sha256: artworkSHA256,
|
|
mimeType: 'image/png',
|
|
width: 1,
|
|
height: 1,
|
|
},
|
|
});
|
|
|
|
expect(secondFinalize.trackId).toBe(firstFinalize.trackId);
|
|
expect(secondFinalize.assetId).toBe(firstFinalize.assetId);
|
|
expect(state.audioAssets.size).toBe(1);
|
|
expect(state.artworkAssets.size).toBe(1);
|
|
|
|
const track = [...state.tracks.values()][0];
|
|
const artworkAsset = [...state.artworkAssets.values()][0];
|
|
expect(track.artworkAssetId).toBe(artworkAsset.id);
|
|
expect(artworkAsset.sha256).toBe(artworkSHA256);
|
|
|
|
const storedArtworkBytes = await readFile(
|
|
join(storageRoot, 'users', state.defaultUser.id, 'artwork', `${artworkSHA256}.png`),
|
|
);
|
|
expect(storedArtworkBytes.equals(artworkBytes)).toBe(true);
|
|
});
|
|
|
|
it('rejects finalize when the upload session references a foreign-owner track', async () => {
|
|
const device = seedDevice();
|
|
const uploadedBytes = sampleMp3Bytes('foreign-track-finalize');
|
|
const sha256 = sha256Hex(uploadedBytes);
|
|
const response = await service.prepare({
|
|
deviceId: device.id,
|
|
sha256,
|
|
originalFilename: 'foreign-track-finalize.mp3',
|
|
sizeBytes: uploadedBytes.length,
|
|
});
|
|
|
|
await service.uploadFile(response.uploadId!, createUploadRequest(uploadedBytes));
|
|
|
|
const foreignTrackId = randomUUID();
|
|
state.tracks.set(foreignTrackId, {
|
|
id: foreignTrackId,
|
|
userId: randomUUID(),
|
|
primaryAudioAssetId: null,
|
|
artworkAssetId: null,
|
|
title: 'Foreign Track',
|
|
artist: 'Elsewhere',
|
|
album: null,
|
|
albumArtist: null,
|
|
genre: null,
|
|
discNumber: null,
|
|
trackNumber: null,
|
|
year: null,
|
|
durationMs: 180000,
|
|
status: 'ACTIVE',
|
|
deletedAt: null,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
});
|
|
state.uploadSessions.set(response.uploadId!, {
|
|
...state.uploadSessions.get(response.uploadId!),
|
|
trackId: foreignTrackId,
|
|
});
|
|
|
|
await expect(
|
|
service.finalize(response.uploadId!, {
|
|
title: 'Finalize Track',
|
|
artist: 'Velody',
|
|
album: 'Milestone 9',
|
|
durationMs: 245000,
|
|
}),
|
|
).rejects.toBeInstanceOf(NotFoundException);
|
|
});
|
|
});
|