From bf4d2d6013eebf0b02b9ec3cac57c3641bb02071 Mon Sep 17 00:00:00 2001
From: Peter Staples <staplespeter.ni@gmail.com>
Date: Tue, 16 Aug 2022 17:41:29 +0100
Subject: [PATCH] bug-13140 Added tests for class mocks

---
 .../jest-mock/src/__tests__/SuperTestClass.ts |  28 +++
 packages/jest-mock/src/__tests__/TestClass.ts |   3 +
 .../__tests__/class-mocks-dual-import.test.ts | 122 +++++++++++++
 .../class-mocks-single-import.test.ts         | 120 +++++++++++++
 .../src/__tests__/class-mocks-types.ts        |  30 ++++
 .../src/__tests__/class-mocks.test.ts         | 163 ++++++++++++++++++
 6 files changed, 466 insertions(+)
 create mode 100644 packages/jest-mock/src/__tests__/SuperTestClass.ts
 create mode 100644 packages/jest-mock/src/__tests__/TestClass.ts
 create mode 100644 packages/jest-mock/src/__tests__/class-mocks-dual-import.test.ts
 create mode 100644 packages/jest-mock/src/__tests__/class-mocks-single-import.test.ts
 create mode 100644 packages/jest-mock/src/__tests__/class-mocks-types.ts
 create mode 100644 packages/jest-mock/src/__tests__/class-mocks.test.ts

