Skip to content

Commit 8c1cc9a

Browse files
tegefaulkestegefaulkes
authored
Merge pull request #830 from MatrixAI/feature-vaultsOps-test-splitting
Split up `VaultOps.test.ts`
2 parents a99942b + 659afa1 commit 8c1cc9a

13 files changed

+1561
-673
lines changed

‎tests/vaults/VaultOps.test.ts‎

Lines changed: 0 additions & 672 deletions
This file was deleted.

‎tests/vaults/VaultOps/addSecret.test.ts‎

Lines changed: 129 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,129 @@
1+
import type { VaultId } from '@/vaults/types';
2+
import type { Vault } from '@/vaults/Vault';
3+
import type KeyRing from '@/keys/KeyRing';
4+
import type { LevelPath } from '@matrixai/db';
5+
import fs from 'fs';
6+
import path from 'path';
7+
import os from 'os';
8+
import { EncryptedFS } from 'encryptedfs';
9+
import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
10+
import { DB } from '@matrixai/db';
11+
import VaultInternal from '@/vaults/VaultInternal';
12+
import * as vaultOps from '@/vaults/VaultOps';
13+
import * as vaultsErrors from '@/vaults/errors';
14+
import * as vaultsUtils from '@/vaults/utils';
15+
import * as keysUtils from '@/keys/utils';
16+
import * as testNodesUtils from '../../nodes/utils';
17+
import * as testVaultsUtils from '../utils';
18+
19+
describe('addSecret', () => {
20+
const logger = new Logger('VaultOps', LogLevel.WARN, [new StreamHandler()]);
21+
22+
const secretName = 'secret';
23+
const secretNameHidden = '.secret';
24+
const secretContent = 'secret-content';
25+
const dirName = 'dir';
26+
27+
let dataDir: string;
28+
let baseEfs: EncryptedFS;
29+
let vaultId: VaultId;
30+
let vaultInternal: VaultInternal;
31+
let vault: Vault;
32+
let db: DB;
33+
let vaultsDbPath: LevelPath;
34+
const vaultIdGenerator = vaultsUtils.createVaultIdGenerator();
35+
const dummyKeyRing = {
36+
getNodeId: () => {
37+
return testNodesUtils.generateRandomNodeId();
38+
},
39+
} as KeyRing;
40+
41+
beforeEach(async () => {
42+
dataDir = await fs.promises.mkdtemp(
43+
path.join(os.tmpdir(), 'polykey-test-'),
44+
);
45+
const dbPath = path.join(dataDir, 'efsDb');
46+
const dbKey = keysUtils.generateKey();
47+
baseEfs = await EncryptedFS.createEncryptedFS({
48+
dbKey,
49+
dbPath,
50+
logger,
51+
});
52+
await baseEfs.start();
53+
54+
vaultId = vaultIdGenerator();
55+
await baseEfs.mkdir(
56+
path.join(vaultsUtils.encodeVaultId(vaultId), 'contents'),
57+
{
58+
recursive: true,
59+
},
60+
);
61+
db = await DB.createDB({
62+
dbPath: path.join(dataDir, 'db'),
63+
logger,
64+
});
65+
vaultsDbPath = ['vaults'];
66+
vaultInternal = await VaultInternal.createVaultInternal({
67+
keyRing: dummyKeyRing,
68+
vaultId,
69+
efs: baseEfs,
70+
logger: logger.getChild(VaultInternal.name),
71+
fresh: true,
72+
db,
73+
vaultsDbPath: vaultsDbPath,
74+
vaultName: 'VaultName',
75+
});
76+
vault = vaultInternal as Vault;
77+
});
78+
afterEach(async () => {
79+
await vaultInternal.stop();
80+
await vaultInternal.destroy();
81+
await db.stop();
82+
await db.destroy();
83+
await baseEfs.stop();
84+
await baseEfs.destroy();
85+
await fs.promises.rm(dataDir, {
86+
force: true,
87+
recursive: true,
88+
});
89+
});
90+
91+
test('adding a secret', async () => {
92+
await vaultOps.addSecret(vault, secretName, secretContent);
93+
await testVaultsUtils.expectSecret(vault, secretName, secretContent);
94+
});
95+
test('add a secret under an existing directory', async () => {
96+
await testVaultsUtils.mkdir(vault, dirName);
97+
const secretPath = path.join(dirName, secretName);
98+
await vaultOps.addSecret(vault, secretPath, secretContent);
99+
await testVaultsUtils.expectSecret(vault, secretPath, secretContent);
100+
});
101+
test('add a secret creating directory', async () => {
102+
const secretPath = path.join(dirName, secretName);
103+
await vaultOps.addSecret(vault, secretPath, secretContent);
104+
await testVaultsUtils.expectSecret(vault, secretPath, secretContent);
105+
});
106+
test(
107+
'adding a secret multiple times',
108+
async () => {
109+
for (let i = 0; i < 5; i++) {
110+
const name = `${secretName}+${i}`;
111+
await vaultOps.addSecret(vault, name, secretContent);
112+
await testVaultsUtils.expectSecret(vault, name, secretContent);
113+
}
114+
},
115+
globalThis.defaultTimeout * 4,
116+
);
117+
test('adding a secret that already exists should fail', async () => {
118+
await vaultOps.addSecret(vault, secretName, secretContent);
119+
const addSecretP = vaultOps.addSecret(vault, secretName, secretContent);
120+
await expect(addSecretP).rejects.toThrow(
121+
vaultsErrors.ErrorSecretsSecretDefined,
122+
);
123+
});
124+
test('adding a hidden secret', async () => {
125+
await vaultOps.addSecret(vault, secretNameHidden, secretContent);
126+
const list = await vaultOps.listSecrets(vault);
127+
expect(list).toContain(secretNameHidden);
128+
});
129+
});

