{"id":20849810,"url":"https://github.com/garbles/kitimat","last_synced_at":"2025-10-14T11:35:32.767Z","repository":{"id":30771953,"uuid":"125956522","full_name":"garbles/kitimat","owner":"garbles","description":"A library for generative, property-based testing in TypeScript and Jest.","archived":false,"fork":false,"pushed_at":"2022-12-07T09:17:11.000Z","size":782,"stargazers_count":68,"open_issues_count":26,"forks_count":1,"subscribers_count":2,"default_branch":"master","last_synced_at":"2025-06-13T02:50:10.265Z","etag":null,"topics":["generative-testing","javascript","jest","property-based-testing","quickcheck","testing","typescript"],"latest_commit_sha":null,"homepage":"","language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/garbles.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2018-03-20T03:39:11.000Z","updated_at":"2024-05-26T18:40:25.000Z","dependencies_parsed_at":"2023-01-14T17:45:25.713Z","dependency_job_id":null,"html_url":"https://github.com/garbles/kitimat","commit_stats":null,"previous_names":[],"tags_count":8,"template":false,"template_full_name":null,"purl":"pkg:github/garbles/kitimat","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/garbles%2Fkitimat","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/garbles%2Fkitimat/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/garbles%2Fkitimat/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/garbles%2Fkitimat/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/garbles","download_url":"https://codeload.github.com/garbles/kitimat/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/garbles%2Fkitimat/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":260982164,"owners_count":23092549,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["generative-testing","javascript","jest","property-based-testing","quickcheck","testing","typescript"],"created_at":"2024-11-18T03:06:55.265Z","updated_at":"2025-10-14T11:35:27.732Z","avatar_url":"https://github.com/garbles.png","language":"TypeScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Kitimat\n\nKitimat is a library for generative, property-based testing in TypeScript.\n\n* **Easy to use**: Integrates directly into [Jest](https://github.com/facebook/jest) with zero additional configuration.\n\n* **Asynchronous**: Kitimat supports async/await, Promises and `done()` out of the box.\n\n* **Statically typed**: Using TypeScript under the hood, Kitimat generators are kept in sync with your application code.\n\n## A quick example\n\nA unit test typically validates that a system - e.g. a function - will assert something\ngiven a specific set of inputs. This specificity is usually sufficient for small systems; however, as the system increases in complexity it usually means that enumerating all possible test cases becomes an impossible task. Instead, generating test cases should be left up to a computer. A developer derives generalizable properties that the system will hold for any input of a given type. The computer should verify these properties by running them against hundreds or thousands of input cases. This is the essence of generative, property-based testing.\n\n```ts\n// my-sort.test.ts\n\nimport { check, integer, array } from 'kitimat-jest';\nimport { sort } from './my-sort';\n\nit('sorts some numbers', () =\u003e {\n  const sorted = sort([6, 1, 2]);\n  expect(sorted).toEqual([1, 2, 6]);\n});\n\ncheck('length does not change', [array(integer())], arr =\u003e {\n  const sorted = sort(arr);\n  expect(sorted.length).toEqual(arr.length);\n});\n\ncheck('idempotent', [array(integer())], arr =\u003e {\n  const once = sort(arr);\n  const twice = sort(sort(arr));\n  expect(once).toEqual(twice);\n});\n\ncheck('ordered', [array(integer())], arr =\u003e {\n  const sorted = sort(arr);\n\n  for (let i = 0; i \u003c sorted.length; i++) {\n    const prev = sorted[i];\n    const next = sorted[i + 1];\n    expect(prev).toBeLessThanOrEqual(next);\n  }\n});\n```\n\n## Installing\n\nYou can install Kitimat on its own, but it is recommend that you use it with Jest.\n\n```\nyarn install kitimat kitimat-jest jest --dev\n```\n\n## Configuration\n\nKitimat uses [cosmiconfig](https://github.com/davidtheclark/cosmiconfig) so you can\nput your configuration in a `.kitimatrc`, `kitimat.config.js` or the key `\"kitimat\"`\nin your `package.json`. These values can be overridden on a test-by-test basis\n([see API reference](#api-reference)).\n\n### `maxNumTests: number = 100`\n\nThe number of test cases generated for each property. Defaults to 100.\n\n### `seed: number = Date.now()`\n\nThe seed for generating pseudo-random values. If the seed is set to a constant value,\nthen the same pseudo-random values will be generated for every run; otherwise,\nKitimat will use `Date.now()`.\n\nThis value can be overridden by using the environment variable `KITIMAT_SEED`.\n\n### `timeout: number = 5000`\n\nJest only. The number of milliseconds for a single property before Jest triggers a timeout\nerror.\n\n## API Reference\n\n### `check(description: string, fuzzers: Fuzzer[], callback: Function, options: Options): void`\n\nA light wrapper around Jest `it`, but accepts a list of Fuzzers and generates values,\npassing them into the `it` callback.\n\n```ts\nimport { check, boolean, integer, string } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\ncheck('something', [boolean(), integer(), string()], (bool, int, str) =\u003e {\n  expect(typeof bool).toEqual('boolean');\n  expect(typeof int).toEqual('number');\n  expect(typeof str).toEqual('string');\n});\n\n/**\n * Use async/await with same behavior as Jest it.\n */\ncheck('something async', [boolean()], async bool =\u003e {\n  const result = await someFunc(bool);\n  expect(result).toEqual(true);\n});\n\n/**\n * Use done with same behavior as Jest it.\n */\ncheck('something async with done', [boolean()], async (bool, done) =\u003e {\n  someFunc(bool).then(result =\u003e {\n    expect(result).toEqual(true);\n    done();\n  });\n});\n\n/**\n * Same behavior as Jest it. This test will be skipped.\n */\ncheck.skip('skip something', [boolean()], bool =\u003e {\n  // ...\n});\n\n/**\n * Same behavior as Jest it. This is the only test in the suite that will run.\n */\ncheck.only('only run this thing', [string()], str =\u003e {\n  // ...\n});\n```\n\n### `exists(description: string, fuzzers: Fuzzer[], callback: Function, options: Options): void`\n\nA light wrapper around Jest `it`, but accepts a list of Fuzzers and generates values,\npassing them into the `it` callback. Similar to `check` except that it completes on the first\nsuccessful test case. `exists` fails if it does not find a successful test case after the\nconfigured number of test cases.\n\n```ts\nimport { exists, boolean } from 'kitimat-jest';\n\nexists('something async', [boolean()], async bool =\u003e {\n  expect(result).toEqual(true);\n});\n```\n\n### `boolean(): Fuzzer\u003cboolean\u003e`\n\nCreates a boolean Fuzzer.\n\n```ts\nimport { check, Fuzzer, boolean } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cboolean\u003e = boolean();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('boolean');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `constant\u003cA\u003e(val: A): Fuzzer\u003cA\u003e`\n\nWraps a constant value in a Fuzzer.\n\n```ts\nimport { check, Fuzzer, constant } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cstring\u003e = constant('my string');\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(val).toEqual('my string');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `number(opts?: { minSize?: number, maxSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates an number Fuzzer.\n\n```ts\nimport { check, Fuzzer, number } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = number();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('number');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `posNumber(opts?: { maxSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates an number Fuzzer of positive values.\n\n```ts\nimport { check, Fuzzer, posNumber } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = posNumber();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(val).toBeGreaterThanOrEqual(0);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `negNumber(opts?: { minSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates an number Fuzzer of negative values.\n\n```ts\nimport { check, Fuzzer, negNumber } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = negNumber();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(val).toBeLessThanOrEqual(0);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `integer(opts?: { minSize?: number, maxSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates an integer Fuzzer.\n\n```ts\nimport { check, Fuzzer, integer } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = integer();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('number');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `posInteger(opts?: { maxSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates an integer Fuzzer of positive values.\n\n```ts\nimport { check, Fuzzer, posInteger } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = posInteger();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(val).toBeGreaterThanOrEqual(0);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `negInteger(opts?: { minSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates an integer Fuzzer of negative values.\n\n```ts\nimport { check, Fuzzer, negInteger } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = negInteger();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(val).toBeLessThanOrEqual(0);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `float(opts?: { minSize?: number, maxSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates an float Fuzzer.\n\n```ts\nimport { check, float } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = float();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('number');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `posFloat(opts?: { maxSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates a float Fuzzer of positive values.\n\n```ts\nimport { check, Fuzzer, posFloat } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = posFloat();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(val).toBeGreaterThanOrEqual(0);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `negFloat(opts?: { minSize?: number }): Fuzzer\u003cnumber\u003e`\n\nCreates a float Fuzzer of negative values.\n\n```ts\nimport { check, Fuzzer, negFloat } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = negFloat();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(val).toBeLessThanOrEqual(0);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `string(opts?: { maxSize?: number }): Fuzzer\u003cstring\u003e`\n\nCreates a string Fuzzer.\n\n```ts\nimport { check, Fuzzer, string } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cstring\u003e = string();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('string');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `asciiString(opts?: { maxSize?: number }): Fuzzer\u003cstring\u003e`\n\nCreates a ASCII string Fuzzer.\n\n```ts\nimport { check, Fuzzer, asciiString } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cstring\u003e = asciiString();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('string');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `array\u003cA\u003e(a: Fuzzer\u003cA\u003e, opts?: { maxSize?: number }): Fuzzer\u003cA[]\u003e`\n\nTakes a Fuzzer of some type and creates an array Fuzzer of that type.\n\n```ts\nimport { check, Fuzzer, array, integer } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber[]\u003e = array(integer());\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(Array.isArray(true)).toEqual(true);\n  expect(val.every(x =\u003e typeof x === 'number')).toEqual(true);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `object\u003cA\u003e({ [K in keyof A]: Fuzzer\u003cA[K]\u003e }): Fuzzer\u003cA\u003e`\n\nTakes an object where the values are fuzzers and creates an object Fuzzer of that type.\n\n```ts\nimport { check, Fuzzer, object, asciiString, posInteger } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\ntype Person = {\n  name: string;\n  age: number;\n};\n\nconst fuzzer: Fuzzer\u003cPerson\u003e = object\u003cPerson\u003e({\n  name: asciiString(),\n  age: posInteger(),\n});\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val.name).toEqual('string');\n  expect(typeof val.age).toEqual('number');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `zip\u003cA, B\u003e(a: Fuzzer\u003cA\u003e, b: Fuzzer\u003cB\u003e): Fuzzer\u003c[A, B]\u003e`\n\nTakes two fuzzers and creates a tuple Fuzzer.\n\n```ts\nimport { check, Fuzzer, zip, integer } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003c[number, number]\u003e = zip(integer(), integer());\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(Array.isArray(true)).toEqual(true);\n  expect(val.every(x =\u003e typeof x === 'number')).toEqual(true);\n  expect(val).toHaveLength(2);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `zip3\u003cA, B, C\u003e(a: Fuzzer\u003cA\u003e, b: Fuzzer\u003cB\u003e, c: Fuzzer\u003cC\u003e): Fuzzer\u003c[A, B, C]\u003e`\n\nTakes three fuzzers and creates a tuple Fuzzer.\n\n```ts\nimport { check, Fuzzer, zip3, integer } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003c[number, number, number]\u003e = zip3(integer(), integer(), integer());\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(Array.isArray(true)).toEqual(true);\n  expect(val.every(x =\u003e typeof x === 'number')).toEqual(true);\n  expect(val).toHaveLength(3);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `zip4\u003cA, B, C, D\u003e(a: Fuzzer\u003cA\u003e, b: Fuzzer\u003cB\u003e, c: Fuzzer\u003cC\u003e, d: Fuzzer\u003cD\u003e): Fuzzer\u003c[A, B, C, D]\u003e`\n\nTakes four fuzzers and creates a tuple Fuzzer.\n\n```ts\nimport { check, Fuzzer, zip4, integer } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003c[number, number, number, number]\u003e = zip4(integer(), integer(), integer(), integer());\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(Array.isArray(true)).toEqual(true);\n  expect(val.every(x =\u003e typeof x === 'number')).toEqual(true);\n  expect(val).toHaveLength(4);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `zip5\u003cA, B, C, D, E\u003e(a: Fuzzer\u003cA\u003e, b: Fuzzer\u003cB\u003e, c: Fuzzer\u003cC\u003e, d: Fuzzer\u003cD\u003e, e: Fuzzer\u003cE\u003e): Fuzzer\u003c[A, B, C, D, E]\u003e`\n\nTakes five fuzzers and creates a tuple Fuzzer.\n\n```ts\nimport { check, Fuzzer, zip5, integer } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003c[number, number, number, number, number]\u003e = zip5(\n  integer(),\n  integer(),\n  integer(),\n  integer(),\n  integer(),\n);\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(Array.isArray(true)).toEqual(true);\n  expect(val.every(x =\u003e typeof x === 'number')).toEqual(true);\n  expect(val).toHaveLength(5);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `frequency\u003cA\u003e(arr: [number, Fuzzer\u003cA\u003e][]): Fuzzer\u003cA\u003e`\n\nTakes a list of tuples (`[number, Fuzzer]`) and returns a Fuzzer\nof weighted values.\n\n```ts\nimport { check, Fuzzer, frequency, posInteger, negInteger } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\n/**\n * 90% of generated values will be positive integers, 10% negative integers.\n */\nconst fuzzer: Fuzzer\u003cnumber\u003e = frequency([\n  [9, posInteger()],\n  [1, negInteger()];\n])\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('number');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `oneOf\u003cA\u003e(arr: Fuzzer\u003cA\u003e[]): Fuzzer\u003cA\u003e`\n\nSimilar to `frequency` except all Fuzzers are equally weighted.\n\n```ts\nimport { check, Fuzzer, oneOf, posInteger, negInteger } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = oneOf([posInteger(), negInteger()]);\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('number');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `map\u003cA, B\u003e(fn: (a: A) =\u003e B | Promise\u003cB\u003e, a: Fuzzer\u003cA\u003e): Fuzzer\u003cB\u003e`\n\nTakes a mapping function that returns any value and a Fuzzer.\nMaps all generated values to create a Fuzzer of a new type.\n_\\*Also an instance method on Fuzzer._\n\n```ts\nimport { check, Fuzzer, string } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cnumber\u003e = string().map(str =\u003e str.length);\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('number');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `flatMap\u003cA, B\u003e(fn: (a: A) =\u003e Fuzzer\u003cB\u003e | Promise\u003cFuzzer\u003cB\u003e\u003e, a: Fuzzer\u003cA\u003e): Fuzzer\u003cB\u003e`\n\nTakes a mapping function that returns a new Fuzzer and a Fuzzer.\nMaps all generated values to create a new Fuzzer of a new type.\n_\\*Also an instance method on Fuzzer._\n\n```ts\nimport { check, Fuzzer, string, array, constant } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\n/**\n * A fuzzer of arrays where the entries are always the same string,\n * but the length of the array is variable.\n */\nconst fuzzer: Fuzzer\u003cstring[]\u003e = string().flatMap(str =\u003e {\n  return array(constant(str));\n});\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(Array.isArray(true)).toEqual(true);\n  expect(val.every(x =\u003e typeof x === 'string')).toEqual(true);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `filter\u003cA\u003e(fn: (a: A) =\u003e boolean | Promise\u003cboolean\u003e, a: Fuzzer\u003cA\u003e): Fuzzer\u003cA\u003e`\n\nTakes a filtering function and a Fuzzer. If a generated value\ndoes not pass the filtering function, another value will be attempted\nuntil one passes. **Be careful** with this because it can cause\nyour tests to take much, much longer to complete. _\\*Also an instance method on Fuzzer._\n\n```ts\nimport { check, Fuzzer, string } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\n/**\n * Do not allow empty strings.\n */\nconst fuzzer: Fuzzer\u003cstring\u003e = string().filter(str =\u003e str.length \u003e 0);\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('string');\n  expect(val.length).toBeGreaterThan(0);\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `maybe\u003cA\u003e(a: Fuzzer\u003cA\u003e): Fuzzer\u003cA | void\u003e`\n\nTakes a Fuzzer and creates a new Fuzzer where the value is either\nthe type of the original Fuzzer or `undefined`. _\\*Also an instance method on Fuzzer._\n\n```ts\nimport { check, Fuzzer, string } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cstring | void\u003e = string().maybe();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n### `noShrink\u003cA\u003e(a: Fuzzer\u003cA\u003e): Fuzzer\u003cA\u003e`\n\nTakes a Fuzzer and prevents it from shrinking. _\\*Also an instance method on Fuzzer._\n\n```ts\nimport { check, Fuzzer, string } from 'kitimat-jest';\nimport { someFunc } from './some-func';\n\nconst fuzzer: Fuzzer\u003cstring\u003e = string().noShrink();\n\ncheck('something', [fuzzer], val =\u003e {\n  expect(typeof val).toEqual('string');\n\n  expect(someFunc(val)).toEqual(true);\n});\n```\n\n## Prior Art\n\nProperty-based testing is not a new idea. I started writing this\nlibrary because I wanted to understand how the concept worked under the hood.\nThe internal implementation borrows from\n[elm-community/elm-test](https://github.com/elm-community/elm-test),\n[mgold/elm-random-pcg](https://github.com/mgold/elm-random-pcg),\n[elm-community/shrink](https://github.com/elm-community/shrink).\nThe client API is designed after [leebyron/testcheck-js](https://github.com/leebyron/testcheck-js).\n\n## Known Issues\n\n`expect.assertions` does not work because all generated test cases are\nrun in a single `it` block.\n\n## Developing\n\nAfter cloning this project, you can run `make test` to install the\ndependencies and run all of the tests.\n\n## Contributing\n\n**_PLEASE_** take into consideration that this is a\npersonal open source project and nobody is paying me to do this work.\nIt would be amazing if you could **_FIRST_** open an issue to\ndiscuss your change and proposed implementation. It is a terrible\nfeeling to have to reject a change over a disagreement; especially,\nwhen the author has clearly put in a lot of effort.\n\n## License\n\nCopyright 2018 (c) Gabe Scholz under MIT License\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgarbles%2Fkitimat","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fgarbles%2Fkitimat","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgarbles%2Fkitimat/lists"}