wehub-resource-sync
2098 lines
59 KiB
TypeScript
2098 lines
59 KiB
TypeScript
import { afterAll, beforeAll, expect, test } from 'vitest';
|
|
|
|
import { PGlite } from '@electric-sql/pglite';
|
|
import type { PgliteDatabase } from 'drizzle-orm/pglite';
|
|
import { drizzle } from 'drizzle-orm/pglite';
|
|
|
|
import { reset, seed } from '../../../src/index.ts';
|
|
import * as schema from './pgSchema.ts';
|
|
|
|
import { sql } from 'drizzle-orm';
|
|
import cities from '../../../src/datasets/cityNames.ts';
|
|
import countries from '../../../src/datasets/countries.ts';
|
|
import firstNames from '../../../src/datasets/firstNames.ts';
|
|
import lastNames from '../../../src/datasets/lastNames.ts';
|
|
|
|
let client: PGlite;
|
|
let db: PgliteDatabase;
|
|
|
|
beforeAll(async () => {
|
|
client = new PGlite();
|
|
|
|
db = drizzle(client);
|
|
|
|
await db.execute(sql`CREATE SCHEMA "seeder_lib_pg";`);
|
|
|
|
await db.execute(
|
|
sql`
|
|
DO $$ BEGIN
|
|
CREATE TYPE "seeder_lib_pg"."enum" AS ENUM('sad', 'ok', 'happy');
|
|
EXCEPTION
|
|
WHEN duplicate_object THEN null;
|
|
END $$;
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."default_table" (
|
|
"default_string" text
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."default_array_table" (
|
|
"default_string" text[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."boolean_table" (
|
|
"boolean" boolean
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."boolean_array_table" (
|
|
"boolean" boolean[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_table" (
|
|
"city" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_unique_table" (
|
|
"city_unique" varchar(256),
|
|
CONSTRAINT "city_unique_table_city_unique_unique" UNIQUE("city_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."city_array_table" (
|
|
"city" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_table" (
|
|
"company_name" text
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_unique_table" (
|
|
"company_name_unique" varchar(256),
|
|
CONSTRAINT "company_name_unique_table_company_name_unique_unique" UNIQUE("company_name_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."company_name_array_table" (
|
|
"company_name" text[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_table" (
|
|
"country" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_unique_table" (
|
|
"country_unique" varchar(256),
|
|
CONSTRAINT "country_unique_table_country_unique_unique" UNIQUE("country_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."country_array_table" (
|
|
"country" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."date_table" (
|
|
"date" date
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."date_array_table" (
|
|
"date" date[],
|
|
"date_string" date[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."email_table" (
|
|
"email" varchar(256),
|
|
CONSTRAINT "email_table_email_unique" UNIQUE("email")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."email_array_table" (
|
|
"email" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."enum_table" (
|
|
"mood_enum" "seeder_lib_pg"."enum"
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_table" (
|
|
"first_name" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_unique_table" (
|
|
"first_name_unique" varchar(256),
|
|
CONSTRAINT "first_name_unique_table_first_name_unique_unique" UNIQUE("first_name_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."first_name_array_table" (
|
|
"first_name" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name__table" (
|
|
"full_name_" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name_unique_table" (
|
|
"full_name_unique" varchar(256),
|
|
CONSTRAINT "full_name_unique_table_full_name_unique_unique" UNIQUE("full_name_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."full_name_array_table" (
|
|
"full_name" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_primary_key_table" (
|
|
"int_primary_key" integer,
|
|
CONSTRAINT "int_primary_key_table_int_primary_key_unique" UNIQUE("int_primary_key")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_table" (
|
|
"int" integer
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_unique_table" (
|
|
"int_unique" integer,
|
|
CONSTRAINT "int_unique_table_int_unique_unique" UNIQUE("int_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."int_array_table" (
|
|
"int" integer[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_table" (
|
|
"interval" interval
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_unique_table" (
|
|
"interval_unique" interval,
|
|
CONSTRAINT "interval_unique_table_interval_unique_unique" UNIQUE("interval_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."interval_array_table" (
|
|
"interval" interval[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."job_Title_table" (
|
|
"job_title" text
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."job_title_array_table" (
|
|
"job_title" text[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."json_table" (
|
|
"json" json
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."json_array_table" (
|
|
"json" json[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_table" (
|
|
"last_name" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_unique_table" (
|
|
"last_name_unique" varchar(256),
|
|
CONSTRAINT "last_name_unique_table_last_name_unique_unique" UNIQUE("last_name_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."last_name_array_table" (
|
|
"last_name" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."line_table" (
|
|
"line" "line"
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."line_array_table" (
|
|
"line" "line"[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."lorem_ipsum_table" (
|
|
"lorem_ipsum" text
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."lorem_ipsum_array_table" (
|
|
"lorem_ipsum" text[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_table" (
|
|
"number" real
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_unique_table" (
|
|
"number_unique" real,
|
|
CONSTRAINT "number_unique_table_number_unique_unique" UNIQUE("number_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."number_array_table" (
|
|
"number" real[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."phone_number_table" (
|
|
"phoneNumber" varchar(256),
|
|
"phone_number_template" varchar(256),
|
|
"phone_number_prefixes" varchar(256),
|
|
CONSTRAINT "phone_number_table_phoneNumber_unique" UNIQUE("phoneNumber"),
|
|
CONSTRAINT "phone_number_table_phone_number_template_unique" UNIQUE("phone_number_template"),
|
|
CONSTRAINT "phone_number_table_phone_number_prefixes_unique" UNIQUE("phone_number_prefixes")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."phone_number_array_table" (
|
|
"phoneNumber" varchar(256)[],
|
|
"phone_number_template" varchar(256)[],
|
|
"phone_number_prefixes" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."point_table" (
|
|
"point" "point"
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."point_array_table" (
|
|
"point" "point"[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_table" (
|
|
"postcode" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_unique_table" (
|
|
"postcode_unique" varchar(256),
|
|
CONSTRAINT "postcode_unique_table_postcode_unique_unique" UNIQUE("postcode_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."postcode_array_table" (
|
|
"postcode" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."state_table" (
|
|
"state" text
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."state_array_table" (
|
|
"state" text[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_table" (
|
|
"street_address" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_unique_table" (
|
|
"street_address_unique" varchar(256),
|
|
CONSTRAINT "street_address_unique_table_street_address_unique_unique" UNIQUE("street_address_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."street_address_array_table" (
|
|
"street_address" varchar(256)[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_table" (
|
|
"string" text
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_unique_table" (
|
|
"string_unique" varchar(256),
|
|
CONSTRAINT "string_unique_table_string_unique_unique" UNIQUE("string_unique")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."string_array_table" (
|
|
"string" text[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."time_table" (
|
|
"time" time
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."time_array_table" (
|
|
"time" time[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."timestamp_table" (
|
|
"timestamp" timestamp
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."timestamp_array_table" (
|
|
"timestamp" timestamp[]
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_table" (
|
|
"values_from_array_not_null" varchar(256) NOT NULL,
|
|
"values_from_array_weighted_not_null" varchar(256) NOT NULL
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_unique_table" (
|
|
"values_from_array" varchar(256),
|
|
"values_from_array_not_null" varchar(256) NOT NULL,
|
|
"values_from_array_weighted" varchar(256),
|
|
"values_from_array_weighted_not_null" varchar(256) NOT NULL,
|
|
CONSTRAINT "values_from_array_unique_table_values_from_array_unique" UNIQUE("values_from_array"),
|
|
CONSTRAINT "values_from_array_unique_table_values_from_array_not_null_unique" UNIQUE("values_from_array_not_null"),
|
|
CONSTRAINT "values_from_array_unique_table_values_from_array_weighted_unique" UNIQUE("values_from_array_weighted"),
|
|
CONSTRAINT "values_from_array_unique_table_values_from_array_weighted_not_null_unique" UNIQUE("values_from_array_weighted_not_null")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."values_from_array_array_table" (
|
|
"values_from_array" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."weighted_random_table" (
|
|
"weighted_random" varchar(256)
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."weighted_random_with_unique_gens_table" (
|
|
"weighted_random_with_unique_gens" varchar(256),
|
|
CONSTRAINT "weighted_random_with_unique_gens_table_weighted_random_with_unique_gens_unique" UNIQUE("weighted_random_with_unique_gens")
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."uuid_table" (
|
|
"uuid" uuid
|
|
);
|
|
`,
|
|
);
|
|
|
|
await db.execute(
|
|
sql`
|
|
CREATE TABLE IF NOT EXISTS "seeder_lib_pg"."uuid_array_table" (
|
|
"uuid" uuid[]
|
|
);
|
|
`,
|
|
);
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await client.close();
|
|
});
|
|
|
|
const count = 1000;
|
|
|
|
test('enum generator test', async () => {
|
|
await seed(db, { enumTable: schema.enumTable }).refine(() => ({
|
|
enumTable: {
|
|
count,
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.enumTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('default generator test', async () => {
|
|
await seed(db, { defaultTable: schema.defaultTable }).refine((funcs) => ({
|
|
defaultTable: {
|
|
count,
|
|
columns: {
|
|
defaultString: funcs.default({ defaultValue: 'default string' }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.defaultTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('default array generator test', async () => {
|
|
await seed(db, { defaultTable: schema.defaultArrayTable }).refine((funcs) => ({
|
|
defaultTable: {
|
|
count,
|
|
columns: {
|
|
defaultString: funcs.default({ defaultValue: 'default string', arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.defaultArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('valuesFromArray generator test', async () => {
|
|
await seed(db, { valuesFromArrayTable: schema.valuesFromArrayTable }).refine((funcs) => ({
|
|
valuesFromArrayTable: {
|
|
count,
|
|
columns: {
|
|
valuesFromArrayNotNull: funcs.valuesFromArray({ values: lastNames }),
|
|
valuesFromArrayWeightedNotNull: funcs.valuesFromArray({
|
|
values: [
|
|
{ values: lastNames, weight: 0.3 },
|
|
{ values: firstNames, weight: 0.7 },
|
|
],
|
|
}),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.valuesFromArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('valuesFromArray unique generator test', async () => {
|
|
// valuesFromArrayUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { valuesFromArrayUniqueTable: schema.valuesFromArrayUniqueTable }, { seed: 1 }).refine((funcs) => ({
|
|
valuesFromArrayUniqueTable: {
|
|
count: 49998,
|
|
columns: {
|
|
valuesFromArray: funcs.valuesFromArray({ values: lastNames.slice(0, 20), isUnique: true }),
|
|
valuesFromArrayNotNull: funcs.valuesFromArray({ values: lastNames, isUnique: true }),
|
|
valuesFromArrayWeighted: funcs.valuesFromArray({
|
|
values: [
|
|
{ values: lastNames.slice(0, 20000), weight: 0.3 },
|
|
{ values: lastNames.slice(20000), weight: 0.7 },
|
|
],
|
|
isUnique: true,
|
|
}),
|
|
valuesFromArrayWeightedNotNull: funcs.valuesFromArray({
|
|
values: [
|
|
{ values: lastNames.slice(0, 14920), weight: 0.3 },
|
|
{ values: lastNames.slice(14920), weight: 0.7 },
|
|
],
|
|
isUnique: true,
|
|
}),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.valuesFromArrayUniqueTable);
|
|
// console.log(valuesFromArrayUniqueTableData);
|
|
const predicate = data.length !== 0 && data.every((row) =>
|
|
row['valuesFromArrayWeightedNotNull'] !== null
|
|
&& row['valuesFromArrayNotNull'] !== null
|
|
);
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { valuesFromArrayUniqueTable: schema.valuesFromArrayUniqueTable }).refine((funcs) => ({
|
|
valuesFromArrayUniqueTable: {
|
|
count: 49998,
|
|
columns: {
|
|
valuesFromArrayWeightedNotNull: funcs.valuesFromArray({
|
|
values: [
|
|
{ values: lastNames.slice(0, 20000), weight: 0.3 },
|
|
{ values: lastNames.slice(20000), weight: 0.7 },
|
|
],
|
|
isUnique: true,
|
|
}),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow(
|
|
/^weighted values arrays is too small to generate values with specified probability for unique not null column\..+/,
|
|
);
|
|
|
|
await expect(
|
|
seed(db, { valuesFromArrayUniqueTable: schema.valuesFromArrayUniqueTable }).refine((funcs) => ({
|
|
valuesFromArrayUniqueTable: {
|
|
count: 49998,
|
|
columns: {
|
|
valuesFromArrayNotNull: funcs.valuesFromArray({
|
|
values: lastNames.slice(20),
|
|
isUnique: true,
|
|
}),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('There are no enough values to fill unique column.');
|
|
|
|
await expect(
|
|
seed(db, { valuesFromArrayUniqueTable: schema.valuesFromArrayUniqueTable }, { seed: 1 }).refine((funcs) => ({
|
|
valuesFromArrayUniqueTable: {
|
|
count: 49999,
|
|
columns: {
|
|
valuesFromArrayNotNull: funcs.valuesFromArray({
|
|
values: lastNames,
|
|
isUnique: true,
|
|
}),
|
|
valuesFromArrayWeightedNotNull: funcs.valuesFromArray({
|
|
values: [
|
|
{ values: lastNames.slice(0, 14854), weight: 0.3 },
|
|
{ values: lastNames.slice(14854), weight: 0.7 },
|
|
],
|
|
isUnique: true,
|
|
}),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('There are no enough values to fill unique column.');
|
|
});
|
|
|
|
test('valuesFromArray array generator test', async () => {
|
|
await seed(db, { valuesFromArrayTable: schema.valuesFromArrayArrayTable }).refine((funcs) => ({
|
|
valuesFromArrayTable: {
|
|
count,
|
|
columns: {
|
|
valuesFromArray: funcs.valuesFromArray({ values: lastNames, arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.valuesFromArrayArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('intPrimaryKey generator test', async () => {
|
|
await seed(db, { intPrimaryKeyTable: schema.intPrimaryKeyTable }).refine((funcs) => ({
|
|
intPrimaryKeyTable: {
|
|
count,
|
|
columns: {
|
|
intPrimaryKey: funcs.intPrimaryKey(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.intPrimaryKeyTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('number generator test', async () => {
|
|
await seed(db, { numberTable: schema.numberTable }).refine((funcs) => ({
|
|
numberTable: {
|
|
count,
|
|
columns: {
|
|
number: funcs.number(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.numberTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('number unique generator test', async () => {
|
|
// numberUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { numberUniqueTable: schema.numberUniqueTable }).refine((funcs) => ({
|
|
numberUniqueTable: {
|
|
count: 20070,
|
|
columns: {
|
|
numberUnique: funcs.number({ isUnique: true, minValue: -100.23, maxValue: 100.46 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.numberUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) =>
|
|
Object.values(row).every((val) => val !== undefined && val !== null && val >= -100.23 && val <= 100.46)
|
|
);
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { numberUniqueTable: schema.numberUniqueTable }).refine((funcs) => ({
|
|
numberUniqueTable: {
|
|
count: 20071,
|
|
columns: {
|
|
numberUnique: funcs.number({ isUnique: true, minValue: -100.23, maxValue: 100.46 }),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('count exceeds max number of unique integers in given range(min, max), try to make range wider.');
|
|
});
|
|
|
|
test('number array generator test', async () => {
|
|
await seed(db, { numberTable: schema.numberArrayTable }).refine((funcs) => ({
|
|
numberTable: {
|
|
count,
|
|
columns: {
|
|
number: funcs.number({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.numberArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('int generator test', async () => {
|
|
await seed(db, { intTable: schema.intTable }).refine((funcs) => ({
|
|
intTable: {
|
|
count,
|
|
columns: {
|
|
int: funcs.int(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.intTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('int unique generator test', async () => {
|
|
// intUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { intUniqueTable: schema.intUniqueTable }).refine((funcs) => ({
|
|
intUniqueTable: {
|
|
count: 201,
|
|
columns: {
|
|
intUnique: funcs.int({ isUnique: true, minValue: -100, maxValue: 100 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.intUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { intUniqueTable: schema.intUniqueTable }).refine((funcs) => ({
|
|
intUniqueTable: {
|
|
count: 202,
|
|
columns: {
|
|
intUnique: funcs.int({ isUnique: true, minValue: -100, maxValue: 100 }),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('count exceeds max number of unique integers in given range(min, max), try to make range wider.');
|
|
});
|
|
|
|
test('int array generator test', async () => {
|
|
await seed(db, { intTable: schema.intArrayTable }).refine((funcs) => ({
|
|
intTable: {
|
|
count,
|
|
columns: {
|
|
int: funcs.int({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.intArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('boolean generator test', async () => {
|
|
await seed(db, { booleanTable: schema.booleanTable }).refine((funcs) => ({
|
|
booleanTable: {
|
|
count,
|
|
columns: {
|
|
boolean: funcs.boolean(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.booleanTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('boolean array generator test', async () => {
|
|
await seed(db, { booleanTable: schema.booleanArrayTable }).refine((funcs) => ({
|
|
booleanTable: {
|
|
count,
|
|
columns: {
|
|
boolean: funcs.boolean({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.booleanArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('date generator test', async () => {
|
|
await seed(db, { dateTable: schema.dateTable }).refine((funcs) => ({
|
|
dateTable: {
|
|
count,
|
|
columns: {
|
|
date: funcs.date(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.dateTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('date array generator test', async () => {
|
|
await seed(db, { dateTable: schema.dateArrayTable }).refine((funcs) => ({
|
|
dateTable: {
|
|
count,
|
|
columns: {
|
|
date: funcs.date({ arraySize: 3 }),
|
|
dateString: funcs.date({ arraySize: 4 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.dateArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) =>
|
|
Object.values(row).every((val) => val !== undefined && val !== null && [3, 4].includes(val.length))
|
|
);
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('time generator test', async () => {
|
|
await seed(db, { timeTable: schema.timeTable }).refine((funcs) => ({
|
|
timeTable: {
|
|
count,
|
|
columns: {
|
|
time: funcs.time(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.timeTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('time array generator test', async () => {
|
|
await seed(db, { timeTable: schema.timeArrayTable }).refine((funcs) => ({
|
|
timeTable: {
|
|
count,
|
|
columns: {
|
|
time: funcs.time({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.timeArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('timestamp generator test', async () => {
|
|
await seed(db, { timestampTable: schema.timestampTable }).refine((funcs) => ({
|
|
timestampTable: {
|
|
count,
|
|
columns: {
|
|
timestamp: funcs.timestamp(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.timestampTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('timestamp array generator test', async () => {
|
|
await seed(db, { timestampTable: schema.timestampArrayTable }).refine((funcs) => ({
|
|
timestampTable: {
|
|
count,
|
|
columns: {
|
|
timestamp: funcs.timestamp({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.timestampArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('json generator test', async () => {
|
|
await seed(db, { jsonTable: schema.jsonTable }).refine((funcs) => ({
|
|
jsonTable: {
|
|
count,
|
|
columns: {
|
|
json: funcs.json(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.jsonTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('json array generator test', async () => {
|
|
await seed(db, { jsonTable: schema.jsonArrayTable }).refine((funcs) => ({
|
|
jsonTable: {
|
|
count,
|
|
columns: {
|
|
json: funcs.json({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.jsonArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('interval generator test', async () => {
|
|
await seed(db, { intervalTable: schema.intervalTable }).refine((funcs) => ({
|
|
intervalTable: {
|
|
count,
|
|
columns: {
|
|
interval: funcs.interval(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.intervalTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('interval unique generator test', async () => {
|
|
// intervalUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { intervalUniqueTable: schema.intervalUniqueTable }).refine((funcs) => ({
|
|
intervalUniqueTable: {
|
|
count,
|
|
columns: {
|
|
intervalUnique: funcs.interval({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.intervalUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('interval array generator test', async () => {
|
|
await seed(db, { intervalTable: schema.intervalArrayTable }).refine((funcs) => ({
|
|
intervalTable: {
|
|
count,
|
|
columns: {
|
|
interval: funcs.interval({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.intervalArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('string generator test', async () => {
|
|
await seed(db, { stringTable: schema.stringTable }).refine((funcs) => ({
|
|
stringTable: {
|
|
count,
|
|
columns: {
|
|
string: funcs.string(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.stringTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('string unique generator test', async () => {
|
|
await seed(db, { stringUniqueTable: schema.stringUniqueTable }).refine((funcs) => ({
|
|
stringUniqueTable: {
|
|
count,
|
|
columns: {
|
|
stringUnique: funcs.string({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.stringUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('string array generator test', async () => {
|
|
await seed(db, { stringTable: schema.stringArrayTable }).refine((funcs) => ({
|
|
stringTable: {
|
|
count,
|
|
columns: {
|
|
string: funcs.string({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.stringArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('email generator test', async () => {
|
|
await seed(db, { emailTable: schema.emailTable }).refine((funcs) => ({
|
|
emailTable: {
|
|
count,
|
|
columns: {
|
|
email: funcs.email(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.emailTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('email array generator test', async () => {
|
|
await seed(db, { emailTable: schema.emailArrayTable }).refine((funcs) => ({
|
|
emailTable: {
|
|
count,
|
|
columns: {
|
|
email: funcs.email({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.emailArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('firstName generator test', async () => {
|
|
await seed(db, { firstNameTable: schema.firstNameTable }).refine((funcs) => ({
|
|
firstNameTable: {
|
|
count,
|
|
columns: {
|
|
firstName: funcs.firstName(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.firstNameTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('firstName unique generator test', async () => {
|
|
// firstNameUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { firstNameUniqueTable: schema.firstNameUniqueTable }).refine((funcs) => ({
|
|
firstNameUniqueTable: {
|
|
count: 30274,
|
|
columns: {
|
|
firstNameUnique: funcs.firstName({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.firstNameUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { firstNameUniqueTable: schema.firstNameUniqueTable }, { count: 30275 }).refine((funcs) => ({
|
|
firstNameUniqueTable: {
|
|
count: 30275,
|
|
columns: {
|
|
firstNameUnique: funcs.firstName({ isUnique: true }),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('count exceeds max number of unique first names.');
|
|
});
|
|
|
|
test('firstName array generator test', async () => {
|
|
await seed(db, { firstNameTable: schema.firstNameArrayTable }).refine((funcs) => ({
|
|
firstNameTable: {
|
|
count,
|
|
columns: {
|
|
firstName: funcs.firstName({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.firstNameArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('lastName generator test', async () => {
|
|
await seed(db, { lastNameTable: schema.lastNameTable }).refine((funcs) => ({
|
|
lastNameTable: {
|
|
count,
|
|
columns: {
|
|
lastName: funcs.lastName(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.lastNameTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('lastName unique generator test', async () => {
|
|
// lastNameUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { lastNameUniqueTable: schema.lastNameUniqueTable }).refine((funcs) => ({
|
|
lastNameUniqueTable: {
|
|
count: 49998,
|
|
columns: {
|
|
lastNameUnique: funcs.lastName({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.lastNameUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { lastNameUniqueTable: schema.lastNameUniqueTable }).refine((funcs) => ({
|
|
lastNameUniqueTable: {
|
|
count: 49999,
|
|
columns: {
|
|
lastNameUnique: funcs.lastName({ isUnique: true }),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('count exceeds max number of unique last names.');
|
|
});
|
|
|
|
test('lastName array generator test', async () => {
|
|
await seed(db, { lastNameTable: schema.lastNameArrayTable }).refine((funcs) => ({
|
|
lastNameTable: {
|
|
count,
|
|
columns: {
|
|
lastName: funcs.lastName({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.lastNameArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('fullName generator test', async () => {
|
|
await seed(db, { fullNameTable: schema.fullNameTable }).refine((funcs) => ({
|
|
fullNameTable: {
|
|
count,
|
|
columns: {
|
|
fullName: funcs.fullName(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.fullNameTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('fullName unique generator test', async () => {
|
|
// fullNameUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { fullNameUniqueTable: schema.fullNameUniqueTable }).refine((funcs) => ({
|
|
fullNameUniqueTable: {
|
|
count,
|
|
columns: {
|
|
fullNameUnique: funcs.fullName({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.fullNameUniqueTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('fullName array generator test', async () => {
|
|
await seed(db, { fullNameTable: schema.fullNameArrayTable }).refine((funcs) => ({
|
|
fullNameTable: {
|
|
count,
|
|
columns: {
|
|
fullName: funcs.fullName({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.fullNameArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('country generator test', async () => {
|
|
await seed(db, { countryTable: schema.countryTable }).refine((funcs) => ({
|
|
countryTable: {
|
|
count,
|
|
columns: {
|
|
country: funcs.country(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.countryTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('country unique generator test', async () => {
|
|
// countryUniqueTable-----------------------------------------------------------------------------------
|
|
await seed(db, { countryUniqueTable: schema.countryUniqueTable }).refine((funcs) => ({
|
|
countryUniqueTable: {
|
|
count: countries.length,
|
|
columns: {
|
|
countryUnique: funcs.country({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.countryUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { countryUniqueTable: schema.countryUniqueTable }).refine((funcs) => ({
|
|
countryUniqueTable: {
|
|
count: countries.length + 1,
|
|
columns: {
|
|
countryUnique: funcs.country({ isUnique: true }),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('count exceeds max number of unique countries.');
|
|
});
|
|
|
|
test('country array generator test', async () => {
|
|
await seed(db, { countryTable: schema.countryArrayTable }).refine((funcs) => ({
|
|
countryTable: {
|
|
count,
|
|
columns: {
|
|
country: funcs.country({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.countryArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('city generator test', async () => {
|
|
await seed(db, { cityTable: schema.cityTable }).refine((funcs) => ({
|
|
cityTable: {
|
|
count,
|
|
columns: {
|
|
city: funcs.city(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.cityTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('city unique generator test', async () => {
|
|
// cityUniqueTable-----------------------------------------------------------------------------------
|
|
await reset(db, { cityUniqueTable: schema.cityUniqueTable });
|
|
await seed(db, { cityUniqueTable: schema.cityUniqueTable }).refine((funcs) => ({
|
|
cityUniqueTable: {
|
|
count: cities.length,
|
|
columns: {
|
|
cityUnique: funcs.city({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.cityUniqueTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { cityUniqueTable: schema.cityUniqueTable }).refine((funcs) => ({
|
|
cityUniqueTable: {
|
|
count: cities.length + 1,
|
|
columns: {
|
|
cityUnique: funcs.city({ isUnique: true }),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('count exceeds max number of unique cities.');
|
|
});
|
|
|
|
test('city array generator test', async () => {
|
|
await seed(db, { cityTable: schema.cityArrayTable }).refine((funcs) => ({
|
|
cityTable: {
|
|
count,
|
|
columns: {
|
|
city: funcs.city({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.cityArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('streetAddress generator test', async () => {
|
|
await seed(db, { streetAddressTable: schema.streetAddressTable }).refine((funcs) => ({
|
|
streetAddressTable: {
|
|
count,
|
|
columns: {
|
|
streetAddress: funcs.streetAddress(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.streetAddressTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('streetAddress unique generator test', async () => {
|
|
await seed(db, { streetAddressUniqueTable: schema.streetAddressUniqueTable }).refine((funcs) => ({
|
|
streetAddressUniqueTable: {
|
|
count,
|
|
columns: {
|
|
streetAddressUnique: funcs.streetAddress({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.streetAddressUniqueTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('streetAddress array generator test', async () => {
|
|
await seed(db, { streetAddressTable: schema.streetAddressArrayTable }).refine((funcs) => ({
|
|
streetAddressTable: {
|
|
count,
|
|
columns: {
|
|
streetAddress: funcs.streetAddress({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.streetAddressArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('jobTitle generator test', async () => {
|
|
await seed(db, { jobTitleTable: schema.jobTitleTable }).refine((funcs) => ({
|
|
jobTitleTable: {
|
|
count,
|
|
columns: {
|
|
jobTitle: funcs.jobTitle(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.jobTitleTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('jobTitle array generator test', async () => {
|
|
await seed(db, { jobTitleTable: schema.jobTitleArrayTable }).refine((funcs) => ({
|
|
jobTitleTable: {
|
|
count,
|
|
columns: {
|
|
jobTitle: funcs.jobTitle({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.jobTitleArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('postcode generator test', async () => {
|
|
await seed(db, { postcodeTable: schema.postcodeTable }).refine((funcs) => ({
|
|
postcodeTable: {
|
|
count,
|
|
columns: {
|
|
postcode: funcs.postcode(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.postcodeTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('postcode unique generator test', async () => {
|
|
await seed(db, { postcodeUniqueTable: schema.postcodeUniqueTable }).refine((funcs) => ({
|
|
postcodeUniqueTable: {
|
|
count,
|
|
columns: {
|
|
postcodeUnique: funcs.postcode({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.postcodeUniqueTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('postcode array generator test', async () => {
|
|
await seed(db, { postcodeTable: schema.postcodeArrayTable }).refine((funcs) => ({
|
|
postcodeTable: {
|
|
count,
|
|
columns: {
|
|
postcode: funcs.postcode({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.postcodeArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('state generator test', async () => {
|
|
await seed(db, { stateTable: schema.stateTable }).refine((funcs) => ({
|
|
stateTable: {
|
|
count,
|
|
columns: {
|
|
state: funcs.state(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.stateTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('state array generator test', async () => {
|
|
await seed(db, { stateTable: schema.stateArrayTable }).refine((funcs) => ({
|
|
stateTable: {
|
|
count,
|
|
columns: {
|
|
state: funcs.state({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.stateArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('companyName generator test', async () => {
|
|
await seed(db, { companyNameTable: schema.companyNameTable }).refine((funcs) => ({
|
|
companyNameTable: {
|
|
count,
|
|
columns: {
|
|
companyName: funcs.companyName(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.companyNameTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('companyName unique generator test', async () => {
|
|
await seed(db, { companyNameUniqueTable: schema.companyNameUniqueTable }).refine((funcs) => ({
|
|
companyNameUniqueTable: {
|
|
count,
|
|
columns: {
|
|
companyNameUnique: funcs.companyName({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.companyNameUniqueTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('companyName array generator test', async () => {
|
|
await seed(db, { companyNameTable: schema.companyNameArrayTable }).refine((funcs) => ({
|
|
companyNameTable: {
|
|
count,
|
|
columns: {
|
|
companyName: funcs.companyName({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.companyNameArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('loremIpsum generator test', async () => {
|
|
await seed(db, { loremIpsumTable: schema.loremIpsumTable }).refine((funcs) => ({
|
|
loremIpsumTable: {
|
|
count,
|
|
columns: {
|
|
loremIpsum: funcs.loremIpsum(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.loremIpsumTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('loremIpsum array generator test', async () => {
|
|
await seed(db, { loremIpsumTable: schema.loremIpsumArrayTable }).refine((funcs) => ({
|
|
loremIpsumTable: {
|
|
count,
|
|
columns: {
|
|
loremIpsum: funcs.loremIpsum({ arraySize: 3 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.loremIpsumArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 3));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('point generator test', async () => {
|
|
await seed(db, { pointTable: schema.pointTable }).refine((funcs) => ({
|
|
pointTable: {
|
|
count,
|
|
columns: {
|
|
point: funcs.point(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.pointTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('point unique generator test', async () => {
|
|
await reset(db, { pointTable: schema.pointTable });
|
|
await seed(db, { pointTable: schema.pointTable }).refine((funcs) => ({
|
|
pointTable: {
|
|
count,
|
|
columns: {
|
|
point: funcs.point({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.pointTable);
|
|
// every value in each row does not equal undefined.
|
|
let predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
// using Set because PGlite does not support unique point
|
|
const pointStrsSet = new Set<string>(data.map((row) => row.point!.map(String).join(',')));
|
|
predicate = pointStrsSet.size === data.length;
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('point array generator test', async () => {
|
|
await seed(db, { pointTable: schema.pointArrayTable }).refine((funcs) => ({
|
|
pointTable: {
|
|
count,
|
|
columns: {
|
|
point: funcs.point({ arraySize: 2 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.pointArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 2));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('line generator test', async () => {
|
|
await seed(db, { lineTable: schema.lineTable }).refine((funcs) => ({
|
|
lineTable: {
|
|
count,
|
|
columns: {
|
|
line: funcs.line(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.lineTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('line unique generator test', async () => {
|
|
await reset(db, { lineTable: schema.lineTable });
|
|
await seed(db, { lineTable: schema.lineTable }).refine((funcs) => ({
|
|
lineTable: {
|
|
count,
|
|
columns: {
|
|
line: funcs.line({ isUnique: true }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.lineTable);
|
|
// every value in each row does not equal undefined.
|
|
let predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
// using Set because PGlite does not support unique point
|
|
const lineStrsSet = new Set<string>(data.map((row) => row.line!.map(String).join(',')));
|
|
predicate = lineStrsSet.size === data.length;
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('line array generator test', async () => {
|
|
await seed(db, { lineTable: schema.lineArrayTable }).refine((funcs) => ({
|
|
lineTable: {
|
|
count,
|
|
columns: {
|
|
line: funcs.line({ arraySize: 2 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.lineArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null && val.length === 2));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('phoneNumber generator test', async () => {
|
|
await seed(db, { phoneNumberTable: schema.phoneNumberTable }).refine((funcs) => ({
|
|
phoneNumberTable: {
|
|
count,
|
|
columns: {
|
|
phoneNumber: funcs.phoneNumber(),
|
|
phoneNumberPrefixes: funcs.phoneNumber({
|
|
prefixes: ['+380 99', '+380 67', '+1'],
|
|
generatedDigitsNumbers: [7, 7, 10],
|
|
}),
|
|
phoneNumberTemplate: funcs.phoneNumber({ template: '+380 ## ## ### ##' }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.phoneNumberTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('phoneNumber array generator test', async () => {
|
|
await seed(db, { phoneNumberTable: schema.phoneNumberArrayTable }).refine((funcs) => ({
|
|
phoneNumberTable: {
|
|
count,
|
|
columns: {
|
|
phoneNumber: funcs.phoneNumber({ arraySize: 3 }),
|
|
phoneNumberPrefixes: funcs.phoneNumber({
|
|
prefixes: ['+380 99', '+380 67', '+1'],
|
|
generatedDigitsNumbers: [7, 7, 10],
|
|
arraySize: 4,
|
|
}),
|
|
phoneNumberTemplate: funcs.phoneNumber({
|
|
template: '+380 ## ## ### ##',
|
|
arraySize: 5,
|
|
}),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.phoneNumberArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) =>
|
|
Object.values(row).every((val) => val !== undefined && val !== null && [3, 4, 5].includes(val.length))
|
|
);
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('weightedRandom generator test', async () => {
|
|
await seed(db, { weightedRandomTable: schema.weightedRandomTable }).refine((funcs) => ({
|
|
weightedRandomTable: {
|
|
count,
|
|
columns: {
|
|
weightedRandom: funcs.weightedRandom([
|
|
{ value: funcs.default({ defaultValue: 'default value' }), weight: 0.3 },
|
|
{ value: funcs.loremIpsum(), weight: 0.7 },
|
|
]),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.weightedRandomTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('weightedRandom with unique gens generator test', async () => {
|
|
await seed(db, { weightedRandomWithUniqueGensTable: schema.weightedRandomWithUniqueGensTable }).refine((funcs) => ({
|
|
weightedRandomWithUniqueGensTable: {
|
|
count: 10000,
|
|
columns: {
|
|
weightedRandomWithUniqueGens: funcs.weightedRandom([
|
|
{ weight: 0.3, value: funcs.email() },
|
|
{ weight: 0.7, value: funcs.firstName({ isUnique: true }) },
|
|
]),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.weightedRandomWithUniqueGensTable);
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
await expect(
|
|
seed(db, { weightedRandomWithUniqueGensTable: schema.weightedRandomWithUniqueGensTable }).refine((funcs) => ({
|
|
weightedRandomWithUniqueGensTable: {
|
|
count: 40000,
|
|
columns: {
|
|
weightedRandomWithUniqueGens: funcs.weightedRandom([
|
|
{ weight: 0.1, value: funcs.email() },
|
|
{ weight: 0.9, value: funcs.firstName({ isUnique: true }) },
|
|
]),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow('count exceeds max number of unique first names.');
|
|
|
|
await expect(
|
|
seed(db, { weightedRandomWithUniqueGensTable: schema.weightedRandomWithUniqueGensTable }).refine((funcs) => ({
|
|
weightedRandomWithUniqueGensTable: {
|
|
count: 10000,
|
|
columns: {
|
|
weightedRandomWithUniqueGens: funcs.weightedRandom([
|
|
{ weight: 0.2, value: funcs.email() },
|
|
{ weight: 0.9, value: funcs.firstName({ isUnique: true }) },
|
|
]),
|
|
},
|
|
},
|
|
})),
|
|
).rejects.toThrow(
|
|
'The weights for the Weighted Random feature must add up to exactly 1. Please review your weights to ensure they total 1 before proceeding',
|
|
);
|
|
});
|
|
|
|
test('uuid generator test', async () => {
|
|
await reset(db, { uuidTable: schema.uuidTable });
|
|
await seed(db, { uuidTable: schema.uuidTable }).refine((funcs) => ({
|
|
uuidTable: {
|
|
count,
|
|
columns: {
|
|
uuid: funcs.uuid(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.uuidTable);
|
|
// every value in each row does not equal undefined.
|
|
let predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
|
|
const uuidStrsSet = new Set<string>(data.map((row) => row.uuid!));
|
|
predicate = uuidStrsSet.size === data.length;
|
|
expect(predicate).toBe(true);
|
|
});
|
|
|
|
test('uuid array generator test', async () => {
|
|
await reset(db, { uuidArrayTable: schema.uuidArrayTable });
|
|
await seed(db, { uuidArrayTable: schema.uuidArrayTable }).refine((funcs) => ({
|
|
uuidArrayTable: {
|
|
count,
|
|
columns: {
|
|
uuid: funcs.uuid({ arraySize: 4 }),
|
|
},
|
|
},
|
|
}));
|
|
|
|
const data = await db.select().from(schema.uuidArrayTable);
|
|
// every value in each row does not equal undefined.
|
|
const predicate = data.length !== 0
|
|
&& data.every((row) => Object.values(row).every((val) => val !== undefined && val !== null));
|
|
expect(predicate).toBe(true);
|
|
});
|