How to use refArbitrary method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

serialized-type.spec.ts

Source:serialized-type.spec.ts

1import { array, assert, boolean, constant, oneof, property, string, tuple } from 'fast-check';2import {3	getSerializedArrayType,4	getSerializedDictionaryType,5	getSerializedIntersectionType,6	getSerializedObjectType,7	getSerializedOptionPropertyType,8	getSerializedRefType,9	getSerializedUnionType,10	intercalateSerializedTypes,11	serializedType,12} from '../serialized-type';13import { serializedDependency } from '../serialized-dependency';14import { $refArbitrary } from '../../../../../utils/__tests__/ref.spec';15import { getRelativePath } from '../../../../../utils/ref';16import { pipe } from 'fp-ts/lib/pipeable';17import { arbitrary, nonEmptyArray } from '../../../../../utils/fast-check';18import { none, some } from 'fp-ts/lib/Option';19import { getIOName, getTypeName, UNSAFE_PROPERTY_PATTERN } from '../../utils';20import { when } from '../../../../../utils/string';21import { head } from 'fp-ts/lib/NonEmptyArray';22const serializedDependencyArbitrary = tuple(string(), string()).map(([name, path]) => serializedDependency(name, path));23export const serializedTypeArbitrary = tuple(24	string(),25	string(),26	array(serializedDependencyArbitrary),27	pipe(array($refArbitrary)),28).map(([type, io, dependencies, refs]) => serializedType(type, io, dependencies, refs));29const name = oneof(string(), constant(undefined));30describe('SerializedType', () => {31	it('getSerializedArrayType', () => {32		assert(33			property(serializedTypeArbitrary, name, (s, name) => {34				expect(pipe(s, getSerializedArrayType(none, name))).toEqual(35					serializedType(36						`Array<${s.type}>`,37						`array(${s.io}${when(name !== undefined, `, '${name}'`)})`,38						[...s.dependencies, serializedDependency('array', 'io-ts')],39						s.refs,40					),41				);42			}),43		);44	});45	it('getSerializedArrayType with minItems not 0', () => {46		assert(47			property(serializedTypeArbitrary, name, (s, name) => {48				expect(pipe(s, getSerializedArrayType(some(1), name))).toEqual(49					serializedType(50						`NonEmptyArray<${s.type}>`,51						`nonEmptyArray(${s.io}${when(name !== undefined, `, '${name}'`)})`,52						[53							...s.dependencies,54							serializedDependency('nonEmptyArray', 'io-ts-types/lib/nonEmptyArray'),55							serializedDependency('NonEmptyArray', 'fp-ts/lib/NonEmptyArray'),56						],57						s.refs,58					),59				);60			}),61		);62	});63	it('getSerializedPropertyType', () => {64		assert(65			property(string(), serializedTypeArbitrary, boolean(), (name, s, isRequired) => {66				const serialized = getSerializedOptionPropertyType(name, isRequired)(s);67				const safeName = UNSAFE_PROPERTY_PATTERN.test(name) ? `['${name}']` : name;68				const expected = isRequired69					? serializedType(`${safeName}: ${s.type}`, `${safeName}: ${s.io}`, s.dependencies, s.refs)70					: serializedType(71							`${safeName}: Option<${s.type}>`,72							`${safeName}: optionFromNullable(${s.io})`,73							[74								...s.dependencies,75								serializedDependency('Option', 'fp-ts/lib/Option'),76								serializedDependency('optionFromNullable', 'io-ts-types/lib/optionFromNullable'),77							],78							s.refs,79					  );80				expect(serialized).toEqual(expected);81			}),82		);83	});84	describe('getSerializedRefType', () => {85		it('should serialize non recursive', () => {86			const refs = pipe(87				tuple($refArbitrary, $refArbitrary),88				arbitrary.filterMap(([from, to]) =>89					to.$ref !== from.$ref90						? some({91								from,92								to,93						  })94						: none,95				),96			);97			assert(98				property(refs, refs => {99					const { from, to } = refs;100					const serialized = getSerializedRefType(from)(to);101					const type = getTypeName(to.name);102					const io = getIOName(to.name);103					const p = getRelativePath(from, to);104					const expected = serializedType(105						type,106						io,107						[serializedDependency(type, p), serializedDependency(io, p)],108						[109							{110								...to,111								name: getTypeName(to.name),112							},113						],114					);115					expect(serialized).toEqual(expected);116				}),117			);118		});119		it('should skip self-reference dependencies', () => {120			assert(121				property($refArbitrary, ref => {122					const type = getTypeName(ref.name);123					const io = getIOName(ref.name);124					const expected = serializedType(type, io, [], [{ ...ref, name: getTypeName(ref.name) }]);125					const serialized = getSerializedRefType(ref)(ref);126					expect(serialized).toEqual(expected);127				}),128			);129		});130	});131	it('getSerializedObjectType', () => {132		assert(133			property(serializedTypeArbitrary, oneof(string(), constant(undefined)), (s, name) => {134				expect(getSerializedObjectType(name)(s)).toEqual(135					serializedType(136						`{ ${s.type} }`,137						`type({ ${s.io} }${when(name !== undefined, `, '${name}'`)})`,138						[...s.dependencies, serializedDependency('type', 'io-ts')],139						s.refs,140					),141				);142			}),143		);144	});145	it('getSerializedDictionaryType', () => {146		assert(147			property(serializedTypeArbitrary, string(), (s, name) => {148				expect(getSerializedDictionaryType(name)(s)).toEqual(149					serializedType(150						`{ [key: string]: ${s.type} }`,151						`record(string, ${s.io}${when(name !== undefined, `, '${name}'`)})`,152						[153							...s.dependencies,154							serializedDependency('record', 'io-ts'),155							serializedDependency('string', 'io-ts'),156						],157						s.refs,158					),159				);160			}),161		);162	});163	it('getSerializedUnionType', () => {164		assert(165			property(nonEmptyArray(serializedTypeArbitrary), types => {166				const intercalated = intercalateSerializedTypes(serializedType(' | ', ',', [], []), types);167				const expected =168					types.length === 1169						? head(types)170						: serializedType(171								`(${intercalated.type})`,172								`union([${intercalated.io}])`,173								[...intercalated.dependencies, serializedDependency('union', 'io-ts')],174								intercalated.refs,175						  );176				expect(getSerializedUnionType(types)).toEqual(expected);177			}),178		);179	});180	it('getSerializedIntersectionType', () => {181		assert(182			property(nonEmptyArray(serializedTypeArbitrary), types => {183				const intercalated = intercalateSerializedTypes(serializedType(' & ', ',', [], []), types);184				const expected =185					types.length === 1186						? head(types)187						: serializedType(188								`${intercalated.type}`,189								`intersection([${intercalated.io}])`,190								[...intercalated.dependencies, serializedDependency('intersection', 'io-ts')],191								intercalated.refs,192						  );193				expect(getSerializedIntersectionType(types)).toEqual(expected);194			}),195		);196	});...

schema-object.spec.ts

Source:schema-object.spec.ts

1import { serializeSchemaObject } from '../schema-object';2import {3	getSerializedArrayType,4	getSerializedDictionaryType,5	getSerializedObjectType,6	getSerializedOptionPropertyType,7	getSerializedRecursiveType,8	getSerializedRefType,9} from '../../../common/data/serialized-type';10import { right } from 'fp-ts/lib/Either';11import { assert, constant, property, record, string } from 'fast-check';12import { $refArbitrary } from '../../../../../utils/__tests__/ref.spec';13import { pipe } from 'fp-ts/lib/pipeable';14import { either } from 'fp-ts';15import { SchemaObjectCodec } from '../../../../../schema/3.0/schema-object';16import { none } from 'fp-ts/lib/Option';17import { reportIfFailed } from '../../../../../utils/io-ts';18describe('SchemaObject', () => {19	describe('serializeSchemaObject', () => {20		it('should properly handle nested allOf / oneOf', () => {21			assert(22				property($refArbitrary, ref => {23					const schema = SchemaObjectCodec.decode({24						allOf: [25							{26								type: 'object',27								properties: {28									id: { type: 'string' },29								},30								required: ['id'],31							},32							{33								oneOf: [34									{35										type: 'object',36										properties: {37											value: { type: 'string' },38										},39										required: ['value'],40									},41									{42										type: 'object',43										properties: {44											error: { type: 'string' },45										},46										required: ['error'],47									},48								],49							},50						],51					});52					const serialized = pipe(schema, reportIfFailed, either.chain(serializeSchemaObject(ref)));53					pipe(54						serialized,55						either.fold(fail, result => {56							expect(result.type).toEqual('{ id: string } & ({ value: string } | { error: string })');57							expect(result.io).toEqual(58								'intersection([type({ id: string }),union([type({ value: string }),type({ error: string })])])',59							);60						}),61					);62				}),63			);64		});65		describe('array', () => {66			it('should serialize using getSerializedArrayType', () => {67				const schema = record({68					type: constant<'array'>('array'),69					items: record({70						type: constant<'string'>('string'),71						format: constant(none),72						deprecated: constant(none),73						nullable: constant(none),74						minItems: constant(none),75						maxItems: constant(none),76					}),77					format: constant(none),78					deprecated: constant(none),79					nullable: constant(none),80					minItems: constant(none),81					maxItems: constant(none),82				});83				assert(84					property($refArbitrary, schema, string(), (from, schema, name) => {85						const expected = pipe(86							schema.items,87							serializeSchemaObject(from, name),88							either.map(getSerializedArrayType(none, name)),89						);90						const serialized = pipe(schema, serializeSchemaObject(from, name));91						expect(serialized).toEqual(expected);92					}),93				);94			});95			it('should support items.$ref', () => {96				assert(97					property($refArbitrary, $refArbitrary, string(), (from, $refArbitrary, name) => {98						const schema = SchemaObjectCodec.decode({99							type: 'array',100							items: {101								$ref: $refArbitrary.$ref,102							},103						});104						const expected = pipe(105							$refArbitrary,106							getSerializedRefType(from),107							getSerializedArrayType(none, name),108						);109						expect(pipe(schema, reportIfFailed, either.chain(serializeSchemaObject(from, name)))).toEqual(110							right(expected),111						);112					}),113				);114			});115		});116		describe('recursive', () => {117			it('object with array of items of self type', () => {118				assert(119					property($refArbitrary, ref => {120						const schema = SchemaObjectCodec.decode({121							type: 'object',122							required: ['children'],123							properties: {124								children: {125									type: 'array',126									items: {127										$ref: ref.$ref, // references self128									},129								},130							},131						});132						const expected = pipe(133							ref,134							getSerializedRefType(ref),135							getSerializedArrayType(none, undefined),136							getSerializedOptionPropertyType('children', true),137							getSerializedObjectType(undefined),138							getSerializedRecursiveType(ref, true),139						);140						const serialized = pipe(schema, reportIfFailed, either.chain(serializeSchemaObject(ref)));141						expect(serialized).toEqual(right(expected));142					}),143				);144			});145			it('object with array of items of object type with one of properties of self type', () => {146				assert(147					property($refArbitrary, ref => {148						const schema = SchemaObjectCodec.decode({149							type: 'object',150							required: ['children'],151							properties: {152								children: {153									type: 'object',154									properties: {155										self: {156											$ref: ref.$ref, // references self157										},158									},159									required: ['self'],160								},161							},162						});163						const serialized = pipe(schema, reportIfFailed, either.chain(serializeSchemaObject(ref)));164						const expected = pipe(165							ref,166							getSerializedRefType(ref),167							getSerializedOptionPropertyType('self', true),168							getSerializedObjectType(undefined),169							getSerializedOptionPropertyType('children', true),170							getSerializedObjectType(undefined),171							getSerializedRecursiveType(ref, true),172						);173						expect(serialized).toEqual(right(expected));174					}),175				);176			});177			it('object with additionalProperties of self type', () => {178				assert(179					property($refArbitrary, ref => {180						const schema = SchemaObjectCodec.decode({181							type: 'object',182							additionalProperties: {183								$ref: ref.$ref, // references self184							},185						});186						const serialized = pipe(schema, reportIfFailed, either.chain(serializeSchemaObject(ref)));187						const expected = pipe(188							ref,189							getSerializedRefType(ref),190							getSerializedDictionaryType(undefined),191							getSerializedRecursiveType(ref, true),192						);193						expect(serialized).toEqual(right(expected));194					}),195				);196			});197		});198	});...

Using AI Code Generation

1const fc = require('fast-check');2const { refArbitrary } = require('fast-check-monorepo');3fc.assert(4  fc.property(refArbitrary(fc.integer()), refArbitrary(fc.integer()), (a, b) => {5    return a.value + b.value === b.value + a.value;6  })7);

Using AI Code Generation

1const { refArbitrary } = require('fast-check-monorepo');2const refArbitrary = refArbitrary();3fc.assert(4  fc.property(refArbitrary, (ref) => {5  })6);7const { refArbitrary } = require('fast-check-monorepo');8const myArbitrary = fc.record({9  otherField: fc.string(),10});11fc.assert(12  fc.property(myArbitrary, (myArbitrary) => {13  })14);15{16  owner: string;17  repo: string;18  ref: string;19  sha: string;20}

Using AI Code Generation

1const fc = require('fast-check');2const { refArbitrary } = require('@testim/root-cause-jest');3const refArbitrary = refArbitrary();4fc.assert(5  fc.property(refArbitrary, (ref) => {6  })7);

Using AI Code Generation

1const { refArbitrary } = require('fast-check');2const refArb = refArbitrary(arb1, arb2);3fc.assert(fc.property(refArb, (ref) => {4}));5const { refArbitrary } = require('fast-check');6const refArb = refArbitrary(arb1, arb2);7fc.assert(fc.property(refArb, (ref) => {8}));9const { refArbitrary } = require('fast-check');10const refArb = refArbitrary(arb1, arb2);11fc.assert(fc.property(refArb, (ref) => {12}));13const { refArbitrary } = require('fast-check');14const refArb = refArbitrary(arb1, arb2);15fc.assert(fc.property(refArb, (ref) => {16}));17const { refArbitrary } = require('fast-check');18const refArb = refArbitrary(arb1, arb2);19fc.assert(fc.property(refArb, (ref) => {20}));21const { refArbitrary } = require('fast-check');22const refArb = refArbitrary(arb1, arb2);23fc.assert(fc.property(refArb, (ref) => {24}));25const { refArbitrary } = require('fast-check');26const refArb = refArbitrary(arb1, arb2);27fc.assert(fc.property(refArb, (ref) => {28}));29const { refArbitrary } = require

Using AI Code Generation

1const fc = require('fast-check');2const { refArbitrary } = require('fast-check-monorepo');3const { Rectangle } = require('./rectangle.js');4const { Point } = require('./point.js');5const rectangleArbitrary = refArbitrary(Rectangle);6const pointArbitrary = refArbitrary(Point);7fc.assert(8  fc.property(rectangleArbitrary, rectangle => {9    return rectangle instanceof Rectangle;10  })11);12fc.assert(13  fc.property(pointArbitrary, point => {14    return point instanceof Point;15  })16);17class Rectangle {18  constructor(x, y, width, height) {19    this.x = x;20    this.y = y;21    this.width = width;22    this.height = height;23  }24}25module.exports = { Rectangle };26class Point {27  constructor(x, y) {28    this.x = x;29    this.y = y;30  }31}32module.exports = { Point };

Using AI Code Generation

1const { refArbitrary } = require("fast-check");2const myArbitrary = refArbitrary();3myArbitrary.sample();4const myArbitrary = refArbitrary()();5myArbitrary.sample();6I think that the problem is that refArbitrary returns a function that returns an arbitrary, not the arbitrary itself. So it should be something like this: const myArbitrary = refArbitrary()(); myArbitrary.sample();

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.