feat(api): adminDeleteUser full support

README.md

@@ -32,7 +32,7 @@ A _Good Enough_ offline emulator for [Amazon Cognito](https://aws.amazon.com/cog
 | AdminAddUserToGroup              | ❌                   |
 | AdminConfirmSignUp               | 🕒 (partial support) |
 | AdminCreateUser                  | 🕒 (partial support) |
-| AdminDeleteUser                  | 🕒 (partial support) |
+| AdminDeleteUser                  | ✅                   |
 | AdminDeleteUserAttributes        | ❌                   |
 | AdminDisableProviderForUser      | ❌                   |
 | AdminDisableUser                 | ❌                   |

integration-tests/aws-sdk/adminDeleteUser.test.ts

@@ -0,0 +1,70 @@
+import { ClockFake } from "../../src/__tests__/clockFake";
+import { UUID } from "../../src/__tests__/patterns";
+import { UserNotFoundError } from "../../src/errors";
+import { withCognitoSdk } from "./setup";
+
+const currentDate = new Date();
+const roundedDate = new Date(currentDate.getTime());
+roundedDate.setMilliseconds(0);
+
+const clock = new ClockFake(currentDate);
+
+describe(
+  "CognitoIdentityServiceProvider.adminDeleteUser",
+  withCognitoSdk(
+    (Cognito) => {
+      it("deletes a user", async () => {
+        const client = Cognito();
+
+        // create the user
+        const createUserResult = await client
+          .adminCreateUser({
+            Username: "abc",
+            UserPoolId: "test",
+
+            // TODO: shouldn't need to supply this
+            TemporaryPassword: "TemporaryPassword",
+          })
+          .promise();
+
+        // verify they exist
+        const beforeUserResult = await client
+          .adminGetUser({
+            Username: "abc",
+            UserPoolId: "test",
+          })
+          .promise();
+
+        expect(beforeUserResult).toEqual({
+          Enabled: true,
+          UserAttributes: createUserResult.User?.Attributes,
+          UserCreateDate: createUserResult.User?.UserCreateDate,
+          UserLastModifiedDate: createUserResult.User?.UserLastModifiedDate,
+          Username: createUserResult.User?.Username,
+          UserStatus: createUserResult.User?.UserStatus,
+        });
+
+        // delete the user
+        await client
+          .adminDeleteUser({
+            Username: "abc",
+            UserPoolId: "test",
+          })
+          .promise();
+
+        // verify they don't exist anymore
+        await expect(
+          client
+            .adminGetUser({
+              Username: "abc",
+              UserPoolId: "test",
+            })
+            .promise()
+        ).rejects.toEqual(new UserNotFoundError("User does not exist"));
+      });
+    },
+    {
+      clock,
+    }
+  )
+);

integration-tests/dataStore.test.ts

@@ -41,6 +41,71 @@ describe("Data Store", () => {
     });
   });
 
