Skip to content

High performance self-hosted photo and video management solution.

refactor: medium tests (#19537)

Jason Rasmussen3105094a3df3
diff --git a/server/src/services/base.service.ts b/server/src/services/base.service.ts
index 1c44abfd92..3e2128ac2c 100644
--- a/server/src/services/base.service.ts
+++ b/server/src/services/base.service.ts
@@ -53,6 +53,53 @@ import { UserTable } from 'src/schema/tables/user.table';
import { AccessRequest, checkAccess, requireAccess } from 'src/utils/access';
import { getConfig, updateConfig } from 'src/utils/config';
+export const BASE_SERVICE_DEPENDENCIES = [
+ LoggingRepository,
+ AccessRepository,
+ ActivityRepository,
+ AlbumRepository,
+ AlbumUserRepository,
+ ApiKeyRepository,
+ AssetRepository,
+ AssetJobRepository,
+ AuditRepository,
+ ConfigRepository,
+ CronRepository,
+ CryptoRepository,
+ DatabaseRepository,
+ DownloadRepository,
+ DuplicateRepository,
+ EmailRepository,
+ EventRepository,
+ JobRepository,
+ LibraryRepository,
+ MachineLearningRepository,
+ MapRepository,
+ MediaRepository,
+ MemoryRepository,
+ MetadataRepository,
+ MoveRepository,
+ NotificationRepository,
+ OAuthRepository,
+ PartnerRepository,
+ PersonRepository,
+ ProcessRepository,
+ SearchRepository,
+ ServerInfoRepository,
+ SessionRepository,
+ SharedLinkRepository,
+ StackRepository,
+ StorageRepository,
+ SyncRepository,
+ SystemMetadataRepository,
+ TagRepository,
+ TelemetryRepository,
+ TrashRepository,
+ UserRepository,
+ VersionHistoryRepository,
+ ViewRepository,
+];
+
@Injectable()
export class BaseService {
protected storageCore: StorageCore;
diff --git a/server/test/medium.factory.ts b/server/test/medium.factory.ts
index cbecff267d..69708d0fce 100644
--- a/server/test/medium.factory.ts
+++ b/server/test/medium.factory.ts
@@ -1,12 +1,12 @@
-import { ClassConstructor } from 'class-transformer';
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
import { Insertable, Kysely } from 'kysely';
import { DateTime } from 'luxon';
import { createHash, randomBytes } from 'node:crypto';
import { Writable } from 'node:stream';
import { AssetFace } from 'src/database';
-import { Albums, AssetJobStatus, Assets, DB, FaceSearch, Person, Sessions } from 'src/db';
+import { Albums, AssetJobStatus, Assets, DB, Exif, FaceSearch, Person, Sessions } from 'src/db';
import { AuthDto } from 'src/dtos/auth.dto';
-import { AssetType, AssetVisibility, SourceType, SyncRequestType } from 'src/enum';
+import { AlbumUserRole, AssetType, AssetVisibility, SourceType, SyncRequestType } from 'src/enum';
import { AccessRepository } from 'src/repositories/access.repository';
import { ActivityRepository } from 'src/repositories/activity.repository';
import { AlbumUserRepository } from 'src/repositories/album-user.repository';
@@ -31,298 +31,263 @@ import { SystemMetadataRepository } from 'src/repositories/system-metadata.repos
import { UserRepository } from 'src/repositories/user.repository';
import { VersionHistoryRepository } from 'src/repositories/version-history.repository';
import { UserTable } from 'src/schema/tables/user.table';
-import { BaseService } from 'src/services/base.service';
+import { BASE_SERVICE_DEPENDENCIES, BaseService } from 'src/services/base.service';
import { SyncService } from 'src/services/sync.service';
-import { RepositoryInterface } from 'src/types';
import { factory, newDate, newEmbedding, newUuid } from 'test/small.factory';
-import { automock, ServiceOverrides, wait } from 'test/utils';
+import { automock, wait } from 'test/utils';
import { Mocked } from 'vitest';
-const sha256 = (value: string) => createHash('sha256').update(value).digest('base64');
+interface ClassConstructor<T = any> extends Function {
+ new (...args: any[]): T;
+}
-// type Repositories = Omit<ServiceOverrides, 'access' | 'telemetry'>;
-type RepositoriesTypes = {
- access: AccessRepository;
- activity: ActivityRepository;
- album: AlbumRepository;
- albumUser: AlbumUserRepository;
- asset: AssetRepository;
- assetJob: AssetJobRepository;
- config: ConfigRepository;
- crypto: CryptoRepository;
- database: DatabaseRepository;
- email: EmailRepository;
- job: JobRepository;
- user: UserRepository;
- logger: LoggingRepository;
- memory: MemoryRepository;
- notification: NotificationRepository;
- partner: PartnerRepository;
- person: PersonRepository;
- search: SearchRepository;
- session: SessionRepository;
- storage: StorageRepository;
- sync: SyncRepository;
- systemMetadata: SystemMetadataRepository;
- versionHistory: VersionHistoryRepository;
+type MediumTestOptions = {
+ mock: ClassConstructor<any>[];
+ real: ClassConstructor<any>[];
+ database: Kysely<DB>;
};
-type RepositoryMocks = { [K in keyof RepositoriesTypes]: Mocked<RepositoryInterface<RepositoriesTypes[K]>> };
-type RepositoryOptions = Partial<{ [K in keyof RepositoriesTypes]: 'mock' | 'real' }>;
-type ContextRepositoryMocks<R extends RepositoryOptions> = {
- [K in keyof RepositoriesTypes as R[K] extends 'mock' ? K : never]: Mocked<RepositoryInterface<RepositoriesTypes[K]>>;
+export const newMediumService = <S extends BaseService>(Service: ClassConstructor<S>, options: MediumTestOptions) => {
+ const ctx = new MediumTestContext(Service, options);
+ return { sut: ctx.sut, ctx };
};
-type ContextRepositories<R extends RepositoryOptions> = {
- [K in keyof RepositoriesTypes as R[K] extends 'real' ? K : never]: RepositoriesTypes[K];
-};
+export class MediumTestContext<S extends BaseService = BaseService> {
+ private repoCache: Record<string, any> = {};
+ private sutDeps: any[];
-export type Context<R extends RepositoryOptions, S extends BaseService> = {
sut: S;
- mocks: ContextRepositoryMocks<R>;
- repos: ContextRepositories<R>;
- getRepository<T extends keyof RepositoriesTypes>(key: T): RepositoriesTypes[T];
-};
-
-export type SyncTestOptions = {
- db: Kysely<DB>;
-};
-
-export const newSyncAuthUser = () => {
- const user = mediumFactory.userInsert();
- const session = mediumFactory.sessionInsert({ userId: user.id });
-
- const auth = factory.auth({
- session,
- user: {
- id: user.id,
- name: user.name,
- email: user.email,
- },
- });
-
- return {
- auth,
- session,
- user,
- create: async (db: Kysely<DB>) => {
- await new UserRepository(db).create(user);
- await new SessionRepository(db).create(session);
- },
- };
-};
-
-export const newSyncTest = (options: SyncTestOptions) => {
- const { sut, mocks, repos, getRepository } = newMediumService(SyncService, {
- database: options.db,
- repos: {
- sync: 'real',
- session: 'real',
- },
- });
-
- const testSync = async (auth: AuthDto, types: SyncRequestType[]) => {
- const stream = mediumFactory.syncStream();
- // Wait for 2ms to ensure all updates are available and account for setTimeout inaccuracy
- await wait(2);
- await sut.stream(auth, stream, { types });
-
- return stream.getResponse();
- };
-
- return {
- sut,
- mocks,
- repos,
- getRepository,
- testSync,
- };
-};
-
-export const newMediumService = <R extends RepositoryOptions, S extends BaseService>(
- Service: ClassConstructor<S>,
- options: {
- database: Kysely<DB>;
- repos: R;
- },
-): Context<R, S> => {
- const repos: Partial<RepositoriesTypes> = {};
- const mocks: Partial<RepositoryMocks> = {};
-
- const loggerMock = getRepositoryMock('logger') as Mocked<LoggingRepository>;
- loggerMock.setContext.mockImplementation(() => {});
- repos.logger = loggerMock;
-
- for (const [_key, type] of Object.entries(options.repos)) {
- if (type === 'real') {
- const key = _key as keyof RepositoriesTypes;
- repos[key] = getRepository(key, options.database) as any;
- continue;
- }
-
- if (type === 'mock') {
- const key = _key as keyof RepositoryMocks;
- mocks[key] = getRepositoryMock(key) as any;
- continue;
- }
+ database: Kysely<DB>;
+
+ constructor(
+ Service: ClassConstructor<S>,
+ private options: MediumTestOptions,
+ ) {
+ this.sutDeps = this.makeDeps(options);
+ this.sut = new Service(...this.sutDeps);
+ this.database = options.database;
}
- const makeRepository = <K extends keyof RepositoriesTypes>(key: K) => {
- return repos[key] || getRepository(key, options.database);
- };
-
- const deps = asDeps({ ...mocks, ...repos } as ServiceOverrides);
- const sut = new Service(...deps);
-
- return {
- sut,
- mocks,
- repos,
- getRepository: makeRepository,
- } as Context<R, S>;
-};
+ private makeDeps(options: MediumTestOptions) {
+ const deps = BASE_SERVICE_DEPENDENCIES;
-export const getRepository = <K extends keyof RepositoriesTypes>(key: K, db: Kysely<DB>) => {
- switch (key) {
- case 'access': {
- return new AccessRepository(db);
+ for (const dep of options.mock) {
+ if (!deps.includes(dep)) {
+ throw new Error(`Mocked repository ${dep.name} is not a valid dependency`);
+ }
}
- case 'activity': {
- return new ActivityRepository(db);
+ for (const dep of options.real) {
+ if (!deps.includes(dep)) {
+ throw new Error(`Real repository ${dep.name} is not a valid dependency`);
+ }
}
+ return (deps as ClassConstructor<any>[]).map((dep) => {
+ if (options.real.includes(dep)) {
+ return this.get(dep);
+ }
- case 'album': {
- return new AlbumRepository(db);
- }
+ if (options.mock.includes(dep)) {
+ return newMockRepository(dep);
+ }
+ });
+ }
- case 'albumUser': {
- return new AlbumUserRepository(db);
+ get<T>(key: ClassConstructor<T>): T {
+ if (!this.repoCache[key.name]) {
+ const real = newRealRepository(key, this.options.database);
+ this.repoCache[key.name] = real;
}
- case 'asset': {
- return new AssetRepository(db);
- }
+ return this.repoCache[key.name];
+ }
- case 'assetJob': {
- return new AssetJobRepository(db);
+ getMock<T, R = Mocked<T>>(key: ClassConstructor<T>): R {
+ const index = BASE_SERVICE_DEPENDENCIES.indexOf(key as any);
+ if (index === -1 || !this.options.mock.includes(key)) {
+ throw new Error(`getMock called with a key that is not a mock: ${key.name}`);
}
- case 'config': {
- return new ConfigRepository();
- }
+ return this.sutDeps[index] as R;
+ }
- case 'crypto': {
- return new CryptoRepository();
- }
+ async newUser(dto: Partial<Insertable<UserTable>> = {}) {
+ const user = mediumFactory.userInsert(dto);
+ const result = await this.get(UserRepository).create(user);
+ return { user, result };
+ }
- case 'database': {
- return new DatabaseRepository(db, LoggingRepository.create(), new ConfigRepository());
- }
+ async newPartner(dto: { sharedById: string; sharedWithId: string; inTimeline?: boolean }) {
+ const partner = { inTimeline: true, ...dto };
+ const result = await this.get(PartnerRepository).create(partner);
+ return { partner, result };
+ }
- case 'email': {
- return new EmailRepository(LoggingRepository.create());
- }
+ async newAsset(dto: Partial<Insertable<Assets>> = {}) {
+ const asset = mediumFactory.assetInsert(dto);
+ const result = await this.get(AssetRepository).create(asset);
+ return { asset, result };
+ }
- case 'logger': {
- return LoggingRepository.create();
- }
+ async newExif(dto: Insertable<Exif>) {
+ const result = await this.get(AssetRepository).upsertExif(dto);
+ return { result };
+ }
- case 'memory': {
- return new MemoryRepository(db);
- }
+ async newAlbum(dto: Insertable<Albums>) {
+ const album = mediumFactory.albumInsert(dto);
+ const result = await this.get(AlbumRepository).create(album, [], []);
+ return { album, result };
+ }
- case 'notification': {
- return new NotificationRepository(db);
- }
+ async newAlbumAsset(albumAsset: { albumId: string; assetId: string }) {
+ const result = await this.get(AlbumRepository).addAssetIds(albumAsset.albumId, [albumAsset.assetId]);
+ return { albumAsset, result };
+ }
- case 'partner': {
- return new PartnerRepository(db);
- }
+ async newAlbumUser(dto: { albumId: string; userId: string; role?: AlbumUserRole }) {
+ const { albumId, userId, role = AlbumUserRole.EDITOR } = dto;
+ const result = await this.get(AlbumUserRepository).create({ albumsId: albumId, usersId: userId, role });
+ return { albumUser: { albumId, userId, role }, result };
+ }
- case 'person': {
- return new PersonRepository(db);
- }
+ async newJobStatus(dto: Partial<Insertable<AssetJobStatus>> & { assetId: string }) {
+ const jobStatus = mediumFactory.assetJobStatusInsert({ assetId: dto.assetId });
+ const result = await this.get(AssetRepository).upsertJobStatus(jobStatus);
+ return { jobStatus, result };
+ }
- case 'search': {
- return new SearchRepository(db);
- }
+ async newPerson(dto: Partial<Insertable<Person>> & { ownerId: string }) {
+ const person = mediumFactory.personInsert(dto);
+ const result = await this.get(PersonRepository).create(person);
+ return { person, result };
+ }
- case 'session': {
- return new SessionRepository(db);
- }
+ async newSession(dto: Partial<Insertable<Sessions>> & { userId: string }) {
+ const session = mediumFactory.sessionInsert(dto);
+ const result = await this.get(SessionRepository).create(session);
+ return { session, result };
+ }
- case 'sync': {
- return new SyncRepository(db);
- }
+ async newSyncAuthUser() {
+ const { user } = await this.newUser();
+ const { session } = await this.newSession({ userId: user.id });
+ const auth = factory.auth({
+ session,
+ user: {
+ id: user.id,
+ name: user.name,
+ email: user.email,
+ },
+ });
+
+ return {
+ auth,
+ session,
+ user,
+ };
+ }
+}
- case 'systemMetadata': {
- return new SystemMetadataRepository(db);
- }
+export class SyncTestContext extends MediumTestContext<SyncService> {
+ constructor(database: Kysely<DB>) {
+ super(SyncService, { database, real: [SyncRepository, SessionRepository], mock: [LoggingRepository] });
+ }
- case 'user': {
- return new UserRepository(db);
- }
+ async syncStream(auth: AuthDto, types: SyncRequestType[]) {
+ const stream = mediumFactory.syncStream();
+ // Wait for 2ms to ensure all updates are available and account for setTimeout inaccuracy
+ await wait(2);
+ await this.sut.stream(auth, stream, { types });
- case 'versionHistory': {
- return new VersionHistoryRepository(db);
- }
+ return stream.getResponse();
+ }
- default: {
- throw new Error(`Invalid repository key: ${key}`);
+ async syncAckAll(auth: AuthDto, response: Array<{ type: string; ack: string }>) {
+ const acks: Record<string, string> = {};
+ for (const { type, ack } of response) {
+ acks[type] = ack;
}
+
+ await this.sut.setAcks(auth, { acks: Object.values(acks) });
}
-};
+}
-const getRepositoryMock = <K extends keyof RepositoryMocks>(key: K) => {
+const newRealRepository = <T>(key: ClassConstructor<T>, db: Kysely<DB>): T => {
switch (key) {
- case 'activity': {
- return automock(ActivityRepository) as Mocked<RepositoryInterface<ActivityRepository>>;
+ case AccessRepository:
+ case AlbumRepository:
+ case AlbumUserRepository:
+ case ActivityRepository:
+ case AssetRepository:
+ case AssetJobRepository:
+ case MemoryRepository:
+ case NotificationRepository:
+ case PartnerRepository:
+ case PersonRepository:
+ case SearchRepository:
+ case SessionRepository:
+ case SyncRepository:
+ case SystemMetadataRepository:
+ case UserRepository:
+ case VersionHistoryRepository: {
+ return new key(db);
}
- case 'album': {
- return automock(AlbumRepository);
+ case ConfigRepository:
+ case CryptoRepository: {
+ return new key();
}
- case 'asset': {
- return automock(AssetRepository);
+ case DatabaseRepository: {
+ return new key(db, LoggingRepository.create(), new ConfigRepository());
}
- case 'assetJob': {
- return automock(AssetJobRepository);
+ case EmailRepository: {
+ return new key(LoggingRepository.create());
}
- case 'config': {
- return automock(ConfigRepository);
+ case LoggingRepository as unknown as ClassConstructor<LoggingRepository>: {
+ return new key() as unknown as T;
}
- case 'crypto': {
- return automock(CryptoRepository);
+ default: {
+ throw new Error(`Unable to create repository instance for key: ${key?.name || key}`);
}
+ }
+};
- case 'database': {
+const newMockRepository = <T>(key: ClassConstructor<T>) => {
+ switch (key) {
+ case ActivityRepository:
+ case AlbumRepository:
+ case AssetRepository:
+ case AssetJobRepository:
+ case ConfigRepository:
+ case CryptoRepository:
+ case MemoryRepository:
+ case NotificationRepository:
+ case PartnerRepository:
+ case PersonRepository:
+ case SessionRepository:
+ case SyncRepository:
+ case SystemMetadataRepository:
+ case UserRepository:
+ case VersionHistoryRepository: {
+ return automock(key);
+ }
+
+ case DatabaseRepository: {
return automock(DatabaseRepository, {
- args: [
- undefined,
- {
- setContext: () => {},
- },
- { getEnv: () => ({ database: { vectorExtension: '' } }) },
- ],
+ args: [undefined, { setContext: () => {} }, { getEnv: () => ({ database: { vectorExtension: '' } }) }],
});
}
- case 'email': {
- return automock(EmailRepository, {
- args: [
- {
- setContext: () => {},
- },
- ],
- });
+ case EmailRepository: {
+ return automock(EmailRepository, { args: [{ setContext: () => {} }] });
}
- case 'job': {
+ case JobRepository: {
return automock(JobRepository, {
args: [
undefined,
@@ -335,106 +300,21 @@ const getRepositoryMock = <K extends keyof RepositoryMocks>(key: K) => {
});
}
- case 'logger': {
+ case LoggingRepository as unknown as ClassConstructor<T>: {
const configMock = { getEnv: () => ({ noColor: false }) };
return automock(LoggingRepository, { args: [undefined, configMock], strict: false });
}
- case 'memory': {
- return automock(MemoryRepository);
- }
-
- case 'notification': {
- return automock(NotificationRepository);
- }
-
- case 'partner': {
- return automock(PartnerRepository);
- }
-
- case 'person': {
- return automock(PersonRepository);
- }
-
- case 'session': {
- return automock(SessionRepository);
- }
-
- case 'storage': {
+ case StorageRepository: {
return automock(StorageRepository, { args: [{ setContext: () => {} }] });
}
- case 'sync': {
- return automock(SyncRepository);
- }
-
- case 'systemMetadata': {
- return automock(SystemMetadataRepository);
- }
-
- case 'user': {
- return automock(UserRepository);
- }
-
- case 'versionHistory': {
- return automock(VersionHistoryRepository);
- }
-
default: {
throw new Error(`Invalid repository key: ${key}`);
}
}
};
-export const asDeps = (repositories: ServiceOverrides) => {
- return [
- repositories.logger || getRepositoryMock('logger'), // logger
- repositories.access, // access
- repositories.activity || getRepositoryMock('activity'),
- repositories.album || getRepositoryMock('album'),
- repositories.albumUser,
- repositories.apiKey,
- repositories.asset || getRepositoryMock('asset'),
- repositories.assetJob || getRepositoryMock('assetJob'),
- repositories.audit,
- repositories.config || getRepositoryMock('config'),
- repositories.cron,
- repositories.crypto || getRepositoryMock('crypto'),
- repositories.database || getRepositoryMock('database'),
- repositories.downloadRepository,
- repositories.duplicateRepository,
- repositories.email || getRepositoryMock('email'),
- repositories.event,
- repositories.job || getRepositoryMock('job'),
- repositories.library,
- repositories.machineLearning,
- repositories.map,
- repositories.media,
- repositories.memory || getRepositoryMock('memory'),
- repositories.metadata,
- repositories.move,
- repositories.notification || getRepositoryMock('notification'),
- repositories.oauth,
- repositories.partner || getRepositoryMock('partner'),
- repositories.person || getRepositoryMock('person'),
- repositories.process,
- repositories.search,
- repositories.serverInfo,
- repositories.session || getRepositoryMock('session'),
- repositories.sharedLink,
- repositories.stack,
- repositories.storage || getRepositoryMock('storage'),
- repositories.sync || getRepositoryMock('sync'),
- repositories.systemMetadata || getRepositoryMock('systemMetadata'),
- repositories.tag,
- repositories.telemetry,
- repositories.trash,
- repositories.user,
- repositories.versionHistory || getRepositoryMock('versionHistory'),
- repositories.view,
- ];
-};
-
const assetInsert = (asset: Partial<Insertable<Assets>> = {}) => {
const id = asset.id || newUuid();
const now = newDate();
@@ -544,6 +424,8 @@ const personInsert = (person: Partial<Insertable<Person>> & { ownerId: string })
};
};
+const sha256 = (value: string) => createHash('sha256').update(value).digest('base64');
+
const sessionInsert = ({ id = newUuid(), userId, ...session }: Partial<Insertable<Sessions>> & { userId: string }) => {
const defaults: Insertable<Sessions> = {
id,
diff --git a/server/test/medium/specs/services/asset.service.spec.ts b/server/test/medium/specs/services/asset.service.spec.ts
index 7be431f5f2..db9a7de082 100644
--- a/server/test/medium/specs/services/asset.service.spec.ts
+++ b/server/test/medium/specs/services/asset.service.spec.ts
@@ -1,44 +1,33 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { AssetRepository } from 'src/repositories/asset.repository';
-import { UserRepository } from 'src/repositories/user.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
import { AssetService } from 'src/services/asset.service';
-import { mediumFactory, newMediumService } from 'test/medium.factory';
+import { newMediumService } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB } from 'test/utils';
-describe(AssetService.name, () => {
- let defaultDatabase: Kysely<DB>;
- let assetRepo: AssetRepository;
- let userRepo: UserRepository;
-
- const createSut = (db?: Kysely<DB>) => {
- return newMediumService(AssetService, {
- database: db || defaultDatabase,
- repos: {
- asset: 'real',
- },
- });
- };
+let defaultDatabase: Kysely<DB>;
- beforeAll(async () => {
- defaultDatabase = await getKyselyDB();
-
- assetRepo = new AssetRepository(defaultDatabase);
- userRepo = new UserRepository(defaultDatabase);
+const setup = (db?: Kysely<DB>) => {
+ return newMediumService(AssetService, {
+ database: db || defaultDatabase,
+ real: [AssetRepository],
+ mock: [LoggingRepository],
});
+};
+
+beforeAll(async () => {
+ defaultDatabase = await getKyselyDB();
+});
+describe(AssetService.name, () => {
describe('getStatistics', () => {
it('should return stats as numbers, not strings', async () => {
- const { sut } = createSut();
-
- const user = mediumFactory.userInsert();
- const asset = mediumFactory.assetInsert({ ownerId: user.id });
-
- await userRepo.create(user);
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, fileSizeInByte: 12_345 });
-
+ const { sut, ctx } = setup();
+ const { user } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user.id });
+ await ctx.newExif({ assetId: asset.id, fileSizeInByte: 12_345 });
const auth = factory.auth({ user: { id: user.id } });
await expect(sut.getStatistics(auth, {})).resolves.toEqual({ images: 1, total: 1, videos: 0 });
});
diff --git a/server/test/medium/specs/services/audit.database.spec.ts b/server/test/medium/specs/services/audit.database.spec.ts
index 33ae38ec6f..377736408c 100644
--- a/server/test/medium/specs/services/audit.database.spec.ts
+++ b/server/test/medium/specs/services/audit.database.spec.ts
@@ -1,74 +1,63 @@
-import { Kysely } from 'kysely';
-import { DB } from 'src/db';
-import { AssetRepository } from 'src/repositories/asset.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
import { PartnerRepository } from 'src/repositories/partner.repository';
import { UserRepository } from 'src/repositories/user.repository';
import { partners_delete_audit } from 'src/schema/functions';
-import { mediumFactory } from 'test/medium.factory';
+import { BaseService } from 'src/services/base.service';
+import { MediumTestContext } from 'test/medium.factory';
import { getKyselyDB } from 'test/utils';
describe('audit', () => {
- let defaultDatabase: Kysely<DB>;
- let assetRepo: AssetRepository;
- let userRepo: UserRepository;
- let partnerRepo: PartnerRepository;
+ let ctx: MediumTestContext;
beforeAll(async () => {
- defaultDatabase = await getKyselyDB();
-
- assetRepo = new AssetRepository(defaultDatabase);
- userRepo = new UserRepository(defaultDatabase);
- partnerRepo = new PartnerRepository(defaultDatabase);
+ ctx = new MediumTestContext(BaseService, {
+ database: await getKyselyDB(),
+ real: [],
+ mock: [LoggingRepository],
+ });
});
describe(partners_delete_audit.name, () => {
it('should not cascade user deletes to partners_audit', async () => {
- const user1 = mediumFactory.userInsert();
- const user2 = mediumFactory.userInsert();
-
- await Promise.all([userRepo.create(user1), userRepo.create(user2)]);
+ const partnerRepo = ctx.get(PartnerRepository);
+ const userRepo = ctx.get(UserRepository);
+ const { user: user1 } = await ctx.newUser();
+ const { user: user2 } = await ctx.newUser();
await partnerRepo.create({ sharedById: user1.id, sharedWithId: user2.id });
await userRepo.delete(user1, true);
-
await expect(
- defaultDatabase.selectFrom('partners_audit').select(['id']).where('sharedById', '=', user1.id).execute(),
+ ctx.database.selectFrom('partners_audit').select(['id']).where('sharedById', '=', user1.id).execute(),
).resolves.toHaveLength(0);
});
});
describe('assets_audit', () => {
it('should not cascade user deletes to assets_audit', async () => {
- const user = mediumFactory.userInsert();
- const asset = mediumFactory.assetInsert({ ownerId: user.id });
-
- await userRepo.create(user);
- await assetRepo.create(asset);
+ const userRepo = ctx.get(UserRepository);
+ const { user } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user.id });
await userRepo.delete(user, true);
-
await expect(
- defaultDatabase.selectFrom('assets_audit').select(['id']).where('assetId', '=', asset.id).execute(),
+ ctx.database.selectFrom('assets_audit').select(['id']).where('assetId', '=', asset.id).execute(),
).resolves.toHaveLength(0);
});
});
describe('exif', () => {
it('should automatically set updatedAt and updateId when the row is updated', async () => {
- const user = mediumFactory.userInsert();
- const asset = mediumFactory.assetInsert({ ownerId: user.id });
-
- await userRepo.create(user);
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
+ const { user } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
- const before = await defaultDatabase
+ const before = await ctx.database
.selectFrom('exif')
.select(['updatedAt', 'updateId'])
.where('assetId', '=', asset.id)
.executeTakeFirstOrThrow();
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon 2' });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon 2' });
- const after = await defaultDatabase
+ const after = await ctx.database
.selectFrom('exif')
.select(['updatedAt', 'updateId'])
.where('assetId', '=', asset.id)
diff --git a/server/test/medium/specs/services/memory.service.spec.ts b/server/test/medium/specs/services/memory.service.spec.ts
index 8489e6bcc9..ff7249d930 100644
--- a/server/test/medium/specs/services/memory.service.spec.ts
+++ b/server/test/medium/specs/services/memory.service.spec.ts
@@ -2,71 +2,66 @@ import { Kysely } from 'kysely';
import { DateTime } from 'luxon';
import { DB } from 'src/db';
import { AssetFileType } from 'src/enum';
+import { AssetRepository } from 'src/repositories/asset.repository';
+import { DatabaseRepository } from 'src/repositories/database.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { MemoryRepository } from 'src/repositories/memory.repository';
+import { PartnerRepository } from 'src/repositories/partner.repository';
+import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';
import { UserRepository } from 'src/repositories/user.repository';
import { MemoryService } from 'src/services/memory.service';
-import { mediumFactory, newMediumService } from 'test/medium.factory';
+import { newMediumService } from 'test/medium.factory';
import { getKyselyDB } from 'test/utils';
-describe(MemoryService.name, () => {
- let defaultDatabase: Kysely<DB>;
-
- const createSut = (db?: Kysely<DB>) => {
- return newMediumService(MemoryService, {
- database: db || defaultDatabase,
- repos: {
- asset: 'real',
- database: 'real',
- memory: 'real',
- user: 'real',
- systemMetadata: 'real',
- partner: 'real',
- },
- });
- };
+let defaultDatabase: Kysely<DB>;
+
+const setup = (db?: Kysely<DB>) => {
+ return newMediumService(MemoryService, {
+ database: db || defaultDatabase,
+ real: [
+ AssetRepository,
+ DatabaseRepository,
+ MemoryRepository,
+ UserRepository,
+ SystemMetadataRepository,
+ UserRepository,
+ PartnerRepository,
+ ],
+ mock: [LoggingRepository],
+ });
+};
+describe(MemoryService.name, () => {
beforeEach(async () => {
defaultDatabase = await getKyselyDB();
- const userRepo = new UserRepository(defaultDatabase);
- const admin = mediumFactory.userInsert({ isAdmin: true });
- await userRepo.create(admin);
});
describe('onMemoryCreate', () => {
it('should work on an empty database', async () => {
- const { sut } = createSut();
+ const { sut } = setup();
await expect(sut.onMemoriesCreate()).resolves.not.toThrow();
});
it('should create a memory from an asset', async () => {
- const { sut, repos, getRepository } = createSut();
-
+ const { sut, ctx } = setup();
+ const assetRepo = ctx.get(AssetRepository);
+ const memoryRepo = ctx.get(MemoryRepository);
const now = DateTime.fromObject({ year: 2025, month: 2, day: 25 }, { zone: 'utc' }) as DateTime<true>;
- const user = mediumFactory.userInsert();
- const asset = mediumFactory.assetInsert({
- ownerId: user.id,
- localDateTime: now.minus({ years: 1 }).toISO(),
- });
- const jobStatus = mediumFactory.assetJobStatusInsert({ assetId: asset.id });
-
- const userRepo = getRepository('user');
- const assetRepo = getRepository('asset');
-
- await userRepo.create(user);
- await assetRepo.create(asset);
+ const { user } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user.id, localDateTime: now.minus({ years: 1 }).toISO() });
await Promise.all([
- assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' }),
+ ctx.newExif({ assetId: asset.id, make: 'Canon' }),
+ ctx.newJobStatus({ assetId: asset.id }),
assetRepo.upsertFiles([
{ assetId: asset.id, type: AssetFileType.PREVIEW, path: '/path/to/preview.jpg' },
{ assetId: asset.id, type: AssetFileType.THUMBNAIL, path: '/path/to/thumbnail.jpg' },
]),
- assetRepo.upsertJobStatus(jobStatus),
]);
vi.setSystemTime(now.toJSDate());
-
await sut.onMemoriesCreate();
- const memories = await repos.memory.search(user.id, {});
+ const memories = await memoryRepo.search(user.id, {});
expect(memories.length).toBe(1);
expect(memories[0]).toEqual(
expect.objectContaining({
@@ -88,16 +83,11 @@ describe(MemoryService.name, () => {
});
it('should not generate a memory twice for the same day', async () => {
- const { sut, repos, getRepository } = createSut();
-
+ const { sut, ctx } = setup();
+ const assetRepo = ctx.get(AssetRepository);
+ const memoryRepo = ctx.get(MemoryRepository);
const now = DateTime.fromObject({ year: 2025, month: 2, day: 20 }, { zone: 'utc' }) as DateTime<true>;
-
- const assetRepo = getRepository('asset');
- const memoryRepo = getRepository('memory');
-
- const user = mediumFactory.userInsert();
- await repos.user.create(user);
-
+ const { user } = await ctx.newUser();
for (const dto of [
{
ownerId: user.id,
@@ -112,11 +102,10 @@ describe(MemoryService.name, () => {
localDateTime: now.minus({ year: 1 }).plus({ days: 5 }).toISO(),
},
]) {
- const asset = mediumFactory.assetInsert(dto);
- await assetRepo.create(asset);
+ const { asset } = await ctx.newAsset(dto);
await Promise.all([
- assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' }),
- assetRepo.upsertJobStatus(mediumFactory.assetJobStatusInsert({ assetId: asset.id })),
+ ctx.newExif({ assetId: asset.id, make: 'Canon' }),
+ ctx.newJobStatus({ assetId: asset.id }),
assetRepo.upsertFiles([
{ assetId: asset.id, type: AssetFileType.PREVIEW, path: '/path/to/preview.jpg' },
{ assetId: asset.id, type: AssetFileType.THUMBNAIL, path: '/path/to/thumbnail.jpg' },
@@ -125,13 +114,13 @@ describe(MemoryService.name, () => {
}
vi.setSystemTime(now.toJSDate());
-
await sut.onMemoriesCreate();
const memories = await memoryRepo.search(user.id, {});
expect(memories.length).toBe(1);
await sut.onMemoriesCreate();
+
const memoriesAfter = await memoryRepo.search(user.id, {});
expect(memoriesAfter.length).toBe(1);
});
@@ -139,7 +128,7 @@ describe(MemoryService.name, () => {
describe('onMemoriesCleanup', () => {
it('should run without error', async () => {
- const { sut } = createSut();
+ const { sut } = setup();
await expect(sut.onMemoriesCleanup()).resolves.not.toThrow();
});
});
diff --git a/server/test/medium/specs/services/person.service.spec.ts b/server/test/medium/specs/services/person.service.spec.ts
index bd5eb5d543..2a1080704c 100644
--- a/server/test/medium/specs/services/person.service.spec.ts
+++ b/server/test/medium/specs/services/person.service.spec.ts
@@ -1,90 +1,80 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
+import { AccessRepository } from 'src/repositories/access.repository';
+import { DatabaseRepository } from 'src/repositories/database.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { PersonRepository } from 'src/repositories/person.repository';
+import { StorageRepository } from 'src/repositories/storage.repository';
import { PersonService } from 'src/services/person.service';
-import { mediumFactory, newMediumService } from 'test/medium.factory';
+import { newMediumService } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB } from 'test/utils';
-describe.concurrent(PersonService.name, () => {
- let defaultDatabase: Kysely<DB>;
+let defaultDatabase: Kysely<DB>;
- const createSut = (db?: Kysely<DB>) => {
- return newMediumService(PersonService, {
- database: db || defaultDatabase,
- repos: {
- access: 'real',
- database: 'real',
- person: 'real',
- storage: 'mock',
- },
- });
- };
-
- beforeEach(async () => {
- defaultDatabase = await getKyselyDB();
+const setup = (db?: Kysely<DB>) => {
+ return newMediumService(PersonService, {
+ database: db || defaultDatabase,
+ real: [AccessRepository, DatabaseRepository, PersonRepository],
+ mock: [LoggingRepository, StorageRepository],
});
+};
+beforeAll(async () => {
+ defaultDatabase = await getKyselyDB();
+});
+
+describe(PersonService.name, () => {
describe('delete', () => {
it('should throw an error when there is no access', async () => {
- const { sut } = createSut();
+ const { sut } = setup();
const auth = factory.auth();
const personId = factory.uuid();
await expect(sut.delete(auth, personId)).rejects.toThrow('Not found or no person.delete access');
});
it('should delete the person', async () => {
- const { sut, getRepository, mocks } = createSut();
-
- const user = mediumFactory.userInsert();
+ const { sut, ctx } = setup();
+ const personRepo = ctx.get(PersonRepository);
+ const storageMock = ctx.getMock(StorageRepository);
+ const { user } = await ctx.newUser();
+ const { person } = await ctx.newPerson({ ownerId: user.id });
const auth = factory.auth({ user });
- const person = mediumFactory.personInsert({ ownerId: auth.user.id });
- mocks.storage.unlink.mockResolvedValue();
-
- const userRepo = getRepository('user');
- await userRepo.create(user);
-
- const personRepo = getRepository('person');
- await personRepo.create(person);
+ storageMock.unlink.mockResolvedValue();
await expect(personRepo.getById(person.id)).resolves.toEqual(expect.objectContaining({ id: person.id }));
await expect(sut.delete(auth, person.id)).resolves.toBeUndefined();
await expect(personRepo.getById(person.id)).resolves.toBeUndefined();
- expect(mocks.storage.unlink).toHaveBeenCalledWith(person.thumbnailPath);
+ expect(storageMock.unlink).toHaveBeenCalledWith(person.thumbnailPath);
});
});
describe('deleteAll', () => {
it('should throw an error when there is no access', async () => {
- const { sut } = createSut();
+ const { sut } = setup();
const auth = factory.auth();
const personId = factory.uuid();
await expect(sut.deleteAll(auth, { ids: [personId] })).rejects.toThrow('Not found or no person.delete access');
});
it('should delete the person', async () => {
- const { sut, getRepository, mocks } = createSut();
-
- const user = mediumFactory.userInsert();
+ const { sut, ctx } = setup();
+ const storageMock = ctx.getMock(StorageRepository);
+ const personRepo = ctx.get(PersonRepository);
+ const { user } = await ctx.newUser();
+ const { person: person1 } = await ctx.newPerson({ ownerId: user.id });
+ const { person: person2 } = await ctx.newPerson({ ownerId: user.id });
const auth = factory.auth({ user });
- const person1 = mediumFactory.personInsert({ ownerId: auth.user.id });
- const person2 = mediumFactory.personInsert({ ownerId: auth.user.id });
- mocks.storage.unlink.mockResolvedValue();
-
- const userRepo = getRepository('user');
- await userRepo.create(user);
-
- const personRepo = getRepository('person');
- await personRepo.create(person1);
- await personRepo.create(person2);
+ storageMock.unlink.mockResolvedValue();
await expect(sut.deleteAll(auth, { ids: [person1.id, person2.id] })).resolves.toBeUndefined();
await expect(personRepo.getById(person1.id)).resolves.toBeUndefined();
await expect(personRepo.getById(person2.id)).resolves.toBeUndefined();
- expect(mocks.storage.unlink).toHaveBeenCalledTimes(2);
- expect(mocks.storage.unlink).toHaveBeenCalledWith(person1.thumbnailPath);
- expect(mocks.storage.unlink).toHaveBeenCalledWith(person2.thumbnailPath);
+ expect(storageMock.unlink).toHaveBeenCalledTimes(2);
+ expect(storageMock.unlink).toHaveBeenCalledWith(person1.thumbnailPath);
+ expect(storageMock.unlink).toHaveBeenCalledWith(person2.thumbnailPath);
});
});
});
diff --git a/server/test/medium/specs/services/user.service.spec.ts b/server/test/medium/specs/services/user.service.spec.ts
index 0113c70158..a16ea3c877 100644
--- a/server/test/medium/specs/services/user.service.spec.ts
+++ b/server/test/medium/specs/services/user.service.spec.ts
@@ -2,72 +2,65 @@ import { Kysely } from 'kysely';
import { DateTime } from 'luxon';
import { DB } from 'src/db';
import { ImmichEnvironment, JobName, JobStatus } from 'src/enum';
+import { ConfigRepository } from 'src/repositories/config.repository';
+import { CryptoRepository } from 'src/repositories/crypto.repository';
+import { JobRepository } from 'src/repositories/job.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';
+import { UserRepository } from 'src/repositories/user.repository';
import { UserService } from 'src/services/user.service';
import { mediumFactory, newMediumService } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB } from 'test/utils';
-describe(UserService.name, () => {
- let defaultDatabase: Kysely<DB>;
-
- const createSut = (db?: Kysely<DB>) => {
- process.env.IMMICH_ENV = ImmichEnvironment.TESTING;
-
- return newMediumService(UserService, {
- database: db || defaultDatabase,
- repos: {
- user: 'real',
- crypto: 'real',
- config: 'real',
- job: 'mock',
- systemMetadata: 'real',
- },
- });
- };
+let defaultDatabase: Kysely<DB>;
+
+const setup = (db?: Kysely<DB>) => {
+ process.env.IMMICH_ENV = ImmichEnvironment.TESTING;
- beforeAll(async () => {
- defaultDatabase = await getKyselyDB();
- const { repos } = createSut();
- await repos.user.create({ isAdmin: true, email: '[email protected]' });
+ return newMediumService(UserService, {
+ database: db || defaultDatabase,
+ real: [CryptoRepository, ConfigRepository, SystemMetadataRepository, UserRepository],
+ mock: [LoggingRepository, JobRepository],
});
+};
+
+beforeAll(async () => {
+ defaultDatabase = await getKyselyDB();
+ const { ctx } = setup();
+ await ctx.newUser({ isAdmin: true, email: '[email protected]' });
+});
+describe(UserService.name, () => {
describe('create', () => {
it('should create a user', async () => {
- const { sut } = createSut();
+ const { sut } = setup();
const user = mediumFactory.userInsert();
-
await expect(sut.createUser({ name: user.name, email: user.email })).resolves.toEqual(
expect.objectContaining({ name: user.name, email: user.email }),
);
});
it('should reject user with duplicate email', async () => {
- const { sut } = createSut();
-
+ const { sut } = setup();
const user = mediumFactory.userInsert();
-
await expect(sut.createUser({ email: user.email })).resolves.toMatchObject({ email: user.email });
await expect(sut.createUser({ email: user.email })).rejects.toThrow('User exists');
});
it('should not return password', async () => {
- const { sut } = createSut();
+ const { sut } = setup();
const dto = mediumFactory.userInsert({ password: 'password' });
-
const user = await sut.createUser({ email: dto.email, password: 'password' });
-
expect((user as any).password).toBeUndefined();
});
});
describe('search', () => {
it('should get users', async () => {
- const { sut, repos } = createSut();
- const user1 = mediumFactory.userInsert();
- const user2 = mediumFactory.userInsert();
-
- await Promise.all([repos.user.create(user1), repos.user.create(user2)]);
-
+ const { sut, ctx } = setup();
+ const { user: user1 } = await ctx.newUser();
+ const { user: user2 } = await ctx.newUser();
const auth = factory.auth({ user: user1 });
await expect(sut.search(auth)).resolves.toEqual(
@@ -81,10 +74,8 @@ describe(UserService.name, () => {
describe('get', () => {
it('should get a user', async () => {
- const { sut, repos } = createSut();
- const user = mediumFactory.userInsert();
-
- await repos.user.create(user);
+ const { sut, ctx } = setup();
+ const { user } = await ctx.newUser();
await expect(sut.get(user.id)).resolves.toEqual(
expect.objectContaining({
@@ -96,11 +87,8 @@ describe(UserService.name, () => {
});
it('should not return password', async () => {
- const { sut, repos } = createSut();
- const user = mediumFactory.userInsert();
-
- await repos.user.create(user);
-
+ const { sut, ctx } = setup();
+ const { user } = await ctx.newUser();
const result = await sut.get(user.id);
expect((result as any).password).toBeUndefined();
@@ -109,10 +97,9 @@ describe(UserService.name, () => {
describe('updateMe', () => {
it('should update a user', async () => {
- const { sut, repos: repositories } = createSut();
-
- const before = await repositories.user.create(mediumFactory.userInsert());
- const auth = factory.auth({ user: { id: before.id } });
+ const { sut, ctx } = setup();
+ const { user, result: before } = await ctx.newUser();
+ const auth = factory.auth({ user: { id: user.id } });
const after = await sut.updateMe(auth, { name: `${before.name} Updated` });
expect(before.updatedAt).toBeDefined();
@@ -128,17 +115,13 @@ describe(UserService.name, () => {
activationKey:
'KuX8KsktrBSiXpQMAH0zLgA5SpijXVr_PDkzLdWUlAogCTMBZ0I3KCHXK0eE9EEd7harxup8_EHMeqAWeHo5VQzol6LGECpFv585U9asXD4Zc-UXt3mhJr2uhazqipBIBwJA2YhmUCDy8hiyiGsukDQNu9Rg9C77UeoKuZBWVjWUBWG0mc1iRqfvF0faVM20w53czAzlhaMxzVGc3Oimbd7xi_CAMSujF_2y8QpA3X2fOVkQkzdcH9lV0COejl7IyH27zQQ9HrlrXv3Lai5Hw67kNkaSjmunVBxC5PS0TpKoc9SfBJMaAGWnaDbjhjYUrm-8nIDQnoeEAidDXVAdPw',
};
- const { sut, repos } = createSut();
- const user = mediumFactory.userInsert();
- await repos.user.create(user);
+ const { sut, ctx } = setup();
+ const { user } = await ctx.newUser();
const auth = factory.auth({ user: { id: user.id } });
-
await expect(sut.getLicense(auth)).rejects.toThrowError();
const after = await sut.setLicense(auth, license);
-
expect(after.licenseKey).toEqual(license.licenseKey);
expect(after.activationKey).toEqual(license.activationKey);
-
const getResponse = await sut.getLicense(auth);
expect(getResponse).toEqual(after);
});
@@ -146,7 +129,7 @@ describe(UserService.name, () => {
describe.sequential('handleUserDeleteCheck', () => {
beforeEach(async () => {
- const { sut } = createSut();
+ const { sut } = setup();
// These tests specifically have to be sequential otherwise we hit race conditions with config changes applying in incorrect tests
const config = await sut.getConfig({ withCache: false });
config.user.deleteDelay = 7;
@@ -154,52 +137,43 @@ describe(UserService.name, () => {
});
it('should work when there are no deleted users', async () => {
- const { sut, mocks } = createSut();
- mocks.job.queueAll.mockResolvedValue(void 0);
-
+ const { sut, ctx } = setup();
+ const jobMock = ctx.getMock(JobRepository);
+ jobMock.queueAll.mockResolvedValue(void 0);
await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
- expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([]);
+ expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([]);
});
it('should work when there is a user to delete', async () => {
- const { sut, repos, mocks } = createSut(await getKyselyDB());
- mocks.job.queueAll.mockResolvedValue(void 0);
- const user = mediumFactory.userInsert({ deletedAt: DateTime.now().minus({ days: 60 }).toJSDate() });
- await repos.user.create(user);
-
+ const { sut, ctx } = setup(await getKyselyDB());
+ const jobMock = ctx.getMock(JobRepository);
+ const { user } = await ctx.newUser({ deletedAt: DateTime.now().minus({ days: 60 }).toJSDate() });
+ jobMock.queueAll.mockResolvedValue(void 0);
await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
- expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([
+ expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([
{ name: JobName.USER_DELETION, data: { id: user.id } },
]);
});
it('should skip a recently deleted user', async () => {
- const { sut, repos, mocks } = createSut(await getKyselyDB());
- mocks.job.queueAll.mockResolvedValue(void 0);
- const user = mediumFactory.userInsert({ deletedAt: DateTime.now().minus({ days: 5 }).toJSDate() });
- await repos.user.create(user);
-
+ const { sut, ctx } = setup(await getKyselyDB());
+ const jobMock = ctx.getMock(JobRepository);
+ await ctx.newUser({ deletedAt: DateTime.now().minus({ days: 5 }).toJSDate() });
+ jobMock.queueAll.mockResolvedValue(void 0);
await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
- expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([]);
+ expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([]);
});
it('should respect a custom user delete delay', async () => {
- const { sut, repos, mocks } = createSut(await getKyselyDB());
- mocks.job.queueAll.mockResolvedValue(void 0);
- const user = mediumFactory.userInsert({ deletedAt: DateTime.now().minus({ days: 25 }).toJSDate() });
- await repos.user.create(user);
-
+ const { sut, ctx } = setup(await getKyselyDB());
+ const jobMock = ctx.getMock(JobRepository);
+ await ctx.newUser({ deletedAt: DateTime.now().minus({ days: 25 }).toJSDate() });
+ jobMock.queueAll.mockResolvedValue(void 0);
const config = await sut.getConfig({ withCache: false });
config.user.deleteDelay = 30;
-
await sut.updateConfig(config);
-
await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
- expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([]);
+ expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([]);
});
});
});
diff --git a/server/test/medium/specs/services/version.service.spec.ts b/server/test/medium/specs/services/version.service.spec.ts
index f99e439e1f..6e9984cc50 100644
--- a/server/test/medium/specs/services/version.service.spec.ts
+++ b/server/test/medium/specs/services/version.service.spec.ts
@@ -2,38 +2,40 @@ import { Kysely } from 'kysely';
import { serverVersion } from 'src/constants';
import { DB } from 'src/db';
import { JobName } from 'src/enum';
+import { DatabaseRepository } from 'src/repositories/database.repository';
+import { JobRepository } from 'src/repositories/job.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { VersionHistoryRepository } from 'src/repositories/version-history.repository';
import { VersionService } from 'src/services/version.service';
import { newMediumService } from 'test/medium.factory';
import { getKyselyDB } from 'test/utils';
-describe(VersionService.name, () => {
- let defaultDatabase: Kysely<DB>;
-
- const setup = (db?: Kysely<DB>) => {
- return newMediumService(VersionService, {
- database: db || defaultDatabase,
- repos: {
- job: 'mock',
- database: 'real',
- versionHistory: 'real',
- },
- });
- };
+let defaultDatabase: Kysely<DB>;
- beforeAll(async () => {
- defaultDatabase = await getKyselyDB();
+const setup = (db?: Kysely<DB>) => {
+ return newMediumService(VersionService, {
+ database: db || defaultDatabase,
+ real: [DatabaseRepository, VersionHistoryRepository],
+ mock: [LoggingRepository, JobRepository],
});
+};
+beforeAll(async () => {
+ defaultDatabase = await getKyselyDB();
+});
+
+describe(VersionService.name, () => {
describe('onBootstrap', () => {
it('record the current version on startup', async () => {
- const { sut, repos } = setup();
+ const { sut, ctx } = setup();
+ const versionHistoryRepo = ctx.get(VersionHistoryRepository);
- const itemsBefore = await repos.versionHistory.getAll();
+ const itemsBefore = await versionHistoryRepo.getAll();
expect(itemsBefore).toHaveLength(0);
await sut.onBootstrap();
- const itemsAfter = await repos.versionHistory.getAll();
+ const itemsAfter = await versionHistoryRepo.getAll();
expect(itemsAfter).toHaveLength(1);
expect(itemsAfter[0]).toEqual({
createdAt: expect.any(Date),
@@ -43,22 +45,26 @@ describe(VersionService.name, () => {
});
it('should queue memory creation when upgrading from 1.128.0', async () => {
- const { sut, repos, mocks } = setup();
- mocks.job.queue.mockResolvedValue(void 0);
+ const { sut, ctx } = setup();
+ const jobMock = ctx.getMock(JobRepository);
+ const versionHistoryRepo = ctx.get(VersionHistoryRepository);
+ jobMock.queue.mockResolvedValue(void 0);
- await repos.versionHistory.create({ version: 'v1.128.0' });
+ await versionHistoryRepo.create({ version: 'v1.128.0' });
await sut.onBootstrap();
- expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.MEMORIES_CREATE });
+ expect(jobMock.queue).toHaveBeenCalledWith({ name: JobName.MEMORIES_CREATE });
});
it('should not queue memory creation when upgrading from 1.129.0', async () => {
- const { sut, repos, mocks } = setup();
+ const { sut, ctx } = setup();
+ const jobMock = ctx.getMock(JobRepository);
+ const versionHistoryRepo = ctx.get(VersionHistoryRepository);
- await repos.versionHistory.create({ version: 'v1.129.0' });
+ await versionHistoryRepo.create({ version: 'v1.129.0' });
await sut.onBootstrap();
- expect(mocks.job.queue).not.toHaveBeenCalled();
+ expect(jobMock.queue).not.toHaveBeenCalled();
});
});
});
diff --git a/server/test/medium/specs/sync/sync-album-asset-exif.spec.ts b/server/test/medium/specs/sync/sync-album-asset-exif.spec.ts
index 07ed8e5785..811dbb374b 100644
--- a/server/test/medium/specs/sync/sync-album-asset-exif.spec.ts
+++ b/server/test/medium/specs/sync/sync-album-asset-exif.spec.ts
@@ -1,158 +1,118 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { SyncTestContext } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB, wait } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
defaultDatabase = await getKyselyDB();
});
-describe.concurrent(SyncRequestType.AlbumAssetExifsV1, () => {
+describe(SyncRequestType.AlbumAssetExifsV1, () => {
it('should detect and sync the first album asset exif', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
- await albumRepo.create({ ownerId: user2.id }, [asset.id], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumAssetExifsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- assetId: asset.id,
- city: null,
- country: null,
- dateTimeOriginal: null,
- description: '',
- exifImageHeight: null,
- exifImageWidth: null,
- exposureTime: null,
- fNumber: null,
- fileSizeInByte: null,
- focalLength: null,
- fps: null,
- iso: null,
- latitude: null,
- lensModel: null,
- longitude: null,
- make: 'Canon',
- model: null,
- modifyDate: null,
- orientation: null,
- profileDescription: null,
- projectionType: null,
- rating: null,
- state: null,
- timeZone: null,
- },
- type: SyncEntityType.AlbumAssetExifV1,
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ assetId: asset.id,
+ city: null,
+ country: null,
+ dateTimeOriginal: null,
+ description: '',
+ exifImageHeight: null,
+ exifImageWidth: null,
+ exposureTime: null,
+ fNumber: null,
+ fileSizeInByte: null,
+ focalLength: null,
+ fps: null,
+ iso: null,
+ latitude: null,
+ lensModel: null,
+ longitude: null,
+ make: 'Canon',
+ model: null,
+ modifyDate: null,
+ orientation: null,
+ profileDescription: null,
+ projectionType: null,
+ rating: null,
+ state: null,
+ timeZone: null,
},
- ]),
- );
-
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AlbumAssetExifsV1]);
+ type: SyncEntityType.AlbumAssetExifV1,
+ },
+ ]);
- expect(ackSyncResponse).toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toEqual([]);
});
it('should sync album asset exif for own user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
- await albumRepo.create({ ownerId: auth.user.id }, [asset.id], []);
-
- await expect(testSync(auth, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toHaveLength(1);
+ const { auth, ctx } = await setup();
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toHaveLength(1);
});
it('should not sync album asset exif for unrelated user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user3.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
- await albumRepo.create({ ownerId: user2.id }, [asset.id], [{ userId: user3.id, role: AlbumUserRole.EDITOR }]);
-
- const sessionRepo = getRepository('session');
- const session = mediumFactory.sessionInsert({ userId: user3.id });
- await sessionRepo.create(session);
-
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user3.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: user3.id, role: AlbumUserRole.EDITOR });
+ const { session } = await ctx.newSession({ userId: user3.id });
const authUser3 = factory.auth({ session, user: user3 });
- await expect(testSync(authUser3, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toHaveLength(0);
+ await expect(ctx.syncStream(authUser3, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toHaveLength(0);
});
it('should backfill album assets exif when a user shares an album with you', async () => {
- const { auth, sut, testSync, getRepository } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const assetRepo = getRepository('asset');
- // Asset to check that we do backfill our own assets
- const asset1Owner = mediumFactory.assetInsert({ ownerId: auth.user.id });
- const asset1User2 = mediumFactory.assetInsert({ ownerId: user2.id });
- const asset2User2 = mediumFactory.assetInsert({ ownerId: user2.id });
- const asset3User2 = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset1Owner);
- await assetRepo.upsertExif({ assetId: asset1Owner.id, make: 'asset1Owner' });
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset: asset1Owner } = await ctx.newAsset({ ownerId: auth.user.id });
+ await ctx.newExif({ assetId: asset1Owner.id, make: 'asset1Owner' });
await wait(2);
- await assetRepo.create(asset1User2);
- await assetRepo.upsertExif({ assetId: asset1User2.id, make: 'asset1User2' });
+ const { asset: asset1User2 } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: asset1User2.id, make: 'asset1User2' });
await wait(2);
- await assetRepo.create(asset2User2);
- await assetRepo.upsertExif({ assetId: asset2User2.id, make: 'asset2User2' });
+ const { asset: asset2User2 } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: asset2User2.id, make: 'asset2User2' });
await wait(2);
- await assetRepo.create(asset3User2);
- await assetRepo.upsertExif({ assetId: asset3User2.id, make: 'asset3User2' });
+ const { asset: asset3User2 } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: asset3User2.id, make: 'asset3User2' });
+ const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album1.id, assetId: asset2User2.id });
+ await ctx.newAlbumUser({ albumId: album1.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
- const albumRepo = getRepository('album');
- const album1 = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album1, [asset2User2.id], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
-
- const response = await testSync(auth, [SyncRequestType.AlbumAssetExifsV1]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
expect(response).toHaveLength(1);
expect(response).toEqual([
{
@@ -165,20 +125,20 @@ describe.concurrent(SyncRequestType.AlbumAssetExifsV1, () => {
]);
// ack initial album asset exif sync
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- // create a second album with
- const album2 = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(
- album2,
- [asset1User2.id, asset2User2.id, asset3User2.id, asset1Owner.id],
- [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }],
+ await ctx.syncAckAll(auth, response);
+
+ // create a second album
+ const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
+ await Promise.all(
+ [asset1User2.id, asset2User2.id, asset3User2.id, asset1Owner.id].map((assetId) =>
+ ctx.newAlbumAsset({ albumId: album2.id, assetId }),
+ ),
);
+ await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
// should backfill the album user
- const backfillResponse = await testSync(auth, [SyncRequestType.AlbumAssetExifsV1]);
- expect(backfillResponse).toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -214,9 +174,7 @@ describe.concurrent(SyncRequestType.AlbumAssetExifsV1, () => {
},
]);
- await sut.setAcks(auth, { acks: [backfillResponse[3].ack, backfillResponse.at(-1).ack] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.AlbumAssetExifsV1]);
- expect(finalResponse).toEqual([]);
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toEqual([]);
});
});
diff --git a/server/test/medium/specs/sync/sync-album-asset.spec.ts b/server/test/medium/specs/sync/sync-album-asset.spec.ts
index ea16393f11..ae4833de34 100644
--- a/server/test/medium/specs/sync/sync-album-asset.spec.ts
+++ b/server/test/medium/specs/sync/sync-album-asset.spec.ts
@@ -1,40 +1,32 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { SyncTestContext } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB, wait } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
defaultDatabase = await getKyselyDB();
});
-describe.concurrent(SyncRequestType.AlbumAssetsV1, () => {
+describe(SyncRequestType.AlbumAssetsV1, () => {
it('should detect and sync the first album asset', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
const originalFileName = 'firstAsset';
const checksum = '1115vHcVkZzNp3Q9G+FEA0nu6zUbGb4Tj4UOXkN0wRA=';
const thumbhash = '2225vHcVkZzNp3Q9G+FEA0nu6zUbGb4Tj4UOXkN0wRA=';
const date = new Date().toISOString();
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({
originalFileName,
ownerId: user2.id,
checksum: Buffer.from(checksum, 'base64'),
@@ -45,110 +37,79 @@ describe.concurrent(SyncRequestType.AlbumAssetsV1, () => {
deletedAt: null,
duration: '0:10:00.00000',
});
- await assetRepo.create(asset);
- await albumRepo.create({ ownerId: user2.id }, [asset.id], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumAssetsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- id: asset.id,
- originalFileName,
- ownerId: asset.ownerId,
- thumbhash,
- checksum,
- deletedAt: asset.deletedAt,
- fileCreatedAt: asset.fileCreatedAt,
- fileModifiedAt: asset.fileModifiedAt,
- isFavorite: asset.isFavorite,
- localDateTime: asset.localDateTime,
- type: asset.type,
- visibility: asset.visibility,
- duration: asset.duration,
- },
- type: SyncEntityType.AlbumAssetV1,
- },
- ]),
- );
-
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AlbumAssetsV1]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ id: asset.id,
+ originalFileName,
+ ownerId: asset.ownerId,
+ thumbhash,
+ checksum,
+ deletedAt: asset.deletedAt,
+ fileCreatedAt: asset.fileCreatedAt,
+ fileModifiedAt: asset.fileModifiedAt,
+ isFavorite: asset.isFavorite,
+ localDateTime: asset.localDateTime,
+ type: asset.type,
+ visibility: asset.visibility,
+ duration: asset.duration,
+ },
+ type: SyncEntityType.AlbumAssetV1,
+ },
+ ]);
- expect(ackSyncResponse).toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toEqual([]);
});
it('should sync album asset for own user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- await albumRepo.create({ ownerId: auth.user.id }, [asset.id], []);
+ const { auth, ctx } = await setup();
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
- await expect(testSync(auth, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toHaveLength(1);
});
it('should not sync album asset for unrelated user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user3.id });
- await assetRepo.create(asset);
- await albumRepo.create({ ownerId: user2.id }, [asset.id], [{ userId: user3.id, role: AlbumUserRole.EDITOR }]);
-
- const sessionRepo = getRepository('session');
- const session = mediumFactory.sessionInsert({ userId: user3.id });
- await sessionRepo.create(session);
-
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user3.id });
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: user3.id, role: AlbumUserRole.EDITOR });
+ const { session } = await ctx.newSession({ userId: user3.id });
const authUser3 = factory.auth({ session, user: user3 });
- await expect(testSync(authUser3, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
+ await expect(ctx.syncStream(authUser3, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toHaveLength(0);
});
it('should backfill album assets when a user shares an album with you', async () => {
- const { auth, sut, testSync, getRepository } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const assetRepo = getRepository('asset');
- // Asset to check that we do backfill our own assets
- const asset1Owner = mediumFactory.assetInsert({ ownerId: auth.user.id });
- const asset1User2 = mediumFactory.assetInsert({ ownerId: user2.id });
- const asset2User2 = mediumFactory.assetInsert({ ownerId: user2.id });
- const asset3User2 = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset1Owner);
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset: asset1Owner } = await ctx.newAsset({ ownerId: auth.user.id });
await wait(2);
- await assetRepo.create(asset1User2);
+ const { asset: asset1User2 } = await ctx.newAsset({ ownerId: user2.id });
await wait(2);
- await assetRepo.create(asset2User2);
+ const { asset: asset2User2 } = await ctx.newAsset({ ownerId: user2.id });
await wait(2);
- await assetRepo.create(asset3User2);
-
- const albumRepo = getRepository('album');
- const album1 = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album1, [asset2User2.id], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
+ const { asset: asset3User2 } = await ctx.newAsset({ ownerId: user2.id });
+ await wait(2);
+ const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album1.id, assetId: asset2User2.id });
+ await ctx.newAlbumUser({ albumId: album1.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
- const response = await testSync(auth, [SyncRequestType.AlbumAssetsV1]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
expect(response).toHaveLength(1);
expect(response).toEqual([
{
@@ -161,20 +122,20 @@ describe.concurrent(SyncRequestType.AlbumAssetsV1, () => {
]);
// ack initial album asset sync
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- // create a second album with
- const album2 = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(
- album2,
- [asset1User2.id, asset2User2.id, asset3User2.id, asset1Owner.id],
- [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }],
+ await ctx.syncAckAll(auth, response);
+
+ // create a second album
+ const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
+ await Promise.all(
+ [asset1User2.id, asset2User2.id, asset3User2.id, asset1Owner.id].map((assetId) =>
+ ctx.newAlbumAsset({ albumId: album2.id, assetId }),
+ ),
);
+ await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
// should backfill the album user
- const backfillResponse = await testSync(auth, [SyncRequestType.AlbumAssetsV1]);
- expect(backfillResponse).toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -210,9 +171,7 @@ describe.concurrent(SyncRequestType.AlbumAssetsV1, () => {
},
]);
- await sut.setAcks(auth, { acks: [backfillResponse[3].ack, backfillResponse.at(-1).ack] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.AlbumAssetsV1]);
- expect(finalResponse).toEqual([]);
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toEqual([]);
});
});
diff --git a/server/test/medium/specs/sync/sync-album-to-asset.spec.ts b/server/test/medium/specs/sync/sync-album-to-asset.spec.ts
index 0941ab05b7..c1af6676f8 100644
--- a/server/test/medium/specs/sync/sync-album-to-asset.spec.ts
+++ b/server/test/medium/specs/sync/sync-album-to-asset.spec.ts
@@ -1,173 +1,119 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { AlbumRepository } from 'src/repositories/album.repository';
+import { AssetRepository } from 'src/repositories/asset.repository';
+import { SyncTestContext } from 'test/medium.factory';
import { getKyselyDB, wait } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
defaultDatabase = await getKyselyDB();
});
-describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
+describe(SyncRequestType.AlbumToAssetsV1, () => {
it('should detect and sync the first album to asset relation', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset);
- const album = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album, [asset.id], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- albumId: album.id,
- assetId: asset.id,
- },
- type: SyncEntityType.AlbumToAssetV1,
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ albumId: album.id,
+ assetId: asset.id,
},
- ]),
- );
-
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
+ type: SyncEntityType.AlbumToAssetV1,
+ },
+ ]);
- expect(ackSyncResponse).toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
it('should sync album to asset for owned albums', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [asset.id], []);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- albumId: album.id,
- assetId: asset.id,
- },
- type: SyncEntityType.AlbumToAssetV1,
- },
- ]),
- );
+ const { auth, ctx } = await setup();
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ albumId: album.id,
+ assetId: asset.id,
+ },
+ type: SyncEntityType.AlbumToAssetV1,
+ },
+ ]);
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(ackSyncResponse).toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
it('should detect and sync the album to asset for shared albums', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- const album = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album, [asset.id], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- albumId: album.id,
- assetId: asset.id,
- },
- type: SyncEntityType.AlbumToAssetV1,
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ albumId: album.id,
+ assetId: asset.id,
},
- ]),
- );
-
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
+ type: SyncEntityType.AlbumToAssetV1,
+ },
+ ]);
- expect(ackSyncResponse).toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
it('should not sync album to asset for an album owned by another user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset);
- await albumRepo.create({ ownerId: user2.id }, [asset.id], []);
-
- await expect(testSync(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toHaveLength(0);
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
it('should backfill album to assets when a user shares an album with you', async () => {
- const { auth, sut, testSync, getRepository } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const assetRepo = getRepository('asset');
- const album1Asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(album1Asset);
- const album2Asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(album2Asset);
-
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { asset: album1Asset } = await ctx.newAsset({ ownerId: user2.id });
+ const { asset: album2Asset } = await ctx.newAsset({ ownerId: auth.user.id });
// Backfill album
- const albumRepo = getRepository('album');
- const album2 = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album2, [album2Asset.id], []);
-
+ const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumAsset({ albumId: album2.id, assetId: album2Asset.id });
await wait(2);
+ const { album: album1 } = await ctx.newAlbum({ ownerId: auth.user.id });
+ await ctx.newAlbumAsset({ albumId: album1.id, assetId: album1Asset.id });
- const album1 = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album1, [album1Asset.id], []);
-
- const response = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
expect(response).toHaveLength(1);
expect(response).toEqual([
{
@@ -181,16 +127,14 @@ describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
]);
// ack initial album to asset sync
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
+ await ctx.syncAckAll(auth, response);
// add user to backfill album
- const albumUserRepo = getRepository('albumUser');
- await albumUserRepo.create({ albumsId: album2.id, usersId: auth.user.id, role: AlbumUserRole.EDITOR });
+ await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
// should backfill the album to asset relation
- const backfillResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(backfillResponse).toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -206,26 +150,20 @@ describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
},
]);
- await sut.setAcks(auth, { acks: [backfillResponse[1].ack] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(finalResponse).toEqual([]);
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted album to asset relation', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [asset.id], []);
+ const { auth, ctx } = await setup();
+ const albumRepo = ctx.get(AlbumRepository);
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual([
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: {
@@ -236,16 +174,13 @@ describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
},
]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
+ await ctx.syncAckAll(auth, response);
await albumRepo.removeAssetIds(album.id, [asset.id]);
-
await wait(2);
- const syncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(syncResponse).toHaveLength(1);
- expect(syncResponse).toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: {
@@ -256,26 +191,20 @@ describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
},
]);
- await sut.setAcks(auth, { acks: [syncResponse[0].ack] });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(ackSyncResponse).toEqual([]);
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted album to asset relation when an asset is deleted', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [asset.id], []);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
+ const { auth, ctx } = await setup();
+ const assetRepo = ctx.get(AssetRepository);
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual([
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: {
@@ -286,16 +215,13 @@ describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
},
]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
+ await ctx.syncAckAll(auth, response);
await assetRepo.remove({ id: asset.id });
-
await wait(2);
- const syncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(syncResponse).toHaveLength(1);
- expect(syncResponse).toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: {
@@ -306,26 +232,20 @@ describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
},
]);
- await sut.setAcks(auth, { acks: [syncResponse[0].ack] });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(ackSyncResponse).toEqual([]);
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
it('should not sync a deleted album to asset relation when the album is deleted', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const albumRepo = getRepository('album');
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [asset.id], []);
+ const { auth, ctx } = await setup();
+ const albumRepo = ctx.get(AlbumRepository);
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual([
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: {
@@ -336,15 +256,9 @@ describe.concurrent(SyncRequestType.AlbumToAssetsV1, () => {
},
]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
+ await ctx.syncAckAll(auth, response);
await albumRepo.delete(album.id);
-
await wait(2);
-
- const syncResponse = await testSync(auth, [SyncRequestType.AlbumToAssetsV1]);
- expect(syncResponse).toHaveLength(0);
- expect(syncResponse).toEqual([]);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumToAssetsV1])).resolves.toEqual([]);
});
});
diff --git a/server/test/medium/specs/sync/sync-album-user.spec.ts b/server/test/medium/specs/sync/sync-album-user.spec.ts
index 305bead275..215752ca6e 100644
--- a/server/test/medium/specs/sync/sync-album-user.spec.ts
+++ b/server/test/medium/specs/sync/sync-album-user.spec.ts
@@ -1,17 +1,16 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { AlbumUserRepository } from 'src/repositories/album-user.repository';
+import { SyncTestContext } from 'test/medium.factory';
import { getKyselyDB, wait } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
@@ -20,198 +19,156 @@ beforeAll(async () => {
describe(SyncRequestType.AlbumUsersV1, () => {
it('should sync an album user with the correct properties', async () => {
- const { auth, getRepository, testSync } = await setup();
+ const { auth, ctx } = await setup();
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ const { user } = await ctx.newUser();
+ const { albumUser } = await ctx.newAlbumUser({ albumId: album.id, userId: user.id, role: AlbumUserRole.EDITOR });
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [], []);
-
- const user = mediumFactory.userInsert();
- await userRepo.create(user);
-
- const albumUser = { albumsId: album.id, usersId: user.id, role: AlbumUserRole.EDITOR };
- await albumUserRepo.create(albumUser);
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
- albumId: albumUser.albumsId,
+ albumId: albumUser.albumId,
role: albumUser.role,
- userId: albumUser.usersId,
+ userId: albumUser.userId,
}),
type: SyncEntityType.AlbumUserV1,
},
]);
});
+
describe('owner', () => {
it('should detect and sync a new shared user', async () => {
- const { auth, testSync, getRepository } = await setup();
-
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user1 = mediumFactory.userInsert();
- await userRepo.create(user1);
+ const { auth, ctx } = await setup();
+ const { user: user1 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ const { albumUser } = await ctx.newAlbumUser({ albumId: album.id, userId: user1.id, role: AlbumUserRole.EDITOR });
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [], []);
-
- const albumUser = { albumsId: album.id, usersId: user1.id, role: AlbumUserRole.EDITOR };
- await albumUserRepo.create(albumUser);
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
- albumId: albumUser.albumsId,
+ albumId: albumUser.albumId,
role: albumUser.role,
- userId: albumUser.usersId,
+ userId: albumUser.userId,
}),
type: SyncEntityType.AlbumUserV1,
},
]);
+
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
});
it('should detect and sync an updated shared user', async () => {
- const { auth, testSync, getRepository, sut } = await setup();
-
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user1 = mediumFactory.userInsert();
- await userRepo.create(user1);
+ const { auth, ctx } = await setup();
+ const albumUserRepo = ctx.get(AlbumUserRepository);
+ const { user: user1 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ const { albumUser } = await ctx.newAlbumUser({ albumId: album.id, userId: user1.id, role: AlbumUserRole.EDITOR });
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [], []);
-
- const albumUser = { albumsId: album.id, usersId: user1.id, role: AlbumUserRole.EDITOR };
- await albumUserRepo.create(albumUser);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumUsersV1]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
await albumUserRepo.update({ albumsId: album.id, usersId: user1.id }, { role: AlbumUserRole.VIEWER });
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
- albumId: albumUser.albumsId,
+ albumId: albumUser.albumId,
role: AlbumUserRole.VIEWER,
- userId: albumUser.usersId,
+ userId: albumUser.userId,
}),
type: SyncEntityType.AlbumUserV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted shared user', async () => {
- const { auth, testSync, getRepository, sut } = await setup();
-
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user1 = mediumFactory.userInsert();
- await userRepo.create(user1);
+ const { auth, ctx } = await setup();
+ const albumUserRepo = ctx.get(AlbumUserRepository);
+ const { user: user1 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+ const { albumUser } = await ctx.newAlbumUser({ albumId: album.id, userId: user1.id, role: AlbumUserRole.EDITOR });
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [], []);
-
- const albumUser = { albumsId: album.id, usersId: user1.id, role: AlbumUserRole.EDITOR };
- await albumUserRepo.create(albumUser);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumUsersV1]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(response).toHaveLength(1);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
await albumUserRepo.delete({ albumsId: album.id, usersId: user1.id });
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
- albumId: albumUser.albumsId,
- userId: albumUser.usersId,
+ albumId: albumUser.albumId,
+ userId: albumUser.userId,
}),
type: SyncEntityType.AlbumUserDeleteV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
});
});
describe('shared user', () => {
it('should detect and sync a new shared user', async () => {
- const { auth, testSync, getRepository } = await setup();
-
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user1 = mediumFactory.userInsert();
- await userRepo.create(user1);
-
- const album = mediumFactory.albumInsert({ ownerId: user1.id });
- await albumRepo.create(album, [], []);
-
- const albumUser = { albumsId: album.id, usersId: auth.user.id, role: AlbumUserRole.EDITOR };
- await albumUserRepo.create(albumUser);
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
+ const { auth, ctx } = await setup();
+ const { user: user1 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: user1.id });
+ const { albumUser } = await ctx.newAlbumUser({
+ albumId: album.id,
+ userId: auth.user.id,
+ role: AlbumUserRole.EDITOR,
+ });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
- albumId: albumUser.albumsId,
+ albumId: albumUser.albumId,
role: albumUser.role,
- userId: albumUser.usersId,
+ userId: albumUser.userId,
}),
type: SyncEntityType.AlbumUserV1,
},
]);
+
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
});
it('should detect and sync an updated shared user', async () => {
- const { auth, testSync, getRepository, sut } = await setup();
-
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const owner = mediumFactory.userInsert();
- const user = mediumFactory.userInsert();
- await Promise.all([userRepo.create(owner), userRepo.create(user)]);
+ const { auth, ctx } = await setup();
+ const albumUserRepo = ctx.get(AlbumUserRepository);
+ const { user: owner } = await ctx.newUser();
+ const { user: user } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: owner.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
+ await ctx.newAlbumUser({ albumId: album.id, userId: user.id, role: AlbumUserRole.EDITOR });
- const album = mediumFactory.albumInsert({ ownerId: owner.id });
- await albumRepo.create(
- album,
- [],
- [
- { userId: auth.user.id, role: AlbumUserRole.EDITOR },
- { userId: user.id, role: AlbumUserRole.EDITOR },
- ],
- );
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(response).toHaveLength(2);
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumUsersV1]);
- expect(initialSyncResponse).toHaveLength(2);
- const acks = [initialSyncResponse[1].ack];
- await sut.setAcks(auth, { acks });
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
await albumUserRepo.update({ albumsId: album.id, usersId: user.id }, { role: AlbumUserRole.VIEWER });
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -222,39 +179,29 @@ describe(SyncRequestType.AlbumUsersV1, () => {
type: SyncEntityType.AlbumUserV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted shared user', async () => {
- const { auth, testSync, getRepository, sut } = await setup();
-
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const owner = mediumFactory.userInsert();
- const user = mediumFactory.userInsert();
- await Promise.all([userRepo.create(owner), userRepo.create(user)]);
-
- const album = mediumFactory.albumInsert({ ownerId: owner.id });
- await albumRepo.create(
- album,
- [],
- [
- { userId: auth.user.id, role: AlbumUserRole.EDITOR },
- { userId: user.id, role: AlbumUserRole.EDITOR },
- ],
- );
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumUsersV1]);
- expect(initialSyncResponse).toHaveLength(2);
- const acks = [initialSyncResponse[1].ack];
- await sut.setAcks(auth, { acks });
-
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
-
+ const { auth, ctx } = await setup();
+ const albumUserRepo = ctx.get(AlbumUserRepository);
+ const { user: owner } = await ctx.newUser();
+ const { user: user } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: owner.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
+ await ctx.newAlbumUser({ albumId: album.id, userId: user.id, role: AlbumUserRole.EDITOR });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(response).toHaveLength(2);
+ await ctx.syncAckAll(auth, response);
+
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
await albumUserRepo.delete({ albumsId: album.id, usersId: user.id });
- await expect(testSync(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -264,35 +211,27 @@ describe(SyncRequestType.AlbumUsersV1, () => {
type: SyncEntityType.AlbumUserDeleteV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
});
it('should backfill album users when a user shares an album with you', async () => {
- const { auth, sut, testSync, getRepository } = await setup();
-
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user1 = mediumFactory.userInsert();
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user1);
- await userRepo.create(user2);
-
- const album1 = mediumFactory.albumInsert({ ownerId: user1.id });
- const album2 = mediumFactory.albumInsert({ ownerId: user1.id });
- await albumRepo.create(album1, [], []);
- await albumRepo.create(album2, [], []);
-
+ const { auth, ctx } = await setup();
+ const { user: user1 } = await ctx.newUser();
+ const { user: user2 } = await ctx.newUser();
+ const { album: album1 } = await ctx.newAlbum({ ownerId: user1.id });
+ const { album: album2 } = await ctx.newAlbum({ ownerId: user1.id });
// backfill album user
- await albumUserRepo.create({ albumsId: album1.id, usersId: user1.id, role: AlbumUserRole.EDITOR });
+ await ctx.newAlbumUser({ albumId: album1.id, userId: user1.id, role: AlbumUserRole.EDITOR });
await wait(2);
// initial album user
- await albumUserRepo.create({ albumsId: album2.id, usersId: auth.user.id, role: AlbumUserRole.EDITOR });
+ await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
await wait(2);
// post checkpoint album user
- await albumUserRepo.create({ albumsId: album1.id, usersId: user2.id, role: AlbumUserRole.EDITOR });
+ await ctx.newAlbumUser({ albumId: album1.id, userId: user2.id, role: AlbumUserRole.EDITOR });
- const response = await testSync(auth, [SyncRequestType.AlbumUsersV1]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
expect(response).toHaveLength(1);
expect(response).toEqual([
{
@@ -307,15 +246,13 @@ describe(SyncRequestType.AlbumUsersV1, () => {
]);
// ack initial user
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
+ await ctx.syncAckAll(auth, response);
// get access to the backfill album user
- await albumUserRepo.create({ albumsId: album1.id, usersId: auth.user.id, role: AlbumUserRole.EDITOR });
+ await ctx.newAlbumUser({ albumId: album1.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
// should backfill the album user
- const backfillResponse = await testSync(auth, [SyncRequestType.AlbumUsersV1]);
- expect(backfillResponse).toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -350,10 +287,8 @@ describe(SyncRequestType.AlbumUsersV1, () => {
},
]);
- await sut.setAcks(auth, { acks: [backfillResponse[1].ack, backfillResponse.at(-1).ack] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.AlbumUsersV1]);
- expect(finalResponse).toEqual([]);
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumUsersV1])).resolves.toEqual([]);
});
});
});
diff --git a/server/test/medium/specs/sync/sync-album.spec.ts b/server/test/medium/specs/sync/sync-album.spec.ts
index 7ee7bf624f..90aa8c4576 100644
--- a/server/test/medium/specs/sync/sync-album.spec.ts
+++ b/server/test/medium/specs/sync/sync-album.spec.ts
@@ -1,17 +1,17 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { AlbumUserRepository } from 'src/repositories/album-user.repository';
+import { AlbumRepository } from 'src/repositories/album.repository';
+import { SyncTestContext } from 'test/medium.factory';
import { getKyselyDB } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
@@ -20,11 +20,12 @@ beforeAll(async () => {
describe(SyncRequestType.AlbumsV1, () => {
it('should sync an album with the correct properties', async () => {
- const { auth, getRepository, testSync } = await setup();
- const albumRepo = getRepository('album');
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [], []);
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const { auth, ctx } = await setup();
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -35,14 +36,18 @@ describe(SyncRequestType.AlbumsV1, () => {
type: SyncEntityType.AlbumV1,
},
]);
+
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
it('should detect and sync a new album', async () => {
- const { auth, getRepository, testSync } = await setup();
- const albumRepo = getRepository('album');
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [], []);
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const { auth, ctx } = await setup();
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -51,14 +56,19 @@ describe(SyncRequestType.AlbumsV1, () => {
type: SyncEntityType.AlbumV1,
},
]);
+
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
it('should detect and sync an album delete', async () => {
- const { auth, getRepository, testSync } = await setup();
- const albumRepo = getRepository('album');
- const album = mediumFactory.albumInsert({ ownerId: auth.user.id });
- await albumRepo.create(album, [], []);
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const { auth, ctx } = await setup();
+ const albumRepo = ctx.get(AlbumRepository);
+ const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({
@@ -69,7 +79,10 @@ describe(SyncRequestType.AlbumsV1, () => {
]);
await albumRepo.delete(album.id);
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: {
@@ -78,67 +91,60 @@ describe(SyncRequestType.AlbumsV1, () => {
type: SyncEntityType.AlbumDeleteV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
describe('shared albums', () => {
it('should detect and sync an album create', async () => {
- const { auth, getRepository, testSync } = await setup();
- const albumRepo = getRepository('album');
- const userRepo = getRepository('user');
-
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const album = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album, [], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
-
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({ id: album.id }),
type: SyncEntityType.AlbumV1,
},
]);
+
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
it('should detect and sync an album share (share before sync)', async () => {
- const { auth, getRepository, testSync } = await setup();
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const album = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album, [], []);
- await albumUserRepo.create({ usersId: auth.user.id, albumsId: album.id, role: AlbumUserRole.EDITOR });
-
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
+
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({ id: album.id }),
type: SyncEntityType.AlbumV1,
},
]);
+
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
it('should detect and sync an album share (share after sync)', async () => {
- const { auth, getRepository, sut, testSync } = await setup();
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const userAlbum = mediumFactory.albumInsert({ ownerId: auth.user.id });
- const user2Album = mediumFactory.albumInsert({ ownerId: user2.id });
- await Promise.all([albumRepo.create(user2Album, [], []), albumRepo.create(userAlbum, [], [])]);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumsV1]);
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { album: userAlbum } = await ctx.newAlbum({ ownerId: auth.user.id });
+ const { album: user2Album } = await ctx.newAlbum({ ownerId: user2.id });
- expect(initialSyncResponse).toEqual([
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({ id: userAlbum.id }),
@@ -146,75 +152,76 @@ describe(SyncRequestType.AlbumsV1, () => {
},
]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ await ctx.syncAckAll(auth, response);
+ await ctx.newAlbumUser({ userId: auth.user.id, albumId: user2Album.id, role: AlbumUserRole.EDITOR });
- await albumUserRepo.create({ usersId: auth.user.id, albumsId: user2Album.id, role: AlbumUserRole.EDITOR });
-
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: expect.objectContaining({ id: user2Album.id }),
type: SyncEntityType.AlbumV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
it('should detect and sync an album delete`', async () => {
- const { auth, getRepository, testSync, sut } = await setup();
- const albumRepo = getRepository('album');
- const userRepo = getRepository('user');
-
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
+ const { auth, ctx } = await setup();
+ const albumRepo = ctx.get(AlbumRepository);
+ const { user: user2 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
- const album = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album, [], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toHaveLength(1);
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumsV1]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
await albumRepo.delete(album.id);
-
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: { albumId: album.id },
type: SyncEntityType.AlbumDeleteV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
it('should detect and sync an album unshare as an album delete', async () => {
- const { auth, getRepository, testSync, sut } = await setup();
- const albumRepo = getRepository('album');
- const albumUserRepo = getRepository('albumUser');
- const userRepo = getRepository('user');
-
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
+ const { auth, ctx } = await setup();
+ const albumUserRepo = ctx.get(AlbumUserRepository);
+ const { user: user2 } = await ctx.newUser();
+ const { album } = await ctx.newAlbum({ ownerId: user2.id });
+ await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.EDITOR });
- const album = mediumFactory.albumInsert({ ownerId: user2.id });
- await albumRepo.create(album, [], [{ userId: auth.user.id, role: AlbumUserRole.EDITOR }]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(response).toHaveLength(1);
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AlbumsV1]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
await albumUserRepo.delete({ albumsId: album.id, usersId: auth.user.id });
-
- await expect(testSync(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumsV1]);
+ expect(newResponse).toEqual([
{
ack: expect.any(String),
data: { albumId: album.id },
type: SyncEntityType.AlbumDeleteV1,
},
]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AlbumsV1])).resolves.toEqual([]);
});
});
});
diff --git a/server/test/medium/specs/sync/sync-asset-exif.spec.ts b/server/test/medium/specs/sync/sync-asset-exif.spec.ts
index 9a3bcb4314..8ddb05a2b7 100644
--- a/server/test/medium/specs/sync/sync-asset-exif.spec.ts
+++ b/server/test/medium/specs/sync/sync-asset-exif.spec.ts
@@ -1,100 +1,78 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { SyncTestContext } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
+
beforeAll(async () => {
defaultDatabase = await getKyselyDB();
});
-describe.concurrent(SyncRequestType.AssetExifsV1, () => {
+describe(SyncRequestType.AssetExifsV1, () => {
it('should detect and sync the first asset exif', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AssetExifsV1]);
+ const { auth, ctx } = await setup();
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- assetId: asset.id,
- city: null,
- country: null,
- dateTimeOriginal: null,
- description: '',
- exifImageHeight: null,
- exifImageWidth: null,
- exposureTime: null,
- fNumber: null,
- fileSizeInByte: null,
- focalLength: null,
- fps: null,
- iso: null,
- latitude: null,
- lensModel: null,
- longitude: null,
- make: 'Canon',
- model: null,
- modifyDate: null,
- orientation: null,
- profileDescription: null,
- projectionType: null,
- rating: null,
- state: null,
- timeZone: null,
- },
- type: SyncEntityType.AssetExifV1,
+ const response = await ctx.syncStream(auth, [SyncRequestType.AssetExifsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ assetId: asset.id,
+ city: null,
+ country: null,
+ dateTimeOriginal: null,
+ description: '',
+ exifImageHeight: null,
+ exifImageWidth: null,
+ exposureTime: null,
+ fNumber: null,
+ fileSizeInByte: null,
+ focalLength: null,
+ fps: null,
+ iso: null,
+ latitude: null,
+ lensModel: null,
+ longitude: null,
+ make: 'Canon',
+ model: null,
+ modifyDate: null,
+ orientation: null,
+ profileDescription: null,
+ projectionType: null,
+ rating: null,
+ state: null,
+ timeZone: null,
},
- ]),
- );
+ type: SyncEntityType.AssetExifV1,
+ },
+ ]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AssetExifsV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetExifsV1])).resolves.toEqual([]);
});
it('should only sync asset exif for own user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
-
- const sessionRepo = getRepository('session');
- const session = mediumFactory.sessionInsert({ userId: user2.id });
- await sessionRepo.create(session);
-
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
+ const { session } = await ctx.newSession({ userId: user2.id });
const auth2 = factory.auth({ session, user: user2 });
- await expect(testSync(auth2, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(0);
+
+ await expect(ctx.syncStream(auth2, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(0);
});
});
diff --git a/server/test/medium/specs/sync/sync-asset.spec.ts b/server/test/medium/specs/sync/sync-asset.spec.ts
index 913edac5d9..5ffec3612e 100644
--- a/server/test/medium/specs/sync/sync-asset.spec.ts
+++ b/server/test/medium/specs/sync/sync-asset.spec.ts
@@ -1,35 +1,32 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { AssetRepository } from 'src/repositories/asset.repository';
+import { SyncTestContext } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
defaultDatabase = await getKyselyDB();
});
-describe.concurrent(SyncEntityType.AssetV1, () => {
+describe(SyncEntityType.AssetV1, () => {
it('should detect and sync the first asset', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
const originalFileName = 'firstAsset';
const checksum = '1115vHcVkZzNp3Q9G+FEA0nu6zUbGb4Tj4UOXkN0wRA=';
const thumbhash = '2225vHcVkZzNp3Q9G+FEA0nu6zUbGb4Tj4UOXkN0wRA=';
const date = new Date().toISOString();
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({
+ const { auth, ctx } = await setup();
+ const { asset } = await ctx.newAsset({
originalFileName,
ownerId: auth.user.id,
checksum: Buffer.from(checksum, 'base64'),
@@ -40,96 +37,70 @@ describe.concurrent(SyncEntityType.AssetV1, () => {
deletedAt: null,
duration: '0:10:00.00000',
});
- await assetRepo.create(asset);
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.AssetsV1]);
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- id: asset.id,
- originalFileName,
- ownerId: asset.ownerId,
- thumbhash,
- checksum,
- deletedAt: asset.deletedAt,
- fileCreatedAt: asset.fileCreatedAt,
- fileModifiedAt: asset.fileModifiedAt,
- isFavorite: asset.isFavorite,
- localDateTime: asset.localDateTime,
- type: asset.type,
- visibility: asset.visibility,
- duration: asset.duration,
- },
- type: 'AssetV1',
+ const response = await ctx.syncStream(auth, [SyncRequestType.AssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ id: asset.id,
+ originalFileName,
+ ownerId: asset.ownerId,
+ thumbhash,
+ checksum,
+ deletedAt: asset.deletedAt,
+ fileCreatedAt: asset.fileCreatedAt,
+ fileModifiedAt: asset.fileModifiedAt,
+ isFavorite: asset.isFavorite,
+ localDateTime: asset.localDateTime,
+ type: asset.type,
+ visibility: asset.visibility,
+ duration: asset.duration,
},
- ]),
- );
-
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ type: 'AssetV1',
+ },
+ ]);
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AssetsV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetsV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted asset', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
+ const { auth, ctx } = await setup();
+ const assetRepo = ctx.get(AssetRepository);
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
await assetRepo.remove(asset);
- const response = await testSync(auth, [SyncRequestType.AssetsV1]);
-
+ const response = await ctx.syncStream(auth, [SyncRequestType.AssetsV1]);
expect(response).toHaveLength(1);
- expect(response).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- assetId: asset.id,
- },
- type: 'AssetDeleteV1',
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ assetId: asset.id,
},
- ]),
- );
+ type: 'AssetDeleteV1',
+ },
+ ]);
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.AssetsV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetsV1])).resolves.toEqual([]);
});
it('should not sync an asset or asset delete for an unrelated user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const sessionRepo = getRepository('session');
- const session = mediumFactory.sessionInsert({ userId: user2.id });
- await sessionRepo.create(session);
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset);
-
+ const { auth, ctx } = await setup();
+ const assetRepo = ctx.get(AssetRepository);
+ const { user: user2 } = await ctx.newUser();
+ const { session } = await ctx.newSession({ userId: user2.id });
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
const auth2 = factory.auth({ session, user: user2 });
- expect(await testSync(auth2, [SyncRequestType.AssetsV1])).toHaveLength(1);
- expect(await testSync(auth, [SyncRequestType.AssetsV1])).toHaveLength(0);
+ expect(await ctx.syncStream(auth2, [SyncRequestType.AssetsV1])).toHaveLength(1);
+ expect(await ctx.syncStream(auth, [SyncRequestType.AssetsV1])).toHaveLength(0);
await assetRepo.remove(asset);
- expect(await testSync(auth2, [SyncRequestType.AssetsV1])).toHaveLength(1);
- expect(await testSync(auth, [SyncRequestType.AssetsV1])).toHaveLength(0);
+ expect(await ctx.syncStream(auth2, [SyncRequestType.AssetsV1])).toHaveLength(1);
+ expect(await ctx.syncStream(auth, [SyncRequestType.AssetsV1])).toHaveLength(0);
});
});
diff --git a/server/test/medium/specs/sync/sync-partner-asset-exif.spec.ts b/server/test/medium/specs/sync/sync-partner-asset-exif.spec.ts
index c47c55ecdc..2fee9b09a9 100644
--- a/server/test/medium/specs/sync/sync-partner-asset-exif.spec.ts
+++ b/server/test/medium/specs/sync/sync-partner-asset-exif.spec.ts
@@ -1,18 +1,16 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { SyncTestContext } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB, wait } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
@@ -21,134 +19,89 @@ beforeAll(async () => {
describe(SyncRequestType.PartnerAssetExifsV1, () => {
it('should detect and sync the first partner asset exif', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- assetId: asset.id,
- city: null,
- country: null,
- dateTimeOriginal: null,
- description: '',
- exifImageHeight: null,
- exifImageWidth: null,
- exposureTime: null,
- fNumber: null,
- fileSizeInByte: null,
- focalLength: null,
- fps: null,
- iso: null,
- latitude: null,
- lensModel: null,
- longitude: null,
- make: 'Canon',
- model: null,
- modifyDate: null,
- orientation: null,
- profileDescription: null,
- projectionType: null,
- rating: null,
- state: null,
- timeZone: null,
- },
- type: SyncEntityType.PartnerAssetExifV1,
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ assetId: asset.id,
+ city: null,
+ country: null,
+ dateTimeOriginal: null,
+ description: '',
+ exifImageHeight: null,
+ exifImageWidth: null,
+ exposureTime: null,
+ fNumber: null,
+ fileSizeInByte: null,
+ focalLength: null,
+ fps: null,
+ iso: null,
+ latitude: null,
+ lensModel: null,
+ longitude: null,
+ make: 'Canon',
+ model: null,
+ modifyDate: null,
+ orientation: null,
+ profileDescription: null,
+ projectionType: null,
+ rating: null,
+ state: null,
+ timeZone: null,
},
- ]),
- );
+ type: SyncEntityType.PartnerAssetExifV1,
+ },
+ ]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toEqual([]);
});
it('should not sync partner asset exif for own user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
-
- await expect(testSync(auth, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toHaveLength(0);
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
+
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toHaveLength(0);
});
it('should not sync partner asset exif for unrelated user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
-
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await Promise.all([userRepo.create(user2), userRepo.create(user3)]);
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user3.id });
- await assetRepo.create(asset);
- await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
-
- const sessionRepo = getRepository('session');
- const session = mediumFactory.sessionInsert({ userId: user3.id });
- await sessionRepo.create(session);
-
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const { asset } = await ctx.newAsset({ ownerId: user3.id });
+ await ctx.newExif({ assetId: asset.id, make: 'Canon' });
+ const { session } = await ctx.newSession({ userId: user3.id });
const authUser3 = factory.auth({ session, user: user3 });
- await expect(testSync(authUser3, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toHaveLength(0);
+
+ await expect(ctx.syncStream(authUser3, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toHaveLength(0);
});
it('should backfill partner asset exif when a partner shared their library with you', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const assetRepo = getRepository('asset');
- const assetUser3 = mediumFactory.assetInsert({ ownerId: user3.id });
- const assetUser2 = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(assetUser3);
- await assetRepo.upsertExif({ assetId: assetUser3.id, make: 'Canon' });
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ const { asset: assetUser3 } = await ctx.newAsset({ ownerId: user3.id });
+ await ctx.newExif({ assetId: assetUser3.id, make: 'Canon' });
await wait(2);
- await assetRepo.create(assetUser2);
- await assetRepo.upsertExif({ assetId: assetUser2.id, make: 'Canon' });
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const response = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
+ const { asset: assetUser2 } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: assetUser2.id, make: 'Canon' });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1]);
expect(response).toHaveLength(1);
expect(response).toEqual(
expect.arrayContaining([
@@ -162,189 +115,133 @@ describe(SyncRequestType.PartnerAssetExifsV1, () => {
]),
);
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- await partnerRepo.create({ sharedById: user3.id, sharedWithId: auth.user.id });
- const backfillResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
-
- expect(backfillResponse).toHaveLength(2);
- expect(backfillResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- assetId: assetUser3.id,
- }),
- type: SyncEntityType.PartnerAssetExifBackfillV1,
- },
- {
- ack: expect.any(String),
- data: {},
- type: SyncEntityType.SyncAckV1,
- },
- ]),
- );
-
- const backfillAck = backfillResponse[1].ack;
- await sut.setAcks(auth, { acks: [backfillAck] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
-
- const finalAcks = finalResponse.map(({ ack }) => ack);
- expect(finalAcks).toEqual([]);
+ await ctx.syncAckAll(auth, response);
+ await ctx.newPartner({ sharedById: user3.id, sharedWithId: auth.user.id });
+
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1]);
+ expect(newResponse).toHaveLength(2);
+ expect(newResponse).toEqual([
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ assetId: assetUser3.id,
+ }),
+ type: SyncEntityType.PartnerAssetExifBackfillV1,
+ },
+ {
+ ack: expect.any(String),
+ data: {},
+ type: SyncEntityType.SyncAckV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toEqual([]);
});
it('should handle partners with users ids lower than a uuidv7', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert({ id: '00d4c0af-7695-4cf2-85e6-415eeaf449cb' });
- const user3 = mediumFactory.userInsert({ id: '00e4c0af-7695-4cf2-85e6-415eeaf449cb' });
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const assetRepo = getRepository('asset');
- const assetUser3 = mediumFactory.assetInsert({ ownerId: user3.id });
- await assetRepo.create(assetUser3);
- await assetRepo.upsertExif({ assetId: assetUser3.id, make: 'assetUser3' });
-
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser({ id: '00d4c0af-7695-4cf2-85e6-415eeaf449cb' });
+ const { user: user3 } = await ctx.newUser({ id: '00e4c0af-7695-4cf2-85e6-415eeaf449cb' });
+ const { asset: assetUser3 } = await ctx.newAsset({ ownerId: user3.id });
+ await ctx.newExif({ assetId: assetUser3.id, make: 'assetUser3' });
await wait(2);
+ const { asset: assetUser2 } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: assetUser2.id, make: 'assetUser2' });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
- const assetUser2 = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(assetUser2);
- await assetRepo.upsertExif({ assetId: assetUser2.id, make: 'assetUser2' });
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const response = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
-
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1]);
expect(response).toHaveLength(1);
- expect(response).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- assetId: assetUser2.id,
- }),
- type: SyncEntityType.PartnerAssetExifV1,
- },
- ]),
- );
-
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ assetId: assetUser2.id,
+ }),
+ type: SyncEntityType.PartnerAssetExifV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, response);
// This checks that our ack upsert is correct
- const ackUpsertResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
- expect(ackUpsertResponse).toEqual([]);
-
- await partnerRepo.create({ sharedById: user3.id, sharedWithId: auth.user.id });
-
- const syncAckResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
- expect(syncAckResponse).toHaveLength(2);
- expect(syncAckResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.stringMatching(new RegExp(`${SyncEntityType.PartnerAssetExifBackfillV1}\\|.+?\\|.+`)),
- data: expect.objectContaining({
- assetId: assetUser3.id,
- }),
- type: SyncEntityType.PartnerAssetExifBackfillV1,
- },
- {
- ack: expect.stringContaining(SyncEntityType.PartnerAssetExifBackfillV1),
- data: {},
- type: SyncEntityType.SyncAckV1,
- },
- ]),
- );
-
- const syncAckResponseAcks = syncAckResponse.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks: [syncAckResponseAcks[1]] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
- expect(finalResponse).toEqual([]);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toEqual([]);
+ await ctx.newPartner({ sharedById: user3.id, sharedWithId: auth.user.id });
+
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1]);
+ expect(newResponse).toHaveLength(2);
+ expect(newResponse).toEqual([
+ {
+ ack: expect.stringMatching(new RegExp(`${SyncEntityType.PartnerAssetExifBackfillV1}\\|.+?\\|.+`)),
+ data: expect.objectContaining({
+ assetId: assetUser3.id,
+ }),
+ type: SyncEntityType.PartnerAssetExifBackfillV1,
+ },
+ {
+ ack: expect.stringContaining(SyncEntityType.PartnerAssetExifBackfillV1),
+ data: {},
+ type: SyncEntityType.SyncAckV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toEqual([]);
});
it('should only backfill partner assets created prior to the current partner asset checkpoint', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const assetRepo = getRepository('asset');
- const assetUser3 = mediumFactory.assetInsert({ ownerId: user3.id });
- const assetUser2 = mediumFactory.assetInsert({ ownerId: user2.id });
- const asset2User3 = mediumFactory.assetInsert({ ownerId: user3.id });
- await assetRepo.create(assetUser3);
- await assetRepo.upsertExif({ assetId: assetUser3.id, make: 'assetUser3' });
+ const { auth, ctx } = await setup();
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ const { asset: assetUser3 } = await ctx.newAsset({ ownerId: user3.id });
+ await ctx.newExif({ assetId: assetUser3.id, make: 'assetUser3' });
await wait(2);
- await assetRepo.create(assetUser2);
- await assetRepo.upsertExif({ assetId: assetUser2.id, make: 'assetUser2' });
+ const { asset: assetUser2 } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newExif({ assetId: assetUser2.id, make: 'assetUser2' });
await wait(2);
- await assetRepo.create(asset2User3);
- await assetRepo.upsertExif({ assetId: asset2User3.id, make: 'asset2User3' });
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const response = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
+ const { asset: asset2User3 } = await ctx.newAsset({ ownerId: user3.id });
+ await ctx.newExif({ assetId: asset2User3.id, make: 'asset2User3' });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1]);
expect(response).toHaveLength(1);
- expect(response).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- assetId: assetUser2.id,
- }),
- type: SyncEntityType.PartnerAssetExifV1,
- },
- ]),
- );
-
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- await partnerRepo.create({ sharedById: user3.id, sharedWithId: auth.user.id });
- const backfillResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
-
- expect(backfillResponse).toHaveLength(3);
- expect(backfillResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.stringMatching(new RegExp(`${SyncEntityType.PartnerAssetExifBackfillV1}\\|.+?\\|.+`)),
- data: expect.objectContaining({
- assetId: assetUser3.id,
- }),
- type: SyncEntityType.PartnerAssetExifBackfillV1,
- },
- {
- ack: expect.stringContaining(SyncEntityType.PartnerAssetExifBackfillV1),
- data: {},
- type: SyncEntityType.SyncAckV1,
- },
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- assetId: asset2User3.id,
- }),
- type: SyncEntityType.PartnerAssetExifV1,
- },
- ]),
- );
-
- const backfillAck = backfillResponse[1].ack;
- const partnerAssetAck = backfillResponse[2].ack;
- await sut.setAcks(auth, { acks: [backfillAck, partnerAssetAck] });
- const finalResponse = await testSync(auth, [SyncRequestType.PartnerAssetExifsV1]);
-
- const finalAcks = finalResponse.map(({ ack }) => ack);
- expect(finalAcks).toEqual([]);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ assetId: assetUser2.id,
+ }),
+ type: SyncEntityType.PartnerAssetExifV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, response);
+ await ctx.newPartner({ sharedById: user3.id, sharedWithId: auth.user.id });
+
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1]);
+ expect(newResponse).toHaveLength(3);
+ expect(newResponse).toEqual([
+ {
+ ack: expect.stringMatching(new RegExp(`${SyncEntityType.PartnerAssetExifBackfillV1}\\|.+?\\|.+`)),
+ data: expect.objectContaining({
+ assetId: assetUser3.id,
+ }),
+ type: SyncEntityType.PartnerAssetExifBackfillV1,
+ },
+ {
+ ack: expect.stringContaining(SyncEntityType.PartnerAssetExifBackfillV1),
+ data: {},
+ type: SyncEntityType.SyncAckV1,
+ },
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ assetId: asset2User3.id,
+ }),
+ type: SyncEntityType.PartnerAssetExifV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetExifsV1])).resolves.toEqual([]);
});
});
diff --git a/server/test/medium/specs/sync/sync-partner-asset.spec.ts b/server/test/medium/specs/sync/sync-partner-asset.spec.ts
index fe3d4edbcc..4faa2f6966 100644
--- a/server/test/medium/specs/sync/sync-partner-asset.spec.ts
+++ b/server/test/medium/specs/sync/sync-partner-asset.spec.ts
@@ -1,18 +1,19 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { AssetRepository } from 'src/repositories/asset.repository';
+import { PartnerRepository } from 'src/repositories/partner.repository';
+import { UserRepository } from 'src/repositories/user.repository';
+import { SyncTestContext } from 'test/medium.factory';
import { factory } from 'test/small.factory';
import { getKyselyDB, wait } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
@@ -21,19 +22,15 @@ beforeAll(async () => {
describe(SyncRequestType.PartnerAssetsV1, () => {
it('should detect and sync the first partner asset', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
+ const { auth, ctx } = await setup();
const originalFileName = 'firstPartnerAsset';
const checksum = '1115vHcVkZzNp3Q9G+FEA0nu6zUbGb4Tj4UOXkN0wRA=';
const thumbhash = '2225vHcVkZzNp3Q9G+FEA0nu6zUbGb4Tj4UOXkN0wRA=';
const date = new Date().toISOString();
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({
ownerId: user2.id,
originalFileName,
checksum: Buffer.from(checksum, 'base64'),
@@ -44,315 +41,217 @@ describe(SyncRequestType.PartnerAssetsV1, () => {
deletedAt: null,
duration: '0:10:00.00000',
});
- await assetRepo.create(asset);
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- id: asset.id,
- ownerId: asset.ownerId,
- originalFileName,
- thumbhash,
- checksum,
- deletedAt: null,
- fileCreatedAt: date,
- fileModifiedAt: date,
- isFavorite: false,
- localDateTime: date,
- type: asset.type,
- visibility: asset.visibility,
- duration: asset.duration,
- },
- type: SyncEntityType.PartnerAssetV1,
- },
- ]),
- );
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
- const ackSyncResponse = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ id: asset.id,
+ ownerId: asset.ownerId,
+ originalFileName,
+ thumbhash,
+ checksum,
+ deletedAt: null,
+ fileCreatedAt: date,
+ fileModifiedAt: date,
+ isFavorite: false,
+ localDateTime: date,
+ type: asset.type,
+ visibility: asset.visibility,
+ duration: asset.duration,
+ },
+ type: SyncEntityType.PartnerAssetV1,
+ },
+ ]);
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted partner asset', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
-
- const assetRepo = getRepository('asset');
- await assetRepo.create(asset);
+ const { auth, ctx } = await setup();
+ const assetRepo = ctx.get(AssetRepository);
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
await assetRepo.remove(asset);
- const response = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
-
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1]);
expect(response).toHaveLength(1);
- expect(response).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- assetId: asset.id,
- },
- type: SyncEntityType.PartnerAssetDeleteV1,
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ assetId: asset.id,
},
- ]),
- );
-
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
+ type: SyncEntityType.PartnerAssetDeleteV1,
+ },
+ ]);
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toEqual([]);
});
it('should not sync a deleted partner asset due to a user delete', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const assetRepo = getRepository('asset');
- await assetRepo.create(mediumFactory.assetInsert({ ownerId: user2.id }));
+ const { auth, ctx } = await setup();
+ const userRepo = ctx.get(UserRepository);
+ const { user: user2 } = await ctx.newUser();
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ await ctx.newAsset({ ownerId: user2.id });
await userRepo.delete({ id: user2.id }, true);
-
- const response = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
- expect(response).toHaveLength(0);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toEqual([]);
});
it('should not sync a deleted partner asset due to a partner delete (unshare)', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const assetRepo = getRepository('asset');
- await assetRepo.create(mediumFactory.assetInsert({ ownerId: user2.id }));
-
- const partnerRepo = getRepository('partner');
- const partner = { sharedById: user2.id, sharedWithId: auth.user.id };
- await partnerRepo.create(partner);
-
- await expect(testSync(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(1);
+ const { auth, ctx } = await setup();
+ const partnerRepo = ctx.get(PartnerRepository);
+ const { user: user2 } = await ctx.newUser();
+ await ctx.newAsset({ ownerId: user2.id });
+ const { partner } = await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(1);
await partnerRepo.remove(partner);
-
- await expect(testSync(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toEqual([]);
});
it('should not sync an asset or asset delete for own user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
+ const { auth, ctx } = await setup();
+ const assetRepo = ctx.get(AssetRepository);
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: auth.user.id });
- await assetRepo.create(asset);
+ const { user: user2 } = await ctx.newUser();
+ const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- await expect(testSync(auth, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
await assetRepo.remove(asset);
- await expect(testSync(auth, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
+ await expect(ctx.syncStream(auth, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
});
it('should not sync an asset or asset delete for unrelated user', async () => {
- const { auth, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const sessionRepo = getRepository('session');
- const session = mediumFactory.sessionInsert({ userId: user2.id });
- await sessionRepo.create(session);
+ const { auth, ctx } = await setup();
+ const assetRepo = ctx.get(AssetRepository);
+ const { user: user2 } = await ctx.newUser();
+ const { session } = await ctx.newSession({ userId: user2.id });
+ const { asset } = await ctx.newAsset({ ownerId: user2.id });
const auth2 = factory.auth({ session, user: user2 });
- const assetRepo = getRepository('asset');
- const asset = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(asset);
-
- await expect(testSync(auth2, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
+ await expect(ctx.syncStream(auth2, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
await assetRepo.remove(asset);
- await expect(testSync(auth2, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
- await expect(testSync(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
+ await expect(ctx.syncStream(auth2, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toHaveLength(0);
});
it('should backfill partner assets when a partner shared their library with you', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const assetRepo = getRepository('asset');
- const assetUser3 = mediumFactory.assetInsert({ ownerId: user3.id });
- const assetUser2 = mediumFactory.assetInsert({ ownerId: user2.id });
- await assetRepo.create(assetUser3);
- await wait(2);
- await assetRepo.create(assetUser2);
+ const { auth, ctx } = await setup();
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const response = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ const { asset: assetUser3 } = await ctx.newAsset({ ownerId: user3.id });
+ await wait(2);
+ const { asset: assetUser2 } = await ctx.newAsset({ ownerId: user2.id });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1]);
expect(response).toHaveLength(1);
- expect(response).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- id: assetUser2.id,
- }),
- type: SyncEntityType.PartnerAssetV1,
- },
- ]),
- );
-
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- await partnerRepo.create({ sharedById: user3.id, sharedWithId: auth.user.id });
- const backfillResponse = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
-
- expect(backfillResponse).toHaveLength(2);
- expect(backfillResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- id: assetUser3.id,
- }),
- type: SyncEntityType.PartnerAssetBackfillV1,
- },
- {
- ack: expect.stringContaining(SyncEntityType.PartnerAssetBackfillV1),
- data: {},
- type: SyncEntityType.SyncAckV1,
- },
- ]),
- );
-
- const backfillAck = backfillResponse[1].ack;
- await sut.setAcks(auth, { acks: [backfillAck] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
-
- const finalAcks = finalResponse.map(({ ack }) => ack);
- expect(finalAcks).toEqual([]);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ id: assetUser2.id,
+ }),
+ type: SyncEntityType.PartnerAssetV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, response);
+ await ctx.newPartner({ sharedById: user3.id, sharedWithId: auth.user.id });
+
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1]);
+ expect(newResponse).toHaveLength(2);
+ expect(newResponse).toEqual([
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ id: assetUser3.id,
+ }),
+ type: SyncEntityType.PartnerAssetBackfillV1,
+ },
+ {
+ ack: expect.stringContaining(SyncEntityType.PartnerAssetBackfillV1),
+ data: {},
+ type: SyncEntityType.SyncAckV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toEqual([]);
});
it('should only backfill partner assets created prior to the current partner asset checkpoint', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user2 = mediumFactory.userInsert();
- const user3 = mediumFactory.userInsert();
- await userRepo.create(user2);
- await userRepo.create(user3);
-
- const assetRepo = getRepository('asset');
- const assetUser3 = mediumFactory.assetInsert({ ownerId: user3.id });
- const assetUser2 = mediumFactory.assetInsert({ ownerId: user2.id });
- const asset2User3 = mediumFactory.assetInsert({ ownerId: user3.id });
- await assetRepo.create(assetUser3);
+ const { auth, ctx } = await setup();
+
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ const { asset: assetUser3 } = await ctx.newAsset({ ownerId: user3.id });
await wait(2);
- await assetRepo.create(assetUser2);
+ const { asset: assetUser2 } = await ctx.newAsset({ ownerId: user2.id });
await wait(2);
- await assetRepo.create(asset2User3);
-
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
-
- const response = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
+ const { asset: asset2User3 } = await ctx.newAsset({ ownerId: user3.id });
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1]);
expect(response).toHaveLength(1);
- expect(response).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- id: assetUser2.id,
- }),
- type: SyncEntityType.PartnerAssetV1,
- },
- ]),
- );
-
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- await partnerRepo.create({ sharedById: user3.id, sharedWithId: auth.user.id });
- const backfillResponse = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
-
- expect(backfillResponse).toHaveLength(3);
- expect(backfillResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- id: assetUser3.id,
- }),
- type: SyncEntityType.PartnerAssetBackfillV1,
- },
- {
- ack: expect.stringContaining(SyncEntityType.PartnerAssetBackfillV1),
- data: {},
- type: SyncEntityType.SyncAckV1,
- },
- {
- ack: expect.any(String),
- data: expect.objectContaining({
- id: asset2User3.id,
- }),
- type: SyncEntityType.PartnerAssetV1,
- },
- ]),
- );
-
- const backfillAck = backfillResponse[1].ack;
- const partnerAssetAck = backfillResponse[2].ack;
- await sut.setAcks(auth, { acks: [backfillAck, partnerAssetAck] });
-
- const finalResponse = await testSync(auth, [SyncRequestType.PartnerAssetsV1]);
-
- const finalAcks = finalResponse.map(({ ack }) => ack);
- expect(finalAcks).toEqual([]);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ id: assetUser2.id,
+ }),
+ type: SyncEntityType.PartnerAssetV1,
+ },
+ ]);
+ await ctx.syncAckAll(auth, response);
+
+ await ctx.newPartner({ sharedById: user3.id, sharedWithId: auth.user.id });
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1]);
+ expect(newResponse).toHaveLength(3);
+ expect(newResponse).toEqual([
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ id: assetUser3.id,
+ }),
+ type: SyncEntityType.PartnerAssetBackfillV1,
+ },
+ {
+ ack: expect.stringContaining(SyncEntityType.PartnerAssetBackfillV1),
+ data: {},
+ type: SyncEntityType.SyncAckV1,
+ },
+ {
+ ack: expect.any(String),
+ data: expect.objectContaining({
+ id: asset2User3.id,
+ }),
+ type: SyncEntityType.PartnerAssetV1,
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnerAssetsV1])).resolves.toEqual([]);
});
});
diff --git a/server/test/medium/specs/sync/sync-partner.spec.ts b/server/test/medium/specs/sync/sync-partner.spec.ts
index f262eec853..11d843243d 100644
--- a/server/test/medium/specs/sync/sync-partner.spec.ts
+++ b/server/test/medium/specs/sync/sync-partner.spec.ts
@@ -1,75 +1,58 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { PartnerRepository } from 'src/repositories/partner.repository';
+import { UserRepository } from 'src/repositories/user.repository';
+import { SyncTestContext } from 'test/medium.factory';
import { getKyselyDB } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
defaultDatabase = await getKyselyDB();
});
-describe.concurrent(SyncEntityType.PartnerV1, () => {
+describe(SyncEntityType.PartnerV1, () => {
it('should detect and sync the first partner', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
+ const { auth, user: user1, ctx } = await setup();
- const user1 = auth.user;
- const userRepo = getRepository('user');
- const partnerRepo = getRepository('partner');
+ const { user: user2 } = await ctx.newUser();
+ const { partner } = await ctx.newPartner({ sharedById: user2.id, sharedWithId: user1.id });
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
-
- const partner = await partnerRepo.create({ sharedById: user2.id, sharedWithId: user1.id });
-
- const initialSyncResponse = await testSync(auth, [SyncRequestType.PartnersV1]);
-
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- inTimeline: partner.inTimeline,
- sharedById: partner.sharedById,
- sharedWithId: partner.sharedWithId,
- },
- type: 'PartnerV1',
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnersV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ inTimeline: partner.inTimeline,
+ sharedById: partner.sharedById,
+ sharedWithId: partner.sharedWithId,
},
- ]),
- );
-
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ type: 'PartnerV1',
+ },
+ ]);
- const ackSyncResponse = await testSync(auth, [SyncRequestType.PartnersV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnersV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted partner', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
+ const { auth, user: user1, ctx } = await setup();
- const userRepo = getRepository('user');
- const user1 = auth.user;
- const user2 = mediumFactory.userInsert();
- await userRepo.create(user2);
+ const partnerRepo = ctx.get(PartnerRepository);
- const partnerRepo = getRepository('partner');
- const partner = await partnerRepo.create({ sharedById: user2.id, sharedWithId: user1.id });
+ const { user: user2 } = await ctx.newUser();
+ const { partner } = await ctx.newPartner({ sharedById: user2.id, sharedWithId: user1.id });
await partnerRepo.remove(partner);
- const response = await testSync(auth, [SyncRequestType.PartnersV1]);
-
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnersV1]);
expect(response).toHaveLength(1);
expect(response).toEqual(
expect.arrayContaining([
@@ -84,27 +67,18 @@ describe.concurrent(SyncEntityType.PartnerV1, () => {
]),
);
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.PartnersV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnersV1])).resolves.toEqual([]);
});
it('should detect and sync a partner share both to and from another user', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user1 = auth.user;
- const user2 = await userRepo.create(mediumFactory.userInsert());
-
- const partnerRepo = getRepository('partner');
- const partner1 = await partnerRepo.create({ sharedById: user2.id, sharedWithId: user1.id });
- const partner2 = await partnerRepo.create({ sharedById: user1.id, sharedWithId: user2.id });
+ const { auth, user: user1, ctx } = await setup();
- const response = await testSync(auth, [SyncRequestType.PartnersV1]);
+ const { user: user2 } = await ctx.newUser();
+ const { partner: partner1 } = await ctx.newPartner({ sharedById: user2.id, sharedWithId: user1.id });
+ const { partner: partner2 } = await ctx.newPartner({ sharedById: user1.id, sharedWithId: user2.id });
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnersV1]);
expect(response).toHaveLength(2);
expect(response).toEqual(
expect.arrayContaining([
@@ -129,93 +103,80 @@ describe.concurrent(SyncEntityType.PartnerV1, () => {
]),
);
- await sut.setAcks(auth, { acks: [response[1].ack] });
-
- const ackSyncResponse = await testSync(auth, [SyncRequestType.PartnersV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnersV1])).resolves.toEqual([]);
});
it('should sync a partner and then an update to that same partner', async () => {
- const { auth, sut, getRepository, testSync } = await setup();
-
- const userRepo = getRepository('user');
- const user1 = auth.user;
- const user2 = await userRepo.create(mediumFactory.userInsert());
+ const { auth, user: user1, ctx } = await setup();
- const partnerRepo = getRepository('partner');
- const partner = await partnerRepo.create({ sharedById: user2.id, sharedWithId: user1.id });
+ const partnerRepo = ctx.get(PartnerRepository);
- const initialSyncResponse = await testSync(auth, [SyncRequestType.PartnersV1]);
+ const { user: user2 } = await ctx.newUser();
+ const { partner } = await ctx.newPartner({ sharedById: user2.id, sharedWithId: user1.id });
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- inTimeline: partner.inTimeline,
- sharedById: partner.sharedById,
- sharedWithId: partner.sharedWithId,
- },
- type: 'PartnerV1',
+ const response = await ctx.syncStream(auth, [SyncRequestType.PartnersV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ inTimeline: partner.inTimeline,
+ sharedById: partner.sharedById,
+ sharedWithId: partner.sharedWithId,
},
- ]),
- );
+ type: 'PartnerV1',
+ },
+ ]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ await ctx.syncAckAll(auth, response);
const updated = await partnerRepo.update(
{ sharedById: partner.sharedById, sharedWithId: partner.sharedWithId },
{ inTimeline: true },
);
- const updatedSyncResponse = await testSync(auth, [SyncRequestType.PartnersV1]);
-
- expect(updatedSyncResponse).toHaveLength(1);
- expect(updatedSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- inTimeline: updated.inTimeline,
- sharedById: updated.sharedById,
- sharedWithId: updated.sharedWithId,
- },
- type: 'PartnerV1',
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.PartnersV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ inTimeline: updated.inTimeline,
+ sharedById: updated.sharedById,
+ sharedWithId: updated.sharedWithId,
},
- ]),
- );
+ type: 'PartnerV1',
+ },
+ ]);
+
+ await ctx.syncAckAll(auth, newResponse);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnersV1])).resolves.toEqual([]);
});
it('should not sync a partner or partner delete for an unrelated user', async () => {
- const { auth, getRepository, testSync } = await setup();
+ const { auth, ctx } = await setup();
- const userRepo = getRepository('user');
- const user2 = await userRepo.create(mediumFactory.userInsert());
- const user3 = await userRepo.create(mediumFactory.userInsert());
+ const partnerRepo = ctx.get(PartnerRepository);
- const partnerRepo = getRepository('partner');
- const partner = await partnerRepo.create({ sharedById: user2.id, sharedWithId: user3.id });
-
- expect(await testSync(auth, [SyncRequestType.PartnersV1])).toHaveLength(0);
+ const { user: user2 } = await ctx.newUser();
+ const { user: user3 } = await ctx.newUser();
+ const { partner } = await ctx.newPartner({ sharedById: user2.id, sharedWithId: user3.id });
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnersV1])).resolves.toEqual([]);
await partnerRepo.remove(partner);
-
- expect(await testSync(auth, [SyncRequestType.PartnersV1])).toHaveLength(0);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnersV1])).resolves.toEqual([]);
});
it('should not sync a partner delete after a user is deleted', async () => {
- const { auth, getRepository, testSync } = await setup();
+ const { auth, ctx } = await setup();
- const userRepo = getRepository('user');
- const user2 = await userRepo.create(mediumFactory.userInsert());
+ const userRepo = ctx.get(UserRepository);
- const partnerRepo = getRepository('partner');
- await partnerRepo.create({ sharedById: user2.id, sharedWithId: auth.user.id });
+ const { user: user2 } = await ctx.newUser();
+ await ctx.newPartner({ sharedById: user2.id, sharedWithId: auth.user.id });
await userRepo.delete({ id: user2.id }, true);
- expect(await testSync(auth, [SyncRequestType.PartnersV1])).toHaveLength(0);
+ await expect(ctx.syncStream(auth, [SyncRequestType.PartnersV1])).resolves.toEqual([]);
});
});
diff --git a/server/test/medium/specs/sync/sync-user.spec.ts b/server/test/medium/specs/sync/sync-user.spec.ts
index 2cea38267c..10a06bd9f7 100644
--- a/server/test/medium/specs/sync/sync-user.spec.ts
+++ b/server/test/medium/specs/sync/sync-user.spec.ts
@@ -1,36 +1,35 @@
import { Kysely } from 'kysely';
import { DB } from 'src/db';
import { SyncEntityType, SyncRequestType } from 'src/enum';
-import { mediumFactory, newSyncAuthUser, newSyncTest } from 'test/medium.factory';
+import { UserRepository } from 'src/repositories/user.repository';
+import { SyncTestContext } from 'test/medium.factory';
import { getKyselyDB } from 'test/utils';
let defaultDatabase: Kysely<DB>;
const setup = async (db?: Kysely<DB>) => {
- const database = db || defaultDatabase;
- const result = newSyncTest({ db: database });
- const { auth, create } = newSyncAuthUser();
- await create(database);
- return { ...result, auth };
+ const ctx = new SyncTestContext(db || defaultDatabase);
+ const { auth, user, session } = await ctx.newSyncAuthUser();
+ return { auth, user, session, ctx };
};
beforeAll(async () => {
defaultDatabase = await getKyselyDB();
});
-describe.concurrent(SyncEntityType.UserV1, () => {
+describe(SyncEntityType.UserV1, () => {
it('should detect and sync the first user', async () => {
- const { auth, sut, getRepository, testSync } = await setup(await getKyselyDB());
+ const { auth, ctx } = await setup(await getKyselyDB());
- const userRepo = getRepository('user');
+ const userRepo = ctx.get(UserRepository);
const user = await userRepo.get(auth.user.id, { withDeleted: false });
if (!user) {
expect.fail('First user should exist');
}
- const initialSyncResponse = await testSync(auth, [SyncRequestType.UsersV1]);
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual([
+ const response = await ctx.syncStream(auth, [SyncRequestType.UsersV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
{
ack: expect.any(String),
data: {
@@ -43,21 +42,17 @@ describe.concurrent(SyncEntityType.UserV1, () => {
},
]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
- const ackSyncResponse = await testSync(auth, [SyncRequestType.UsersV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.UsersV1])).resolves.toEqual([]);
});
it('should detect and sync a soft deleted user', async () => {
- const { auth, sut, getRepository, testSync } = await setup(await getKyselyDB());
+ const { auth, ctx } = await setup(await getKyselyDB());
const deletedAt = new Date().toISOString();
- const deletedUser = mediumFactory.userInsert({ deletedAt });
- const deleted = await getRepository('user').create(deletedUser);
+ const { user: deleted } = await ctx.newUser({ deletedAt });
- const response = await testSync(auth, [SyncRequestType.UsersV1]);
+ const response = await ctx.syncStream(auth, [SyncRequestType.UsersV1]);
expect(response).toHaveLength(2);
expect(response).toEqual(
@@ -85,95 +80,81 @@ describe.concurrent(SyncEntityType.UserV1, () => {
]),
);
- const acks = [response[1].ack];
- await sut.setAcks(auth, { acks });
- const ackSyncResponse = await testSync(auth, [SyncRequestType.UsersV1]);
-
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.UsersV1])).resolves.toEqual([]);
});
it('should detect and sync a deleted user', async () => {
- const { auth, sut, getRepository, testSync } = await setup(await getKyselyDB());
+ const { auth, ctx } = await setup(await getKyselyDB());
- const userRepo = getRepository('user');
- const user = mediumFactory.userInsert();
- await userRepo.create(user);
- await userRepo.delete({ id: user.id }, true);
+ const userRepo = ctx.get(UserRepository);
- const response = await testSync(auth, [SyncRequestType.UsersV1]);
+ const { user } = await ctx.newUser();
+ await userRepo.delete({ id: user.id }, true);
+ const response = await ctx.syncStream(auth, [SyncRequestType.UsersV1]);
expect(response).toHaveLength(2);
- expect(response).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- userId: user.id,
- },
- type: 'UserDeleteV1',
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ userId: user.id,
},
- {
- ack: expect.any(String),
- data: {
- deletedAt: null,
- email: auth.user.email,
- id: auth.user.id,
- name: auth.user.name,
- },
- type: 'UserV1',
+ type: 'UserDeleteV1',
+ },
+ {
+ ack: expect.any(String),
+ data: {
+ deletedAt: null,
+ email: auth.user.email,
+ id: auth.user.id,
+ name: auth.user.name,
},
- ]),
- );
-
- const acks = response.map(({ ack }) => ack);
- await sut.setAcks(auth, { acks });
- const ackSyncResponse = await testSync(auth, [SyncRequestType.UsersV1]);
+ type: 'UserV1',
+ },
+ ]);
- expect(ackSyncResponse).toHaveLength(0);
+ await ctx.syncAckAll(auth, response);
+ await expect(ctx.syncStream(auth, [SyncRequestType.UsersV1])).resolves.toEqual([]);
});
it('should sync a user and then an update to that same user', async () => {
- const { auth, sut, getRepository, testSync } = await setup(await getKyselyDB());
+ const { auth, ctx } = await setup(await getKyselyDB());
- const initialSyncResponse = await testSync(auth, [SyncRequestType.UsersV1]);
+ const userRepo = ctx.get(UserRepository);
- expect(initialSyncResponse).toHaveLength(1);
- expect(initialSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- deletedAt: null,
- email: auth.user.email,
- id: auth.user.id,
- name: auth.user.name,
- },
- type: 'UserV1',
+ const response = await ctx.syncStream(auth, [SyncRequestType.UsersV1]);
+ expect(response).toHaveLength(1);
+ expect(response).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ deletedAt: null,
+ email: auth.user.email,
+ id: auth.user.id,
+ name: auth.user.name,
},
- ]),
- );
+ type: 'UserV1',
+ },
+ ]);
- const acks = [initialSyncResponse[0].ack];
- await sut.setAcks(auth, { acks });
+ await ctx.syncAckAll(auth, response);
- const userRepo = getRepository('user');
const updated = await userRepo.update(auth.user.id, { name: 'new name' });
- const updatedSyncResponse = await testSync(auth, [SyncRequestType.UsersV1]);
- expect(updatedSyncResponse).toHaveLength(1);
- expect(updatedSyncResponse).toEqual(
- expect.arrayContaining([
- {
- ack: expect.any(String),
- data: {
- deletedAt: null,
- email: auth.user.email,
- id: auth.user.id,
- name: updated.name,
- },
- type: 'UserV1',
+ const newResponse = await ctx.syncStream(auth, [SyncRequestType.UsersV1]);
+ expect(newResponse).toHaveLength(1);
+ expect(newResponse).toEqual([
+ {
+ ack: expect.any(String),
+ data: {
+ deletedAt: null,
+ email: auth.user.email,
+ id: auth.user.id,
+ name: updated.name,
},
- ]),
- );
+ type: 'UserV1',
+ },
+ ]);
});
});