‎tests/vaults/VaultOps/addSecretDirectory.test.ts‎

Lines changed: 196 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,196 @@
1+
import type { VaultId } from '@/vaults/types';
2+
import type { Vault } from '@/vaults/Vault';
3+
import type KeyRing from '@/keys/KeyRing';
4+
import type { LevelPath } from '@matrixai/db';
5+
import fs from 'fs';
6+
import path from 'path';
7+
import os from 'os';
8+
import { EncryptedFS } from 'encryptedfs';
9+
import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
10+
import { DB } from '@matrixai/db';
11+
import VaultInternal from '@/vaults/VaultInternal';
12+
import * as vaultOps from '@/vaults/VaultOps';
13+
import * as vaultsUtils from '@/vaults/utils';
14+
import * as keysUtils from '@/keys/utils';
15+
import * as testNodesUtils from '../../nodes/utils';
16+
17+
describe('addSecretDirectory', () => {
18+
const logger = new Logger('VaultOps', LogLevel.WARN, [new StreamHandler()]);
19+
20+
let dataDir: string;
21+
let baseEfs: EncryptedFS;
22+
let vaultId: VaultId;
23+
let vaultInternal: VaultInternal;
24+
let vault: Vault;
25+
let db: DB;
26+
let vaultsDbPath: LevelPath;
27+
const vaultIdGenerator = vaultsUtils.createVaultIdGenerator();
28+
const dummyKeyRing = {
29+
getNodeId: () => {
30+
return testNodesUtils.generateRandomNodeId();
31+
},
32+
} as KeyRing;
33+
34+
beforeEach(async () => {
35+
dataDir = await fs.promises.mkdtemp(
36+
path.join(os.tmpdir(), 'polykey-test-'),
37+
);
38+
const dbPath = path.join(dataDir, 'efsDb');
39+
const dbKey = keysUtils.generateKey();
40+
baseEfs = await EncryptedFS.createEncryptedFS({
41+
dbKey,
42+
dbPath,
43+
logger,
44+
});
45+
await baseEfs.start();
46+
47+
vaultId = vaultIdGenerator();
48+
await baseEfs.mkdir(
49+
path.join(vaultsUtils.encodeVaultId(vaultId), 'contents'),
50+
{
51+
recursive: true,
52+
},
53+
);
54+
db = await DB.createDB({
55+
dbPath: path.join(dataDir, 'db'),
56+
logger,
57+
});
58+
vaultsDbPath = ['vaults'];
59+
vaultInternal = await VaultInternal.createVaultInternal({
60+
keyRing: dummyKeyRing,
61+
vaultId,
62+
efs: baseEfs,
63+
logger: logger.getChild(VaultInternal.name),
64+
fresh: true,
65+
db,
66+
vaultsDbPath: vaultsDbPath,
67+
vaultName: 'VaultName',
68+
});
69+
vault = vaultInternal as Vault;
70+
});
71+
afterEach(async () => {
72+
await vaultInternal.stop();
73+
await vaultInternal.destroy();
74+
await db.stop();
75+
await db.destroy();
76+
await baseEfs.stop();
77+
await baseEfs.destroy();
78+
await fs.promises.rm(dataDir, {
79+
force: true,
80+
recursive: true,
81+
});
82+
});
83+
84+
test('adding a directory of 1 secret', async () => {
85+
const secretDir = await fs.promises.mkdtemp(
86+
path.join(os.tmpdir(), 'secret-directory-'),
87+
);
88+
const secretDirName = path.basename(secretDir);
89+
const name = 'secret';
90+
const content = keysUtils.getRandomBytes(5);
91+
await fs.promises.writeFile(path.join(secretDir, name), content);
92+
93+
await vaultOps.addSecretDirectory(vault, secretDir, fs);
94+
await expect(
95+
vault.readF((efs) => efs.readdir(secretDirName)),
96+
).resolves.toContain('secret');
97+
98+
await fs.promises.rm(secretDir, {
99+
force: true,
100+
recursive: true,
101+
});
102+
});
103+
test('adding a directory with subdirectories and files', async () => {
104+
const secretDir = await fs.promises.mkdtemp(
105+
path.join(os.tmpdir(), 'secret-directory-'),
106+
);
107+
const secretDirName = path.basename(secretDir);
108+
await fs.promises.mkdir(path.join(secretDir, 'dir1'));
109+
await fs.promises.mkdir(path.join(secretDir, 'dir1', 'dir2'));
110+
await fs.promises.mkdir(path.join(secretDir, 'dir3'));
111+
112+
await fs.promises.writeFile(path.join(secretDir, 'secret1'), 'secret1');
113+
await fs.promises.writeFile(
114+
path.join(secretDir, 'dir1', 'secret2'),
115+
'secret2',
116+
);
117+
await fs.promises.writeFile(
118+
path.join(secretDir, 'dir1', 'dir2', 'secret3'),
119+
'secret3',
120+
);
121+
await fs.promises.writeFile(
122+
path.join(secretDir, 'dir3', 'secret4'),
123+
'secret4',
124+
);
125+
await fs.promises.writeFile(
126+
path.join(secretDir, 'dir3', 'secret5'),
127+
'secret5',
128+
);
129+
130+
await vaultOps.addSecretDirectory(vault, path.join(secretDir), fs);
131+
const list = await vaultOps.listSecrets(vault);
132+
expect(list.sort()).toStrictEqual(
133+
[
134+
path.join(secretDirName, 'secret1'),
135+
path.join(secretDirName, 'dir1', 'secret2'),
136+
path.join(secretDirName, 'dir1', 'dir2', 'secret3'),
137+
path.join(secretDirName, 'dir3', 'secret4'),
138+
path.join(secretDirName, 'dir3', 'secret5'),
139+
].sort(),
140+
);
141+
142+
await fs.promises.rm(secretDir, {
143+
force: true,
144+
recursive: true,
145+
});
146+
});
147+
test('testing the errors handling of adding secret directories', async () => {
148+
const secretDir = await fs.promises.mkdtemp(
149+
path.join(os.tmpdir(), 'secret-directory-'),
150+
);
151+
const secretDirName = path.basename(secretDir);
152+
await fs.promises.mkdir(path.join(secretDir, 'dir1'));
153+
await fs.promises.mkdir(path.join(secretDir, 'dir1', 'dir2'));
154+
await fs.promises.mkdir(path.join(secretDir, 'dir3'));
155+
await fs.promises.writeFile(path.join(secretDir, 'secret1'), 'secret1');
156+
await fs.promises.writeFile(
157+
path.join(secretDir, 'dir1', 'secret2'),
158+
'secret2',
159+
);
160+
await fs.promises.writeFile(
161+
path.join(secretDir, 'dir1', 'dir2', 'secret3'),
162+
'secret3',
163+
);
164+
await fs.promises.writeFile(
165+
path.join(secretDir, 'dir3', 'secret4'),
166+
'secret4',
167+
);
168+
await fs.promises.writeFile(
169+
path.join(secretDir, 'dir3', 'secret5'),
170+
'secret5',
171+
);
172+
173+
await vaultOps.mkdir(vault, secretDirName, { recursive: true });
174+
await vaultOps.addSecret(
175+
vault,
176+
path.join(secretDirName, 'secret1'),
177+
'blocking-secret',
178+
);
179+
await vaultOps.addSecretDirectory(vault, secretDir, fs);
180+
const list = await vaultOps.listSecrets(vault);
181+
expect(list.sort()).toStrictEqual(
182+
[
183+
path.join(secretDirName, 'secret1'),
184+
path.join(secretDirName, 'dir1', 'secret2'),
185+
path.join(secretDirName, 'dir1', 'dir2', 'secret3'),
186+
path.join(secretDirName, 'dir3', 'secret4'),
187+
path.join(secretDirName, 'dir3', 'secret5'),
188+
].sort(),
189+
);
190+
191+
await fs.promises.rm(secretDir, {
192+
force: true,
193+
recursive: true,
194+
});
195+
});
196+
});

0 commit comments

Comments
 (0)