+  describe("delete", () => {
+    it("deletes a value", async () => {
+      const dataStore = await createDataStore("example", {}, path);
+
+      await dataStore.set("key1", 1);
+      await dataStore.set("key2", 2);
+
+      const fileBefore = JSON.parse(
+        await readFile(path + "/example.json", "utf-8")
+      );
+
+      expect(fileBefore).toEqual({
+        key1: 1,
+        key2: 2,
+      });
+
+      await dataStore.delete("key1");
+
+      const fileAfter = JSON.parse(
+        await readFile(path + "/example.json", "utf-8")
+      );
+
+      expect(fileAfter).toEqual({
+        key2: 2,
+      });
+    });
+
+    it("deletes a nested value using array syntax", async () => {
+      const dataStore = await createDataStore("example", {}, path);
+
+      await dataStore.set(["key", "a", "b"], 1);
+      await dataStore.set(["key", "a", "c"], 2);
+      await dataStore.set("key2", 3);
+
+      const fileBefore = JSON.parse(
+        await readFile(path + "/example.json", "utf-8")
+      );
+
+      expect(fileBefore).toEqual({
+        key: {
+          a: {
+            b: 1,
+            c: 2,
+          },
+        },
+        key2: 3,
+      });
+
+      await dataStore.delete(["key", "a", "b"]);
+
+      const fileAfter = JSON.parse(
+        await readFile(path + "/example.json", "utf-8")
+      );
+
+      expect(fileAfter).toEqual({
+        key: {
+          a: {
+            c: 2,
+          },
+        },
+        key2: 3,
+      });
+    });
+  });
+
   describe("set", () => {
     it("saves a value", async () => {
       const dataStore = await createDataStore("example", {}, path);

src/__tests__/mockDataStore.ts

@@ -0,0 +1,8 @@
+import { DataStore } from "../services/dataStore";
+
+export const newMockDataStore = (): jest.Mocked<DataStore> => ({
+  delete: jest.fn(),
+  get: jest.fn(),
+  getRoot: jest.fn(),
+  set: jest.fn(),
+});

src/__tests__/mockUserPoolClient.ts

@@ -7,11 +7,12 @@ export const MockUserPoolClient = {
   createAppClient: jest.fn() as jest.MockedFunction<
     UserPoolClient["createAppClient"]
   >,
+  deleteUser: jest.fn() as jest.MockedFunction<UserPoolClient["deleteUser"]>,
   getUserByUsername: jest.fn() as jest.MockedFunction<
     UserPoolClient["getUserByUsername"]
   >,
-  listUsers: jest.fn() as jest.MockedFunction<UserPoolClient["listUsers"]>,
-  saveUser: jest.fn() as jest.MockedFunction<UserPoolClient["saveUser"]>,
   listGroups: jest.fn() as jest.MockedFunction<UserPoolClient["listGroups"]>,
+  listUsers: jest.fn() as jest.MockedFunction<UserPoolClient["listUsers"]>,
   saveGroup: jest.fn() as jest.MockedFunction<UserPoolClient["saveGroup"]>,
+  saveUser: jest.fn() as jest.MockedFunction<UserPoolClient["saveUser"]>,
 };

src/__tests__/testDataBuilder.ts

@@ -1,11 +1,11 @@
 import { User } from "../services/userPoolClient";
 
-export const user = (): User => ({
-  Attributes: [],
-  Enabled: true,
-  Password: "Password123!",
-  UserCreateDate: new Date().getTime(),
-  UserLastModifiedDate: new Date().getTime(),
-  Username: "Username",
-  UserStatus: "CONFIRMED",
+export const user = (partial?: Partial<User>): User => ({
+  Attributes: partial?.Attributes ?? [],
+  Enabled: partial?.Enabled ?? true,
+  Password: partial?.Password ?? "Password123!",
+  UserCreateDate: partial?.UserCreateDate ?? new Date().getTime(),
+  UserLastModifiedDate: partial?.UserLastModifiedDate ?? new Date().getTime(),
+  Username: partial?.Username ?? "Username",
+  UserStatus: partial?.UserStatus ?? "CONFIRMED",
 });

src/errors.ts

@@ -19,8 +19,8 @@ export class NotAuthorizedError extends CognitoError {
 }
 
 export class UserNotFoundError extends CognitoError {
-  public constructor() {
-    super("UserNotFoundException", "User not found");
+  public constructor(message = "User not found") {
+    super("UserNotFoundException", message);
   }
 }
 

src/services/cognitoClient.test.ts

@@ -1,3 +1,4 @@
+import { newMockDataStore } from "../__tests__/mockDataStore";
 import { MockLogger } from "../__tests__/mockLogger";
 import { ResourceNotFoundError } from "../errors";
 import { DateClock } from "./clock";
@@ -13,11 +14,7 @@ describe("Cognito Client", () => {
   const clock = new DateClock();
 
   beforeEach(() => {
-    mockDataStore = {
-      set: jest.fn(),
-      get: jest.fn(),
-      getRoot: jest.fn(),
-    };
+    mockDataStore = newMockDataStore();
     createUserPoolClient = jest.fn().mockResolvedValue(mockUserPool);
     createDataStore = jest.fn().mockResolvedValue(mockDataStore);
   });

src/services/dataStore.ts

@@ -5,9 +5,10 @@ import { promisify } from "util";
 const mkdir = promisify(fs.mkdir);
 
 export interface DataStore {
-  getRoot<T>(): Promise<T | null>;
+  delete(key: string | string[]): Promise<void>;
   get<T>(key: string | string[]): Promise<T | null>;
   get<T>(key: string | string[], defaultValue: T): Promise<T>;
+  getRoot<T>(): Promise<T | null>;
   set<T>(key: string | string[], value: T): Promise<void>;
 }
 
@@ -32,6 +33,13 @@ export const createDataStore: CreateDataStore = async (
   db.default(defaults);
 
   return {
+    async delete(key: string | string[]) {
+      (key instanceof Array ? key : [key])
+        .reduce((acc, k) => acc.get(k), db)
+        .delete();
+      await db.save();
+    },
+
     async getRoot() {
       return (await db.value()) ?? null;
     },