Fixing tests/bin/sessions, removed nested describes and concurrent test

Author: tegefaulkes

tests/bin/sessions.test.ts

@@ -50,7 +50,7 @@ describe('Session Token Refreshing', () => {
       path.join(os.tmpdir(), 'polykey-test-'),
     );
     nodePath = path.join(dataDir, 'keynode');
-    command = ['vaults', 'list', '-np', nodePath];
+    command = ['agent', 'status', '-np', nodePath];
     passwordFile = path.join(dataDir, 'passwordFile');
     sessionFile = path.join(nodePath, 'token');
     await fs.promises.writeFile(passwordFile, 'password');
@@ -68,6 +68,11 @@ describe('Session Token Refreshing', () => {
     await fs.promises.rmdir(dataDir, { recursive: true });
   });
 
+  beforeEach(async () => {
+    // Invalidate sessions
+    await polykeyAgent.sessionManager.resetKey();
+  });
+
   test('Process should store session token in session file', async () => {
     // Agent has not been unlocked yet
     const result = await testUtils.pkStdio(
@@ -76,7 +81,7 @@ describe('Session Token Refreshing', () => {
       dataDir,
     );
     expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain(vaultName);
+    expect(result.stdout).toContain('LIVE');
 
     const buff = await fs.promises.readFile(sessionFile);
     const newToken = buff.toString() as SessionToken;
@@ -85,131 +90,82 @@ describe('Session Token Refreshing', () => {
     ).not.toThrow();
   });
 
-  describe('After session has been unlocked', () => {
-    beforeAll(async () => {
-      // Authorize session
-      await testUtils.pkStdio(
-        ['agent', 'unlock', '-np', nodePath, '--password-file', passwordFile],
-        {},
-        dataDir,
-      );
-    }, global.polykeyStartupTimeout);
+  test('Process should refresh the session token', async () => {
+    const prevToken = await polykeyAgent.sessionManager.createToken();
+    await fs.promises.writeFile(sessionFile, prevToken);
 
-    test('Process should refresh the session token', async () => {
-      tokenBuffer = await fs.promises.readFile(sessionFile);
-      token = tokenBuffer.toString() as SessionToken;
-      const prevToken = token;
+    // At least 1 second of delay
+    // Expiry time resolution is in seconds
+    await sleep(1100);
+    const result = await testUtils.pkStdio(command, {}, dataDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('LIVE');
 
-      // At least 1 second of delay
-      // Expiry time resolution is in seconds
-      await sleep(1100);
-      const result = await testUtils.pkStdio(command, {}, dataDir);
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout).toContain(vaultName);
+    const buff = await fs.promises.readFile(sessionFile);
+    const newToken = buff.toString() as SessionToken;
+    expect(
+      async () => await polykeyAgent.sessionManager.verifyToken(newToken),
+    ).not.toThrow();
+    // Make sure the first and second tokens are not the same
+    expect(newToken).not.toEqual(prevToken);
+  });
 
-      const buff = await fs.promises.readFile(sessionFile);
-      const newToken = buff.toString() as SessionToken;
-      expect(
-        async () => await polykeyAgent.sessionManager.verifyToken(newToken),
-      ).not.toThrow();
-      // Make sure the first and second tokens are not the same
-      expect(newToken).not.toEqual(prevToken);
-    });
+  test('Serial processes should refresh the session token', async () => {
+    token = await polykeyAgent.sessionManager.createToken();
+    await fs.promises.writeFile(sessionFile, token);
 
-    test('Serial processes should refresh the session token', async () => {
-      let result = await testUtils.pkStdio(command, {}, dataDir);
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout).toContain(vaultName);
+    let result = await testUtils.pkStdio(command, {}, dataDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('LIVE');
 
-      tokenBuffer = await fs.promises.readFile(sessionFile);
-      const token1 = tokenBuffer.toString() as SessionToken;
-      expect(
-        async () => await polykeyAgent.sessionManager.verifyToken(token1),
-      ).not.toThrow();
+    tokenBuffer = await fs.promises.readFile(sessionFile);
+    const token1 = tokenBuffer.toString() as SessionToken;
+    expect(
+      async () => await polykeyAgent.sessionManager.verifyToken(token1),
+    ).not.toThrow();
 
-      // At least 1 second of delay
-      // Expiry time resolution is in seconds
-      await sleep(1100);
-      result = await testUtils.pkStdio(command, {}, dataDir);
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout).toContain(vaultName);
+    // At least 1 second of delay
+    // Expiry time resolution is in seconds
+    await sleep(1100);
+    result = await testUtils.pkStdio(command, {}, dataDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('LIVE');
 
-      tokenBuffer = await fs.promises.readFile(sessionFile);
-      const token2 = tokenBuffer.toString() as SessionToken;
-      expect(
-        async () => await polykeyAgent.sessionManager.verifyToken(token2),
-      ).not.toThrow();
+    tokenBuffer = await fs.promises.readFile(sessionFile);
+    const token2 = tokenBuffer.toString() as SessionToken;
+    expect(
+      async () => await polykeyAgent.sessionManager.verifyToken(token2),
+    ).not.toThrow();
 
-      // Make sure the first and second tokens are not the same
-      expect(token1).not.toEqual(token2);
-    });
+    // Make sure the first and second tokens are not the same
+    expect(token1).not.toEqual(token2);
+  });
 
-    test(
-      'Failing processes should unlock the session file',
-      async () => {
-        const result = await testUtils.pkStdio(
-          ['vaults', 'delete', 'NotAVault', '-np', nodePath],
-          {},
-          dataDir,
-        );
-        expect(result.exitCode).not.toBe(0);
-
-        tokenBuffer = await fs.promises.readFile(sessionFile);
-        token = tokenBuffer.toString() as SessionToken;
-        expect(
-          async () => await polykeyAgent.sessionManager.verifyToken(token),
-        ).not.toThrow();
-
-        // Try to lock the session file to ensure it's unlocked
-        const fd = fs.openSync(sessionFile, 'r');
-        expect(lock(fd)).toBeTruthy();
-        lock.unlock(fd);
-        fs.closeSync(fd);
-      },
-      global.failedConnectionTimeout,
-    );
+  test(
+    'Failing processes should unlock the session file',
+    async () => {
+      token = await polykeyAgent.sessionManager.createToken();
+      await fs.promises.writeFile(sessionFile, token);
 
-    test('Parallel processes should not refresh the session token', async () => {
-      let tokenP1 = 'token1' as SessionToken;
-      let tokenP2 = 'token2' as SessionToken;
+      const result = await testUtils.pkStdio(
+        ['vaults', 'delete', 'NotAVault', '-np', nodePath],
+        {},
+        dataDir,
+      );
+      expect(result.exitCode).not.toBe(0);
 
       tokenBuffer = await fs.promises.readFile(sessionFile);
-      const prevTokenParallel = tokenBuffer.toString() as SessionToken;
-
-      async function runListCommand(): Promise<SessionToken> {
-        // At least 1 second of delay
-        // Expiry time resolution is in seconds
-        await sleep(1000);
-        await testUtils.pkStdio(command, {}, dataDir);
-        const buffer = await fs.promises.readFile(sessionFile);
-        return buffer.toString() as SessionToken;
-      }
-
-      [tokenP1, tokenP2] = await Promise.all([
-        runListCommand(),
-        runListCommand(),
-      ]);
-
-      // Verify both tokens
-      expect(
-        async () => await polykeyAgent.sessionManager.verifyToken(tokenP1),
-      ).not.toThrow();
+      token = tokenBuffer.toString() as SessionToken;
       expect(
-        async () => await polykeyAgent.sessionManager.verifyToken(tokenP2),
+        async () => await polykeyAgent.sessionManager.verifyToken(token),
       ).not.toThrow();
 
-      // Check that both commands were completed
-      expect(tokenP1).not.toEqual('token1');
-      expect(tokenP2).not.toEqual('token2');
-
-      // Check that the session token was refreshed exactly one time
-      if (tokenP1 === prevTokenParallel) {
-        expect(tokenP2).not.toEqual(prevTokenParallel);
-      } else if (tokenP2 === prevTokenParallel) {
-        expect(tokenP1).not.toEqual(prevTokenParallel);
-      } else {
-        expect(tokenP1).toEqual(tokenP2);
-      }
-    });
-  });
+      // Try to lock the session file to ensure it's unlocked
+      const fd = fs.openSync(sessionFile, 'r');
+      expect(lock(fd)).toBeTruthy();
+      lock.unlock(fd);
+      fs.closeSync(fd);
+    },
+    global.failedConnectionTimeout,
+  );
 });