vitest-gwt 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Eric Siebeneich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,132 @@
+# vitest-gwt
+A small library to help Vitest support given-when-then style testing without a
+bunch of overhead
+
+## Compatibility Chart
+
+vitest-gwt stays in lockstep with vitest's **MAJOR VERSION**. If you're using
+vitest@2.x.x, use vitest-gwt@2.x.x
+
+## Usage
+
+1. Install the package
+    ```bash
+    npm i --save-dev vitest-gwt
+    ```
+2. In your test files, import `test`
+    ```js
+    import test from 'vitest-gwt';
+    ```
+3. Write a test!
+    ```js
+    describe('test context', () => {
+      test('has no expected errors', {
+        given: {
+          mock_vitest_test_function,
+          GOOD_test_case,
+        },
+        when: {
+          executing_test_case,
+        },
+        then: {
+          all_GIVENS_called,
+          all_WHENS_called,
+          all_THENS_called,
+        },
+      });
+    });
+    ```
+
+## [Scenario Test](https://github.com/devzeebo/gwt-runner/blob/main/README.md#scenario-definition)
+
+Sometimes a GWT flow doesn't make sense. You might be writing integration tests.
+Or something that needs to assert something, then do another thing, then assert
+something else.
+
+In these cases, you can use the scenario definition style which allows chaining
+`when` and `then`, followed by `then_when` and `then` blocks.
+
+```ts
+{
+  given: {
+    mock_vitest_test_function,
+    GOOD_test_case,
+  },
+  scenario: [{
+    when: {
+      executing_test_case,
+    },
+    then: {
+      assert_something,
+    },
+  }, {
+    then_when: {
+      user_submits_form,
+    },
+    then: {
+      something_else_happens,
+      yet_another_thing_is_true,
+    },
+  }, {
+    then_when: {
+      something_happens,
+    },
+    then: {
+      expect_error: some_check,
+      and: {
+        something_is_still_true,
+      },
+    }
+  }]
+}
+```
+
+## Disabling a test
+Sometimes you want a test to be disabled in code. Vitest offers this functionality with
+the `xtest` method, and we've duplicated this logic, but with strong typing so you can
+disable your gwt style tests.
+
+```js
+import test, { xtest } from 'vitest-gwt';
+
+describe('test context', () => {
+  test('this test will run', {
+    then: {
+      CANARY,
+    },
+  });
+
+  xtest('this test will NOT run', {
+    when: {
+      oops_we_broke_this,
+    },
+  });
+});
+```
+
+## withAspect
+
+`withAspect` wraps up vitest's `beforeEach` and `afterEach` to allow preparing and
+cleaning up the context before running tests.
+
+```js
+withAspect(
+  // this is the beforeEach. Do your prep work here
+  function(this: Context) {
+  },
+  // this is the afterEach. It is OPTIONAL. If you need to do clean up of
+  // external resources you allocated in the beforeEach, do it here
+  function(this: Context) {
+  }
+)
+```
+
+The `afterEach` has access to whatever values you put on the Context in the
+`beforeEach`. It does NOT have access to the values put on the Context during
+the specific test.
+
+
+## Detailed Usage
+
+Please refer to [gwt-runner](https://github.com/devzeebo/gwt-runner) for
+detailed usage on how to write tests and clauses.

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+import { TestContext } from 'gwt-runner';
+declare const _default: <TContext>(name: string, gwtDefinition: import("gwt-runner").GwtDefinition<TContext>) => void;
+export default _default;
+export { TestContext };
+export declare const withAspect: <T>(before: (this: T) => any, after?: (this: T) => any) => void;

package/lib/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAspect = exports.TestContext = void 0;
+var tslib_1 = require("tslib");
+var vitest_1 = require("vitest");
+var gwt_runner_1 = tslib_1.__importStar(require("gwt-runner"));
+Object.defineProperty(exports, "TestContext", { enumerable: true, get: function () { return gwt_runner_1.TestContext; } });
+var withAspect_1 = tslib_1.__importDefault(require("./withAspect"));
+exports.default = (0, gwt_runner_1.default)(vitest_1.test);
+exports.withAspect = (0, withAspect_1.default)(vitest_1.beforeEach, vitest_1.afterEach);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;AAAA,iCAIgB;AAChB,+DAAoD;AAI3C,4FAJW,wBAAW,OAIX;AAHpB,oEAA6C;AAE7C,kBAAe,IAAA,oBAAS,EAAC,aAAM,CAAC,CAAC;AAGpB,QAAA,UAAU,GAAG,IAAA,oBAAiB,EAAC,mBAAgB,EAAE,kBAAe,CAAC,CAAC"}

package/lib/withAspect.d.ts

@@ -0,0 +1,4 @@
+import type { beforeEach as vitestBeforeEach, afterEach as vitestAfterEach } from 'vitest';
+type Callback<T> = (this: T) => any;
+declare const _default: (beforeEach: typeof vitestBeforeEach, afterEach: typeof vitestAfterEach) => <T>(before: Callback<T>, after?: Callback<T>) => void;
+export default _default;

package/lib/withAspect.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var gwt_runner_1 = require("gwt-runner");
+exports.default = (function (beforeEach, afterEach) { return (function (before, after) {
+    beforeEach(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    gwt_runner_1.TestContext.createContext();
+                    return [4 /*yield*/, before.bind(gwt_runner_1.TestContext.context)()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    afterEach(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!after) return [3 /*break*/, 2];
+                    return [4 /*yield*/, after.bind(gwt_runner_1.TestContext.context)()];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    gwt_runner_1.TestContext.releaseContext();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+}); });
+//# sourceMappingURL=withAspect.js.map

package/lib/withAspect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withAspect.js","sourceRoot":"","sources":["../src/withAspect.ts"],"names":[],"mappings":";;;AAIA,yCAAyC;AAIzC,mBAAe,UACb,UAAmC,EACnC,SAAiC,IAC9B,OAAA,CACH,UACE,MAAmB,EACnB,KAAmB;IAEnB,UAAU,CAAC;;;;oBACT,wBAAW,CAAC,aAAa,EAAE,CAAC;oBAE5B,qBAAO,MAAM,CAAC,IAAI,CAAC,wBAAW,CAAC,OAAY,CAAS,EAAE,EAAA;;oBAAtD,SAAsD,CAAC;;;;SACxD,CAAC,CAAC;IAEH,SAAS,CAAC;;;;yBACJ,KAAK,EAAL,wBAAK;oBACP,qBAAO,KAAK,CAAC,IAAI,CAAC,wBAAW,CAAC,OAAY,CAAS,EAAE,EAAA;;oBAArD,SAAqD,CAAC;;;oBAGxD,wBAAW,CAAC,cAAc,EAAE,CAAC;;;;SAC9B,CAAC,CAAC;AACL,CAAC,CACF,EAnBI,CAmBJ,EAAC"}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "vitest-gwt",
+  "version": "0.0.1",
+  "description": "A small library to help Vitest support given-when-then style testing without a bunch of overhead",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "src",
+    "!**/*.spec.ts"
+  ],
+  "scripts": {
+    "build": "wireit",
+    "test": "wireit",
+    "lint": "wireit",
+    "test:coverage": "wireit",
+    "prepublishOnly": "wireit"
+  },
+  "wireit": {
+    "build": {
+      "command": "tsc --project ./tsconfig.build.json",
+      "files": [
+        "src/**/*.ts",
+        "tsconfig.*",
+        "!src/**/*.spec.ts"
+      ],
+      "output": [
+        "lib/**"
+      ]
+    },
+    "lint": {
+      "command": "eslint ./src"
+    },
+    "test": {
+      "command": "vitest run"
+    },
+    "test:coverage": {
+      "command": "vitest run --coverage"
+    },
+    "prepublishOnly": {
+      "dependencies": [
+        "lint",
+        "test:coverage",
+        "build"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devzeebo/vitest-gwt.git"
+  },
+  "peerDependencies": {
+    "vitest": ">2.0.0"
+  },
+  "keywords": [
+    "vitest",
+    "gwt",
+    "unit",
+    "testing",
+    "given",
+    "when",
+    "then"
+  ],
+  "author": "Eric Siebeneich",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/devzeebo/vitest-gwt/issues"
+  },
+  "homepage": "https://github.com/devzeebo/vitest-gwt#readme",
+  "devDependencies": {
+    "@react-ddd/eslint-config": "^0.3.1",
+    "@types/lodash": "^4.14.198",
+    "@types/node": "^20.6.0",
+    "@vitest/coverage-v8": "^2.0.5",
+    "axios": "^1.5.0",
+    "lodash": "^4.17.21",
+    "typescript": "^5.2.2",
+    "vitest": ">2.0.0",
+    "wireit": "^0.13.0"
+  },
+  "dependencies": {
+    "gwt-runner": "^2.4.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+import {
+  test as vitest,
+  beforeEach as vitestBeforeEach,
+  afterEach as vitestAfterEach,
+} from 'vitest';
+import gwtRunner, { TestContext } from 'gwt-runner';
+import withAspectBuilder from './withAspect';
+
+export default gwtRunner(vitest);
+export { TestContext };
+
+export const withAspect = withAspectBuilder(vitestBeforeEach, vitestAfterEach);

package/src/withAspect.ts

@@ -0,0 +1,31 @@
+import type {
+  beforeEach as vitestBeforeEach,
+  afterEach as vitestAfterEach,
+} from 'vitest';
+import { TestContext } from 'gwt-runner';
+
+type Callback<T> = (this: T) => any;
+
+export default (
+  beforeEach: typeof vitestBeforeEach,
+  afterEach: typeof vitestAfterEach,
+) => (
+  <T>(
+    before: Callback<T>,
+    after?: Callback<T>,
+  ) => {
+    beforeEach(async () => {
+      TestContext.createContext();
+
+      await (before.bind(TestContext.context as T) as any)();
+    });
+
+    afterEach(async () => {
+      if (after) {
+        await (after.bind(TestContext.context as T) as any)();
+      }
+
+      TestContext.releaseContext();
+    });
+  }
+);