chore: updated mkdir and added tests

[ci skip]

Author: aryanjassal

src/secrets/CommandMkdir.ts

@@ -4,6 +4,8 @@ import * as binUtils from '../utils';
 import * as binOptions from '../utils/options';
 import * as binParsers from '../utils/parsers';
 import * as binProcessors from '../utils/processors';
+import { ErrorMessage } from 'polykey/dist/client/types';
+import { ErrorPolykeyCLIUncaughtException } from '@/errors';
 
 class CommandMkdir extends CommandPolykey {
   constructor(...args: ConstructorParameters<typeof CommandPolykey>) {
@@ -68,7 +70,23 @@ class CommandMkdir extends CommandPolykey {
           }
           await writer.close();
           for await (const result of response.readable) {
-            if (result.error != null) console.error(result.error);
+            if (result.type === 'error') {
+              const error = result as ErrorMessage;
+              let message: string = '';
+              if (error.code === 'ENOENT') {
+                message = 'No such secret or directory';
+              } else if (error.code === 'EEXIST') {
+                message = 'Secret or directory exists';
+              } else {
+                throw new ErrorPolykeyCLIUncaughtException(
+                  `Unexpected error code ${error.code}`,
+                );
+              }
+
+              process.stderr.write(
+                `${error.code}: cannot create directory ${error.reason}: ${message}`,
+              );
+            }
           }
         }, meta);
       } finally {

tests/secrets/mkdir.test.ts

@@ -6,6 +6,7 @@ import PolykeyAgent from 'polykey/dist/PolykeyAgent';
 import { vaultOps } from 'polykey/dist/vaults';
 import * as keysUtils from 'polykey/dist/keys/utils';
 import * as testUtils from '../utils';
+import { remoteErrorCause } from '@/utils';
 
 describe('commandMkdir', () => {
   const password = 'password';
@@ -94,6 +95,106 @@ describe('commandMkdir', () => {
       expect(stat2.isDirectory()).toBeTruthy();
     });
   });
+  test('should fail without recursive set', async () => {
+    const vaultName = 'vault' as VaultName;
+    const dirName1 = 'dir1';
+    const dirName2 = 'dir2';
+    const dirNameNested = `${dirName1}/${dirName2}`;
+    const vaultId = await polykeyAgent.vaultManager.createVault(vaultName);
+
+    command = [
+      'secrets',
+      'mkdir',
+      '-np',
+      dataDir,
+      `${vaultName}:${dirNameNested}`,
+    ];
+
+    const result = await testUtils.pkStdio([...command], {
+      env: { PK_PASSWORD: password },
+      cwd: dataDir,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toBeDefined();
+
+    await polykeyAgent.vaultManager.withVaults([vaultId], async (vault) => {
+      await vault.readF(async (efs) => {
+        const dirName1P = efs.readdir(dirName1);
+        await expect(dirName1P).rejects.toThrow('ENOENT');
+        const dirNameNestedP = efs.readdir(dirNameNested);
+        await expect(dirNameNestedP).rejects.toThrow('ENOENT');
+      });
+    })
+  });
+  test('should fail to make existing directory', async () => {
+    const vaultName = 'vault' as VaultName;
+    const dirName = 'dir-exists';
+    const vaultId = await polykeyAgent.vaultManager.createVault(vaultName);
+
+    await polykeyAgent.vaultManager.withVaults([vaultId], async (vault) => {
+      await vault.writeF(async (efs) => {
+        await efs.mkdir(dirName);
+      });
+    });
+
+    command = [
+      'secrets',
+      'mkdir',
+      '-np',
+      dataDir,
+      `${vaultName}:${dirName}`,
+    ];
+
+    const result = await testUtils.pkStdio([...command], {
+      env: { PK_PASSWORD: password },
+      cwd: dataDir,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toBeDefined();
+
+    await polykeyAgent.vaultManager.withVaults([vaultId], async (vault) => {
+      await vault.readF(async (efs) => {
+        const dirP = efs.readdir(dirName);
+        await expect(dirP).toResolve();
+      });
+    })
+  });
+  test('should fail to make existing secret', async () => {
+    const vaultName = 'vault' as VaultName;
+    const secretName = 'secret-exists';
+    const secretContent = 'secret-content';
+    const vaultId = await polykeyAgent.vaultManager.createVault(vaultName);
+
+    await polykeyAgent.vaultManager.withVaults([vaultId], async (vault) => {
+      await vault.writeF(async (efs) => {
+        await efs.writeFile(secretName, secretContent);
+      });
+    });
+
+    command = [
+      'secrets',
+      'mkdir',
+      '-np',
+      dataDir,
+      `${vaultName}:${secretName}`,
+    ];
+
+    const result = await testUtils.pkStdio([...command], {
+      env: { PK_PASSWORD: password },
+      cwd: dataDir,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toBeDefined();
+
+    await polykeyAgent.vaultManager.withVaults([vaultId], async (vault) => {
+      await vault.readF(async (efs) => {
+        const stat = await efs.stat(secretName);
+        expect(stat.isFile()).toBeTruthy();
+        const contents = await efs.readFile(secretName);
+        expect(contents.toString()).toEqual(secretContent)
+      });
+    })
+  });
   test('should make directories in multiple vaults', async () => {
     const vaultName1 = 'vault1' as VaultName;
     const vaultName2 = 'vault2' as VaultName;