chore(suite-sync): createEnsureSuiteSyncOwner

suite-common/suite-sync/src/owner/tests/createEnsureSuiteSyncOwner.test.ts

@@ -0,0 +1,85 @@
+import { asSuiteSyncOwnerId, asSuiteSyncOwnerSecretHex } from '@suite-common/suite-sync-storage';
+import { asDelegatedIdentityKey } from '@suite-common/suite-types';
+import { asDeviceUniquePath } from '@trezor/connect';
+import { err, ok } from '@trezor/type-utils';
+
+import {
+    CreateEnsureSuiteSyncOwnerDeps,
+    createEnsureSuiteSyncOwner,
+} from '../createEnsureSuiteSyncOwner';
+import { RetrieveSuiteSyncOwnerParams } from '../createRetrieveSuiteSyncOwner';
+
+const device: RetrieveSuiteSyncOwnerParams['device'] = {
+    instance: 0,
+    path: asDeviceUniquePath('path'),
+    state: {
+        staticSessionId: 'A@B:0',
+    },
+    useEmptyPassphrase: false,
+};
+
+const delegatedKey = asDelegatedIdentityKey(
+    '0c9d40cd155e7ddb93e7b3c7b2acd8d75e7a3ebd543a3504c8f8164fb692772b',
+);
+
+const owner = {
+    ownerId: asSuiteSyncOwnerId('owner1'),
+    ownerSecret: asSuiteSyncOwnerSecretHex('owner1secretHex'),
+};
+
+const createDeps = (
+    overrides: Partial<CreateEnsureSuiteSyncOwnerDeps> = {},
+): CreateEnsureSuiteSyncOwnerDeps => ({
+    loadSuiteSyncOwnerFromState: jest.fn().mockResolvedValue(null),
+    retrieveSuiteSyncOwner: jest.fn().mockResolvedValue(ok(owner)),
+    saveSuiteSyncOwner: jest.fn(),
+    ...overrides,
+});
+
+describe(createEnsureSuiteSyncOwner.name, () => {
+    it('returns owner from state when already loaded', async () => {
+        const deps = createDeps({
+            loadSuiteSyncOwnerFromState: jest.fn().mockResolvedValue(owner),
+        });
+
+        const result = await createEnsureSuiteSyncOwner(deps)({ device, delegatedKey });
+
+        expect(result.success).toBe(true);
+        expect(result.success && result.payload).toBe(owner);
+        expect(deps.loadSuiteSyncOwnerFromState).toHaveBeenCalledWith({
+            deviceStaticId: device.state.staticSessionId,
+        });
+        expect(deps.retrieveSuiteSyncOwner).not.toHaveBeenCalled();
+        expect(deps.saveSuiteSyncOwner).not.toHaveBeenCalled();
+    });
+
+    it('retrieves and saves owner when not in state', async () => {
+        const deps = createDeps();
+
+        const result = await createEnsureSuiteSyncOwner(deps)({ device, delegatedKey });
+
+        expect(result.success).toBe(true);
+        expect(result.success && result.payload).toBe(owner);
+        expect(deps.retrieveSuiteSyncOwner).toHaveBeenCalledWith({ device, delegatedKey });
+        expect(deps.saveSuiteSyncOwner).toHaveBeenCalledWith({
+            deviceStaticId: device.state.staticSessionId,
+            suiteSyncOwner: owner,
+        });
+    });
+
+    it('returns error when retrieve fails', async () => {
+        const deviceError = err({
+            type: 'DeviceError' as const,
+            message: 'device disconnected',
+        });
+        const deps = createDeps({
+            retrieveSuiteSyncOwner: jest.fn().mockResolvedValue(deviceError),
+        });
+
+        const result = await createEnsureSuiteSyncOwner(deps)({ device, delegatedKey });
+
+        expect(result.success).toBe(false);
+        expect(!result.success && result.error.type).toBe('DeviceError');
+        expect(deps.saveSuiteSyncOwner).not.toHaveBeenCalled();
+    });
+});

suite-common/suite-sync/src/storage/tests/createEnsureQuota.test.ts

@@ -1,10 +1,10 @@
 import { createMockDeps } from '@suite-common/dependency-injection';
 import {
     SuiteSyncOwner,
-    asDelegatedIdentityKey,
     asSuiteSyncOwnerId,
     asSuiteSyncOwnerSecretHex,
-} from '@suite-common/suite-types';
+} from '@suite-common/suite-sync-storage';
+import { asDelegatedIdentityKey } from '@suite-common/suite-types';
 import { mockSuiteDevice } from '@suite-common/suite-types/mocks';
 import { StaticSessionId } from '@trezor/connect';
 import { ok } from '@trezor/type-utils';