diff --git a/packages/jest-mock/src/__tests__/SuperTestClass.ts b/packages/jest-mock/src/__tests__/SuperTestClass.ts
new file mode 100644
index 000000000000..2ea722af2f3a
--- /dev/null
+++ b/packages/jest-mock/src/__tests__/SuperTestClass.ts
@@ -0,0 +1,28 @@
+export class SuperTestClass {
+  static staticTestProperty = 'staticTestProperty';
+
+  static get staticTestAccessor(): string {
+    return 'staticTestAccessor';
+  }
+
+  static set staticTestAccessor(_x: string) {
+    return;
+  }
+
+  static staticTestMethod(): string {
+    return 'staticTestMethod';
+  }
+
+  testProperty = 'testProperty';
+
+  get testAccessor(): string {
+    return 'testAccessor';
+  }
+  set testAccessor(_x: string) {
+    return;
+  }
+
+  testMethod(): string {
+    return 'testMethod';
+  }
+}
diff --git a/packages/jest-mock/src/__tests__/TestClass.ts b/packages/jest-mock/src/__tests__/TestClass.ts
new file mode 100644
index 000000000000..59b17d7810f6
--- /dev/null
+++ b/packages/jest-mock/src/__tests__/TestClass.ts
@@ -0,0 +1,3 @@
+import {SuperTestClass} from './SuperTestClass';
+
+export default class TestClass extends SuperTestClass {}
diff --git a/packages/jest-mock/src/__tests__/class-mocks-dual-import.test.ts b/packages/jest-mock/src/__tests__/class-mocks-dual-import.test.ts
new file mode 100644
index 000000000000..f017806fce07
--- /dev/null
+++ b/packages/jest-mock/src/__tests__/class-mocks-dual-import.test.ts
@@ -0,0 +1,122 @@
+import {SuperTestClass} from './SuperTestClass';
+import TestClass from './TestClass';
+jest.mock('./SuperTestClass');
+jest.mock('./TestClass');
+
+describe('Testing the mocking of a class hierarchy defined in multiple imports', () => {
+  it('can call an instance method - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass.prototype, 'testMethod')
+      .mockImplementation(() => {
+        return 'mockTestMethod';
+      });
+    const testClassInstance = new SuperTestClass();
+    expect(testClassInstance.testMethod()).toEqual('mockTestMethod');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can call a superclass instance method - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass.prototype, 'testMethod')
+      .mockImplementation(() => {
+        return 'mockTestMethod';
+      });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testMethod()).toEqual('mockTestMethod');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can read a value from an instance getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass.prototype, 'testAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockTestAccessor';
+      });
+    const testClassInstance = new SuperTestClass();
+    expect(testClassInstance.testAccessor).toEqual('mockTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can read a value from a superclass instance getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass.prototype, 'testAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockTestAccessor';
+      });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testAccessor).toEqual('mockTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can write a value to an instance setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass.prototype, 'testAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    const testClassInstance = new SuperTestClass();
+    testClassInstance.testAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can write a value to a superclass instance setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass.prototype, 'testAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    const testClassInstance = new TestClass();
+    testClassInstance.testAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can read a value from a static getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass, 'staticTestAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockStaticTestAccessor';
+      });
+    expect(SuperTestClass.staticTestAccessor).toEqual('mockStaticTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can read a value from a superclass static getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass, 'staticTestAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockStaticTestAccessor';
+      });
+    expect(TestClass.staticTestAccessor).toEqual('mockStaticTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can write a value to a static setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass, 'staticTestAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    SuperTestClass.staticTestAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can write a value to a superclass static setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass, 'staticTestAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    TestClass.staticTestAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/packages/jest-mock/src/__tests__/class-mocks-single-import.test.ts b/packages/jest-mock/src/__tests__/class-mocks-single-import.test.ts
new file mode 100644
index 000000000000..b99054d8734b
--- /dev/null
+++ b/packages/jest-mock/src/__tests__/class-mocks-single-import.test.ts
@@ -0,0 +1,120 @@
+import SuperTestClass, {TestClass} from './class-mocks-types';
+jest.mock('./class-mocks-types');
+
+describe('Testing the mocking of a class hierarchy defined in a single import', () => {
+  it('can call an instance method - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass.prototype, 'testMethod')
+      .mockImplementation(() => {
+        return 'mockTestMethod';
+      });
+    const testClassInstance = new SuperTestClass();
+    expect(testClassInstance.testMethod()).toEqual('mockTestMethod');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can call a superclass instance method - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass.prototype, 'testMethod')
+      .mockImplementation(() => {
+        return 'mockTestMethod';
+      });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testMethod()).toEqual('mockTestMethod');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can read a value from an instance getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass.prototype, 'testAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockTestAccessor';
+      });
+    const testClassInstance = new SuperTestClass();
+    expect(testClassInstance.testAccessor).toEqual('mockTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can read a value from a superclass instance getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass.prototype, 'testAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockTestAccessor';
+      });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testAccessor).toEqual('mockTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can write a value to an instance setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass.prototype, 'testAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    const testClassInstance = new SuperTestClass();
+    testClassInstance.testAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can write a value to a superclass instance setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass.prototype, 'testAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    const testClassInstance = new TestClass();
+    testClassInstance.testAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can read a value from a static getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass, 'staticTestAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockStaticTestAccessor';
+      });
+    expect(SuperTestClass.staticTestAccessor).toEqual('mockStaticTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can read a value from a superclass static getter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass, 'staticTestAccessor', 'get')
+      .mockImplementation(() => {
+        return 'mockStaticTestAccessor';
+      });
+    expect(TestClass.staticTestAccessor).toEqual('mockStaticTestAccessor');
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can write a value to a static setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(SuperTestClass, 'staticTestAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    SuperTestClass.staticTestAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+
+    mockTestMethod.mockClear();
+  });
+
+  it('can write a value to a superclass static setter - Auto-mocked class', () => {
+    const mockTestMethod = jest
+      .spyOn(TestClass, 'staticTestAccessor', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    TestClass.staticTestAccessor = '';
+    expect(mockTestMethod).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/packages/jest-mock/src/__tests__/class-mocks-types.ts b/packages/jest-mock/src/__tests__/class-mocks-types.ts
new file mode 100644
index 000000000000..e39e582e9ad1
--- /dev/null
+++ b/packages/jest-mock/src/__tests__/class-mocks-types.ts
@@ -0,0 +1,30 @@
+export default class SuperTestClass {
+  static staticTestProperty = 'staticTestProperty';
+
+  static get staticTestAccessor(): string {
+    return 'staticTestAccessor';
+  }
+
+  static set staticTestAccessor(_x: string) {
+    return;
+  }
+
+  static staticTestMethod(): string {
+    return 'staticTestMethod';
+  }
+
+  testProperty = 'testProperty';
+
+  get testAccessor(): string {
+    return 'testAccessor';
+  }
+  set testAccessor(_x: string) {
+    return;
+  }
+
+  testMethod(): string {
+    return 'testMethod';
+  }
+}
+
+export class TestClass extends SuperTestClass {}
diff --git a/packages/jest-mock/src/__tests__/class-mocks.test.ts b/packages/jest-mock/src/__tests__/class-mocks.test.ts
new file mode 100644
index 000000000000..e8ddd312aaf9
--- /dev/null
+++ b/packages/jest-mock/src/__tests__/class-mocks.test.ts
@@ -0,0 +1,163 @@
+describe('Testing the mocking of a class', () => {
+  it('can call an instance method', () => {
+    class TestClass {
+      testMethod(): string {
+        return 'testMethod';
+      }
+    }
+
+    jest.spyOn(TestClass.prototype, 'testMethod').mockImplementation(() => {
+      return 'mockTestMethod';
+    });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testMethod()).toEqual('mockTestMethod');
+  });
+
+  it('can call a superclass instance method', () => {
+    class SuperTestClass {
+      testMethod(): string {
+        return 'testMethod';
+      }
+    }
+
+    class TestClass extends SuperTestClass {}
+
+    jest.spyOn(TestClass.prototype, 'testMethod').mockImplementation(() => {
+      return 'mockTestMethod';
+    });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testMethod()).toEqual('mockTestMethod');
+  });
+
+  it('can read a value from an instance getter', () => {
+    class TestClass {
+      get testMethod(): string {
+        return 'testMethod';
+      }
+    }
+
+    jest
+      .spyOn(TestClass.prototype, 'testMethod', 'get')
+      .mockImplementation(() => {
+        return 'mockTestMethod';
+      });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testMethod).toEqual('mockTestMethod');
+  });
+
+  it('can read a value from an superclass instance getter', () => {
+    class SuperTestClass {
+      get testMethod(): string {
+        return 'testMethod';
+      }
+    }
+
+    class TestClass extends SuperTestClass {}
+
+    jest
+      .spyOn(TestClass.prototype, 'testMethod', 'get')
+      .mockImplementation(() => {
+        return 'mockTestMethod';
+      });
+    const testClassInstance = new TestClass();
+    expect(testClassInstance.testMethod).toEqual('mockTestMethod');
+  });
+
+  it('can write a value to an instance setter', () => {
+    class TestClass {
+      set testMethod(_x: string) {
+        return;
+      }
+    }
+
+    const mocktestMethod = jest
+      .spyOn(TestClass.prototype, 'testMethod', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    const testClassInstance = new TestClass();
+    testClassInstance.testMethod = '';
+    expect(mocktestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can write a value to a superclass instance setter', () => {
+    class SuperTestClass {
+      set testMethod(_x: string) {
+        return;
+      }
+    }
+
+    class TestClass extends SuperTestClass {}
+
+    const mocktestMethod = jest
+      .spyOn(TestClass.prototype, 'testMethod', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    const testClassInstance = new TestClass();
+    testClassInstance.testMethod = '';
+    expect(mocktestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can read a value from a static getter', () => {
+    class TestClass {
+      static get testMethod(): string {
+        return 'testMethod';
+      }
+    }
+
+    jest.spyOn(TestClass, 'testMethod', 'get').mockImplementation(() => {
+      return 'mockTestMethod';
+    });
+    expect(TestClass.testMethod).toEqual('mockTestMethod');
+  });
+
+  it('can read a value from a superclass static getter', () => {
+    class SuperTestClass {
+      static get testMethod(): string {
+        return 'testMethod';
+      }
+    }
+
+    class TestClass extends SuperTestClass {}
+
+    jest.spyOn(TestClass, 'testMethod', 'get').mockImplementation(() => {
+      return 'mockTestMethod';
+    });
+    expect(TestClass.testMethod).toEqual('mockTestMethod');
+  });
+
+  it('can write a value to a static setter', () => {
+    class TestClass {
+      static set testMethod(_x: string) {
+        return;
+      }
+    }
+
+    const mocktestMethod = jest
+      .spyOn(TestClass, 'testMethod', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    TestClass.testMethod = '';
+    expect(mocktestMethod).toHaveBeenCalledTimes(1);
+  });
+
+  it('can write a value to a superclass static setter', () => {
+    class SuperTestClass {
+      static set testMethod(_x: string) {
+        return;
+      }
+    }
+
+    class TestClass extends SuperTestClass {}
+
+    const mocktestMethod = jest
+      .spyOn(TestClass, 'testMethod', 'set')
+      .mockImplementation((_x: string) => {
+        return () => {};
+      });
+    TestClass.testMethod = '';
+    expect(mocktestMethod).toHaveBeenCalledTimes(1);
+  });
+});