@snowtop/ent 0.1.0-alpha160-test5 → 0.1.0-alpha160-test6

package/src/testutils/db/value.ts

@@ -0,0 +1,294 @@
+import { v4 } from "uuid";
+import { DBType, Field, Schema, Type } from "../../schema";
+import {
+  DateType,
+  TimeType,
+  TimetzType,
+  TimestampType,
+  TimestamptzType,
+  JSONBType,
+  JSONType,
+  StringType,
+} from "../../schema";
+
+function random(): string {
+  return Math.random().toString(16).substring(2);
+}
+
+export function randomEmail(domain?: string): string {
+  domain = domain || "email.com";
+
+  return `test+${random()}@${domain}`;
+}
+
+function randomPhoneNumber(): string {
+  return `+1${Math.random().toString(10).substring(2, 11)}`;
+}
+
+function coinFlip() {
+  return Math.floor(Math.random() * 10) >= 5;
+}
+
+function specialType(typ: Type, col: string) {
+  let list = m.get(typ.dbType);
+  if (list?.length) {
+    for (const l of list) {
+      let regex: RegExp[] = [];
+      if (Array.isArray(l.regex)) {
+        regex = l.regex;
+      } else {
+        regex = [l.regex];
+      }
+
+      for (const r of regex) {
+        if (r.test(col)) {
+          return l.newValue();
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
+interface Info {
+  schema: Schema;
+}
+
+export function getDefaultValue(
+  f: Field,
+  col: string,
+  infos?: Map<string, Info>,
+): any {
+  if (f.defaultValueOnCreate) {
+    // @ts-ignore
+    return f.defaultValueOnCreate();
+  }
+  // half the time, return null for nullable
+  if (f.nullable && coinFlip()) {
+    return null;
+  }
+
+  const specialVal = specialType(f.type, col);
+  if (specialVal !== undefined) {
+    return specialVal;
+  }
+
+  return getValueForType(f.type, f, infos);
+}
+
+function getValueForType(typ: Type, f: Field, infos?: Map<string, Info>) {
+  switch (typ.dbType) {
+    case DBType.UUID:
+      return v4();
+    case DBType.Boolean:
+      return coinFlip();
+    case DBType.Date:
+      return DateType().format(new Date());
+    case DBType.Time:
+      return TimeType().format(new Date());
+    case DBType.Timetz:
+      return TimetzType().format(new Date());
+    case DBType.Timestamp:
+      return TimestampType().format(new Date());
+    case DBType.Timestamptz:
+      return TimestamptzType().format(new Date());
+    case DBType.String:
+      return random();
+    case DBType.Int:
+      return Math.floor(Math.random() * 100000000);
+    case DBType.Float:
+      return Math.random() * 100000000;
+    case DBType.Enum:
+    case DBType.StringEnum:
+      if (typ.values) {
+        const idx = Math.floor(Math.random() * typ.values.length);
+        return typ.values[idx];
+      }
+      if (typ.enumMap) {
+        const vals = Object.values(typ.enumMap);
+        const idx = Math.floor(Math.random() * vals.length);
+        return vals[idx];
+      }
+      if (f.foreignKey) {
+        const schema = f.foreignKey.schema;
+        const col = f.foreignKey.column;
+        if (!infos) {
+          throw new Error(`infos required for enum with foreignKey`);
+        }
+        const info = infos.get(schema);
+        if (!info) {
+          throw new Error(`couldn't load data for schema ${schema}`);
+        }
+        if (!info.schema.dbRows) {
+          throw new Error(`no dbRows for schema ${schema}`);
+        }
+        const idx = Math.floor(Math.random() * info.schema.dbRows.length);
+        return info.schema.dbRows[idx][col];
+      }
+      throw new Error("TODO: enum without values not currently supported");
+
+    case DBType.IntEnum:
+      const vals = Object.values(typ.intEnumMap!);
+      const idx = Math.floor(Math.random() * vals.length);
+      return vals[idx];
+
+    case DBType.BigInt:
+      return BigInt(Math.floor(Math.random() * 100000000));
+    case DBType.JSONB:
+      // type as list
+      if (typ.listElemType?.dbType === DBType.JSONB) {
+        const values: any[] = [];
+
+        for (let i = 0; i < 10; i++) {
+          values.push(getValueForType(typ.listElemType, f, infos));
+        }
+        if (!f.format) {
+          throw new Error("invalid format");
+        }
+        return f.format(values);
+      }
+      return JSONBType().format({});
+    case DBType.JSON:
+      return JSONType().format({});
+    case DBType.List:
+      // just do 10
+      const values: any[] = [];
+
+      for (let i = 0; i < 10; i++) {
+        values.push(
+          getValueForType(f.type.listElemType!, f.__getElemField(), infos),
+        );
+      }
+      if (!f.format) {
+        throw new Error("invalid format");
+      }
+      return f.format(values);
+    default:
+      throw new Error(`unsupported type ${typ.dbType}`);
+  }
+}
+
+interface commonType {
+  dbType: DBType;
+  newValue: () => any;
+  regex: [RegExp] | RegExp;
+}
+
+const emailType = {
+  dbType: DBType.String,
+  newValue: () => {
+    return StringType().format(randomEmail().toLowerCase());
+  },
+  regex: /^email(_address)|_email$/,
+};
+
+const phoneType = {
+  dbType: DBType.String,
+  newValue: () => {
+    return randomPhoneNumber();
+  },
+  regex: /^phone(_number)?|_phone$|_phone_number$/,
+};
+
+const passwordType = {
+  dbType: DBType.String,
+  newValue: () => {
+    // we don't use password type because when we're generating so many rows, it's too slow...
+    return random();
+  },
+  regex: /^password/,
+};
+
+const firstNames = [
+  "Daenerys",
+  "Jon",
+  "Arya",
+  "Sansa",
+  "Eddard",
+  "Khal",
+  "Robb",
+  "Joffrey",
+  "Ramsay",
+  "Cersei",
+  "Bolton",
+  "Oberyn",
+  "Jojen",
+  "Petyr",
+  "Brienne",
+  "Ygritte",
+  "Missandei",
+  "Shae",
+  "Sandor",
+  "Theon",
+  "Catelyn",
+  "Gilly",
+  "Samwell",
+  "Jaime",
+  "Stannis",
+  "Tyene",
+  "Obara",
+  "Nymeria",
+  "Elia",
+  "Ellaria",
+  "Myrcella",
+  "Hodor",
+  "Osha",
+  "Meera",
+  "Davos",
+  "Gendry",
+];
+
+const lastNames = [
+  "Stark",
+  "Targaryen",
+  "Lannister",
+  "Drogo",
+  "Baratheon",
+  "Reed",
+  "Martell",
+  "Tyrell",
+  "Clegane",
+  "Baelish",
+  "Greyjoy",
+  "Tarly",
+  "Sand",
+  "Snow",
+  "Bolton",
+  "Frey",
+  "Tarth",
+  "Payne",
+  "Seaworth",
+];
+
+const firstNameType = {
+  dbType: DBType.String,
+  newValue: () => {
+    let idx = Math.floor(firstNames.length * Math.random());
+    return firstNames[idx];
+  },
+  regex: /^first_?(name)?/,
+};
+
+const lastNameType = {
+  dbType: DBType.String,
+  newValue: () => {
+    let idx = Math.floor(lastNames.length * Math.random());
+    return lastNames[idx];
+  },
+  regex: /^last_?(name)?/,
+};
+
+let types: commonType[] = [
+  phoneType,
+  emailType,
+  passwordType,
+  firstNameType,
+  lastNameType,
+];
+
+let m: Map<DBType, commonType[]> = new Map();
+for (const type of types) {
+  let list = m.get(type.dbType) || [];
+  list.push(type);
+  m.set(type.dbType, list);
+}

package/src/testutils/db_mock.ts

@@ -0,0 +1,351 @@
+import { v4 as uuidv4 } from "uuid";
+import { Pool, PoolClient } from "pg";
+import { mocked } from "jest-mock";
+import { ID, Data } from "../core/base";
+import { Clause } from "../core/clause";
+
+import { performQuery, queryResult, getDataToReturn } from "./parse_sql";
+import { MockLogs } from "./mock_log";
+
+const eventEmitter = {
+  on: jest.fn(),
+  addListener: jest.fn(),
+  removeListener: jest.fn(),
+  once: jest.fn(),
+  off: jest.fn(),
+  removeAllListeners: jest.fn(),
+  setMaxListeners: jest.fn(),
+  getMaxListeners: jest.fn(),
+  listeners: jest.fn(),
+  rawListeners: jest.fn(),
+  emit: jest.fn(),
+  listenerCount: jest.fn(),
+  prependListener: jest.fn(),
+  prependOnceListener: jest.fn(),
+  eventNames: jest.fn(),
+};
+
+export interface queryOptions {
+  query: string;
+  values?: any[];
+  qs?: internalQueryStructure | null;
+}
+
+export interface mockOptions {
+  tableName: string;
+  //  columns?: string[];
+  clause: Clause;
+  result: (values: any[]) => {};
+}
+
+export enum queryType {
+  SELECT,
+  INSERT,
+  UPDATE,
+  BEGIN,
+  COMMIT,
+  ROLLBACK,
+  DELETE,
+}
+
+export interface queryStructure {
+  tableName?: string;
+  type: queryType;
+  //  columns?: string[];
+  values?: any[];
+}
+
+interface internalQueryStructure extends queryStructure {
+  query: string;
+  columns?: string[];
+  whereClause?: string;
+  suffix?: string;
+  setClause?: string;
+}
+
+/**
+ * @deprecated
+ */
+export class QueryRecorder {
+  private static queries: queryOptions[] = [];
+  private static ids: ID[] = [];
+
+  // we need pkeys when storing...
+  private static data: Map<string, Data[]> = new Map();
+
+  // TODO kill use AST or just throw away
+  static getQueryStructure(query): internalQueryStructure | null {
+    // we parsing sql now??
+    // slowing building sqlshim?
+    // make it so that we return the values entered back when mocking the db
+
+    if (/^INSERT/.test(query)) {
+      let execArray = /INSERT INTO (.+) \((.+)\) VALUES \((.+)\) (.+)?/.exec(
+        query,
+      );
+      if (execArray) {
+        return {
+          tableName: execArray[1],
+          columns: execArray[2].split(", "),
+          type: queryType.INSERT,
+          query: execArray[0],
+          suffix: execArray[4],
+        };
+      }
+      return null;
+    }
+
+    if (/^SELECT/.test(query)) {
+      let execArray = /^SELECT (.+) FROM (.+) WHERE (.+)?/.exec(query);
+      if (execArray) {
+        return {
+          tableName: execArray[2],
+          whereClause: execArray[3],
+          type: queryType.SELECT,
+          query: execArray[0],
+          columns: execArray[1].split(", "),
+        };
+      }
+    }
+
+    if (/^UPDATE/.test(query)) {
+      // regex can't do returning
+      let execArray = /^UPDATE (.+) SET (.+) WHERE (.+) /.exec(query);
+      if (execArray) {
+        return {
+          tableName: execArray[1],
+          // not completely accurate
+          whereClause: execArray[3],
+          type: queryType.UPDATE,
+          query: execArray[0],
+          setClause: execArray[2],
+          //          colummns: execArray[1].split(", "),
+        };
+      }
+    }
+
+    if (/^DELETE/.test(query)) {
+      // regex can't do returning
+      let execArray = /^DELETE FROM (.+) WHERE (.+) /.exec(query);
+      if (execArray) {
+        return {
+          tableName: execArray[1],
+          whereClause: execArray[2],
+          type: queryType.DELETE,
+          query: execArray[0],
+        };
+      }
+    }
+
+    if (/^BEGIN/.test(query)) {
+      return {
+        type: queryType.BEGIN,
+        query: query,
+      };
+    }
+
+    if (/^COMMIT/.test(query)) {
+      return {
+        type: queryType.COMMIT,
+        query: query,
+      };
+    }
+
+    if (/^ROLLBACK/.test(query)) {
+      return {
+        type: queryType.ROLLBACK,
+        query: query,
+      };
+    }
+    return null;
+  }
+
+  private static recordQuery(
+    query: string,
+    values: any[],
+  ): queryResult | undefined {
+    let qs = QueryRecorder.getQueryStructure(query);
+    QueryRecorder.queries.push({
+      query: query,
+      values: values,
+      qs: qs,
+    });
+
+    return performQuery(query, values, QueryRecorder.data);
+  }
+
+  static newID(): ID {
+    let id = uuidv4();
+    QueryRecorder.ids.push(id);
+    return id;
+  }
+
+  static getCurrentIDs(): ID[] {
+    return QueryRecorder.ids;
+  }
+
+  static getLastID(): ID {
+    const l = QueryRecorder.ids.length;
+    if (!l) {
+      throw new Error(`no ID`);
+    }
+    return QueryRecorder.ids[l - 1];
+  }
+
+  static getData() {
+    return QueryRecorder.data;
+  }
+
+  static filterData(tableName: string, filterfn: (row: Data) => boolean) {
+    const rows = QueryRecorder.data.get(tableName) || [];
+    let result: Data[] = [];
+    for (const row of rows) {
+      // transform the data into whatever the return value should be before filtering
+      const row2 = getDataToReturn(row, undefined, true);
+      if (filterfn(row2)) {
+        result.push(row2);
+      }
+    }
+    return result;
+  }
+
+  static clear() {
+    QueryRecorder.queries = [];
+    QueryRecorder.ids = [];
+    QueryRecorder.data = new Map();
+  }
+
+  static clearQueries() {
+    // clears queries but keeps data
+    // this is useful for situations like write this data before each test
+    // but each test shouldn't have to account for this
+    QueryRecorder.queries = [];
+  }
+
+  static getCurrentQueries(): queryOptions[] {
+    return QueryRecorder.queries;
+  }
+
+  /**
+   * @deprecated will keep this since it's just using ml.logs
+   * which we still want around (I think) but we should eventually
+   * probably stop using this
+   */
+  static validateQueryStructuresFromLogs(
+    ml: MockLogs,
+    expected: queryStructure[],
+    opts?: {
+      skipSelect?: boolean;
+      flagBeginCommit?: boolean;
+    },
+  ) {
+    const queries = ml.logs.map((log) => {
+      const qs = QueryRecorder.getQueryStructure(log.query);
+      if (!qs) {
+        throw new Error(`invalid query ${log.querya}`);
+      }
+      return {
+        query: log.query,
+        qs,
+      };
+    });
+
+    QueryRecorder.validateQueryStructuresImpl(expected, queries, opts);
+  }
+
+  private static validateQueryStructuresImpl(
+    expected: queryStructure[],
+    queries: queryOptions[],
+    opts?: {
+      skipSelect?: boolean;
+      flagBeginCommit?: boolean;
+    },
+  ) {
+    if (opts?.skipSelect) {
+      queries = queries.filter((query) => query.qs?.type !== queryType.SELECT);
+    }
+    if (!opts?.flagBeginCommit) {
+      queries = queries.filter(
+        (query) =>
+          query.qs?.type !== queryType.BEGIN &&
+          query.qs?.type !== queryType.COMMIT,
+      );
+    }
+    //    console.log(queries, expected);
+    expect(queries.length).toBe(expected.length);
+
+    for (let i = 0; i < expected.length; i++) {
+      let expectedStructure = expected[i];
+      let query = queries[i];
+      switch (expectedStructure.type) {
+        case queryType.BEGIN:
+          expect(query.query).toBe("BEGIN");
+          expect(query.values).toBe(undefined);
+          break;
+        case queryType.ROLLBACK:
+          expect(query.query).toBe("ROLLBACK");
+          expect(query.values).toBe(undefined);
+          break;
+        case queryType.COMMIT:
+          expect(query.query).toBe("COMMIT");
+          expect(query.values).toBe(undefined);
+          break;
+        case queryType.SELECT:
+          if (!opts?.skipSelect) {
+            console.error(
+              "validating select query structure not supported yet",
+            );
+          }
+          // TODO INSERT and UPDATE tests here...
+          // should be easy...
+          break;
+        case queryType.INSERT:
+          expect(query.query.startsWith("INSERT")).toBe(true);
+          expect(query.qs?.tableName).toBe(expectedStructure.tableName);
+          break;
+        case queryType.UPDATE:
+          expect(query.query.startsWith("UPDATE")).toBe(true);
+          expect(query.qs?.tableName).toBe(expectedStructure.tableName);
+          break;
+      }
+    }
+  }
+
+  static mockPool(pool: typeof Pool) {
+    const mockedPool = mocked(pool);
+    // @ts-ignore
+    // TODO what changed in mockImplementation?
+    mockedPool.mockImplementation((): Pool => {
+      return {
+        totalCount: 1,
+        idleCount: 1,
+        waitingCount: 1,
+        connect: async (): Promise<PoolClient> => {
+          return {
+            connect: jest.fn(),
+            release: jest.fn(),
+            query: jest
+              .fn()
+              .mockImplementation((query: string, values: any[]) => {
+                return QueryRecorder.recordQuery(query, values);
+              }),
+            copyFrom: jest.fn(),
+            copyTo: jest.fn(),
+            pauseDrain: jest.fn(),
+            resumeDrain: jest.fn(),
+            escapeIdentifier: jest.fn(),
+            escapeLiteral: jest.fn(),
+
+            // EventEmitter
+            ...eventEmitter,
+          };
+        },
+        end: jest.fn(),
+        query: jest.fn().mockImplementation(QueryRecorder.recordQuery),
+
+        // EventEmitter
+        ...eventEmitter,
+      };
+    });
+  }
+}

package/src/testutils/db_time_zone.ts

@@ -0,0 +1,40 @@
+import { DateTime } from "luxon";
+import { leftPad } from "../schema";
+import DB from "../core/db";
+
+let dbCurrentZone: string | null | undefined = undefined;
+export class DBTimeZone {
+  private static async getVal(): Promise<string | null> {
+    if (dbCurrentZone !== undefined) {
+      return dbCurrentZone;
+    }
+
+    const r = await DB.getInstance()
+      .getPool()
+      .query("SELECT current_setting('TIMEZONE');");
+
+    if (r.rows.length) {
+      dbCurrentZone = r.rows[0].current_setting as string;
+    } else {
+      dbCurrentZone = null;
+    }
+    return dbCurrentZone;
+  }
+
+  static async getDateOffset(d: Date) {
+    let zone = await DBTimeZone.getVal();
+
+    let dt = DateTime.fromJSDate(d);
+    if (zone) {
+      dt = dt.setZone(zone);
+    }
+
+    // use
+    const val = leftPad(dt.get("offset") / 60);
+
+    if (val == "00") {
+      return "+00";
+    }
+    return val;
+  }
+}