@snowtop/ent 0.1.0-alpha160-test7 → 0.1.0-alpha161-test1

package/src/testutils/fake_data/fake_user.ts

@@ -1,232 +0,0 @@
-import {
-  ID,
-  Ent,
-  Viewer,
-  Data,
-  LoadEntOptions,
-  PrivacyPolicy,
-  Skip,
-  Allow,
-  Context,
-} from "../../core/base";
-import { loadEnt, loadEntX } from "../../core/ent";
-import {
-  AllowIfViewerRule,
-  AlwaysDenyRule,
-  AllowIfViewerInboundEdgeExistsRule,
-  AllowIfConditionAppliesRule,
-} from "../../core/privacy";
-import { getBuilderSchemaFromFields, SimpleAction } from "../builder";
-import { StringType } from "../../schema";
-import { EdgeType } from "./internal";
-import { NodeType } from "./const";
-import { IDViewer, IDViewerOptions } from "../../core/viewer";
-import { table, uuid, text, timestamptz } from "../db/temp_db";
-import { ObjectLoaderFactory } from "../../core/loaders";
-import { convertDate } from "../../core/convert";
-import { WriteOperation } from "../../action";
-
-interface TokenOptions extends IDViewerOptions {
-  tokens?: {};
-}
-
-export class ViewerWithAccessToken extends IDViewer {
-  constructor(viewerID: ID, private opts?: Partial<TokenOptions>) {
-    super(viewerID, opts);
-  }
-
-  hasToken(key: string): boolean {
-    const tokens = this.opts?.tokens || {};
-    return tokens[key] !== undefined;
-  }
-}
-
-export class FakeUser implements Ent {
-  readonly id: ID;
-  readonly data: Data;
-  readonly nodeType = NodeType.FakeUser;
-  readonly createdAt: Date;
-  readonly updatedAt: Date;
-  readonly firstName: string;
-  readonly lastName: string;
-  readonly emailAddress: string;
-  readonly phoneNumber: string | null;
-  protected readonly password: string | null;
-
-  getPrivacyPolicy(): PrivacyPolicy<this> {
-    return {
-      rules: [
-        AllowIfViewerRule,
-        {
-          async apply(v, ent) {
-            if (!(v instanceof ViewerWithAccessToken)) {
-              return Skip();
-            }
-
-            return v.hasToken("always_allow_user") ? Allow() : Skip();
-          },
-        },
-
-        // can view user if friends
-        new AllowIfViewerInboundEdgeExistsRule(EdgeType.UserToFriends),
-        // can view user if following
-        new AllowIfViewerInboundEdgeExistsRule(EdgeType.UserToFollowing),
-        new AllowIfConditionAppliesRule((viewer: Viewer, ent: Ent) => {
-          if (!(viewer instanceof ViewerWithAccessToken)) {
-            return false;
-          }
-
-          return viewer.hasToken("allow_outbound_friend_request");
-        }, new AllowIfViewerInboundEdgeExistsRule(EdgeType.UserToFriendRequests)),
-        new AllowIfConditionAppliesRule((viewer: Viewer, ent: Ent) => {
-          if (!(viewer instanceof ViewerWithAccessToken)) {
-            return false;
-          }
-
-          return viewer.hasToken("allow_incoming_friend_request");
-        }, new AllowIfViewerInboundEdgeExistsRule(EdgeType.UserToIncomingFriendRequests)),
-        AlwaysDenyRule,
-      ],
-    };
-  }
-
-  constructor(public viewer: Viewer, data: Data) {
-    this.data = data;
-    this.id = data.id;
-    this.createdAt = convertDate(data.created_at);
-    this.updatedAt = convertDate(data.updated_at);
-    this.firstName = data.first_name;
-    this.lastName = data.last_name;
-    this.emailAddress = data.email_address;
-    this.phoneNumber = data.phone_number;
-    this.password = data.password;
-  }
-
-  __setRawDBData(data: Data) {}
-
-  static getFields(): string[] {
-    return [
-      "id",
-      "created_at",
-      "updated_at",
-      "first_name",
-      "last_name",
-      "email_address",
-      "phone_number",
-      "password",
-    ];
-  }
-
-  static getTestTable() {
-    return table(
-      "fake_users",
-      uuid("id", { primaryKey: true }),
-      timestamptz("created_at"),
-      timestamptz("updated_at"),
-      text("first_name"),
-      text("last_name"),
-      text("email_address"),
-      text("phone_number"),
-      text("password"),
-    );
-  }
-
-  static loaderOptions(): LoadEntOptions<FakeUser> {
-    return {
-      tableName: "fake_users",
-      fields: FakeUser.getFields(),
-      ent: this,
-      loaderFactory: userLoader,
-    };
-  }
-  static async load(v: Viewer, id: ID): Promise<FakeUser | null> {
-    return loadEnt(v, id, FakeUser.loaderOptions());
-  }
-
-  static async loadX(v: Viewer, id: ID): Promise<FakeUser> {
-    return loadEntX(v, id, FakeUser.loaderOptions());
-  }
-}
-
-export const FakeUserSchema = getBuilderSchemaFromFields(
-  {
-    firstName: StringType(),
-    lastName: StringType(),
-    emailAddress: StringType(),
-    phoneNumber: StringType(),
-    password: StringType({
-      nullable: true,
-    }),
-  },
-  FakeUser,
-);
-
-export interface UserCreateInput {
-  firstName: string;
-  lastName: string;
-  emailAddress: string;
-  phoneNumber: string | null;
-  password: string | null;
-  createdAt?: Date;
-  updatedAt?: Date;
-}
-
-export type UserEditInput = Partial<UserCreateInput>;
-
-export function getUserBuilder(viewer: Viewer, input: UserCreateInput) {
-  const action = getUserAction(viewer, input);
-  return action.builder;
-}
-
-export function getUserAction(viewer: Viewer, input: UserCreateInput) {
-  const m = new Map();
-  for (const key in input) {
-    m.set(key, input[key]);
-  }
-  const action = new SimpleAction(
-    viewer,
-    FakeUserSchema,
-    m,
-    WriteOperation.Insert,
-    null,
-  );
-  action.viewerForEntLoad = (data: Data, context?: Context) => {
-    // load the created ent using a VC of the newly created user.
-    return new IDViewer(data.id, {
-      context,
-    });
-  };
-  return action;
-}
-
-export async function createUser(viewer: Viewer, input: UserCreateInput) {
-  const action = getUserAction(viewer, input);
-  return action.saveX();
-}
-
-export const userLoader = new ObjectLoaderFactory({
-  tableName: "fake_users",
-  fields: FakeUser.getFields(),
-  key: "id",
-});
-
-export const userEmailLoader = new ObjectLoaderFactory({
-  tableName: "fake_users",
-  fields: FakeUser.getFields(),
-  key: "email_address",
-});
-
-export const userPhoneNumberLoader = new ObjectLoaderFactory({
-  tableName: "fake_users",
-  fields: FakeUser.getFields(),
-  key: "phone_number",
-});
-
-userLoader.addToPrime(userEmailLoader);
-userLoader.addToPrime(userPhoneNumberLoader);
-
-userEmailLoader.addToPrime(userLoader);
-userEmailLoader.addToPrime(userPhoneNumberLoader);
-
-userPhoneNumberLoader.addToPrime(userLoader);
-userPhoneNumberLoader.addToPrime(userEmailLoader);

package/src/testutils/fake_data/index.ts

@@ -1 +0,0 @@
-export * from "./internal";

package/src/testutils/fake_data/internal.ts

@@ -1,8 +0,0 @@
-export * from "./const";
-export * from "./fake_contact";
-export * from "./fake_user";
-export * from "./fake_event";
-export * from "./fake_tag";
-export * from "./events_query";
-export * from "./user_query";
-export * from "./tag_query";

package/src/testutils/fake_data/tag_query.ts

@@ -1,56 +0,0 @@
-import { ID, Viewer } from "../../core/base";
-import { CustomEdgeQueryBase } from "../../core/query/custom_query";
-import { FakeUser, FakeTag } from "./internal";
-
-export class UserToTagsFkeyQuery extends CustomEdgeQueryBase<
-  FakeUser,
-  FakeTag
-> {
-  constructor(viewer: Viewer, src: ID | FakeUser) {
-    super(viewer, {
-      src,
-      loadEntOptions: FakeTag.loaderOptions(),
-      groupCol: "owner_id",
-      name: "user_to_tags",
-      sortColumn: "canonical_name",
-      primarySortColIsUnique: true,
-    });
-  }
-
-  static query(viewer: Viewer, src: FakeUser | ID): UserToTagsFkeyQuery {
-    return new UserToTagsFkeyQuery(viewer, src);
-  }
-
-  sourceEnt(id: ID) {
-    return FakeUser.load(this.viewer, id);
-  }
-}
-
-export class UserToTagsFkeyQueryAsc extends CustomEdgeQueryBase<
-  FakeUser,
-  FakeTag
-> {
-  constructor(viewer: Viewer, src: ID | FakeUser) {
-    super(viewer, {
-      src,
-      loadEntOptions: FakeTag.loaderOptions(),
-      groupCol: "owner_id",
-      name: "user_to_tags_asc",
-      orderby: [
-        {
-          column: "canonical_name",
-          direction: "ASC",
-        },
-      ],
-      primarySortColIsUnique: true,
-    });
-  }
-
-  static query(viewer: Viewer, src: FakeUser | ID): UserToTagsFkeyQueryAsc {
-    return new UserToTagsFkeyQueryAsc(viewer, src);
-  }
-
-  sourceEnt(id: ID) {
-    return FakeUser.load(this.viewer, id);
-  }
-}

package/src/testutils/fake_data/test_helpers.ts

@@ -1,388 +0,0 @@
-import { advanceBy, advanceTo } from "jest-date-mock";
-import { IDViewer, LoggedOutViewer } from "../../core/viewer";
-import { Context, Data, Ent } from "../../core/base";
-import { AssocEdge, loadEdgeData } from "../../core/ent";
-import { snakeCase } from "snake-case";
-import { createRowForTest } from "../write";
-import {
-  TempDB,
-  assoc_edge_config_table,
-  assoc_edge_table,
-} from "../db/temp_db";
-
-import {
-  createUser,
-  FakeUser,
-  UserCreateInput,
-  ContactCreateInput,
-  FakeContact,
-  getContactBuilder,
-  EdgeType,
-  SymmetricEdges,
-  InverseEdges,
-  FakeUserSchema,
-} from ".";
-import { EventCreateInput, FakeEvent, getEventBuilder } from "./fake_event";
-import { NodeType } from "./const";
-import { MockDate } from "./../mock_date";
-import { BuilderSchema, SimpleAction } from "../builder";
-import { WriteOperation } from "../../action";
-import { FakeTag } from "./fake_tag";
-import { Dialect } from "../../core/db";
-
-export function getContactInput(
-  user: FakeUser,
-  input?: Partial<ContactCreateInput>,
-): ContactCreateInput {
-  return {
-    firstName: "Jon",
-    lastName: "Snow",
-    emailAddress: "foo@bar.com",
-    userID: user.id,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    ...input,
-  };
-}
-
-export function getUserInput(
-  input?: Partial<UserCreateInput>,
-): UserCreateInput {
-  return {
-    firstName: "Jon",
-    lastName: "Snow",
-    emailAddress: "foo@bar.com",
-    phoneNumber: "415-212-1212",
-    password: "pa$$w0rd",
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    ...input,
-  };
-}
-
-export function getEventInput(
-  user: FakeUser,
-  input?: Partial<EventCreateInput>,
-): EventCreateInput {
-  return {
-    startTime: new Date(),
-    location: "fun location",
-    title: "title",
-    description: "fun event",
-    userID: user.id,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    ...input,
-  };
-}
-
-export async function createTestUser(
-  input?: Partial<UserCreateInput>,
-  ctx?: Context,
-): Promise<FakeUser> {
-  const user = await createUser(new LoggedOutViewer(ctx), {
-    firstName: "Jon",
-    lastName: "Snow",
-    password: "12345678",
-    phoneNumber: "4152221231",
-    emailAddress: "foo@bar.com",
-    ...input,
-  });
-  if (!user) {
-    throw new Error("error creating user");
-  }
-  return user;
-}
-
-export const inputs: Partial<ContactCreateInput>[] = [
-  {
-    firstName: "Arya",
-    lastName: "Stark",
-  },
-  {
-    firstName: "Robb",
-    lastName: "Stark",
-  },
-  {
-    firstName: "Sansa",
-    lastName: "Stark",
-  },
-  {
-    firstName: "Rickon",
-    lastName: "Stark",
-  },
-  {
-    firstName: "Bran",
-    lastName: "Stark",
-  },
-];
-
-interface createContactOptions {
-  input?: Partial<UserCreateInput>;
-  slice?: number;
-  user?: FakeUser;
-  start?: number;
-  ctx?: Context;
-}
-export async function createAllContacts(
-  opts?: createContactOptions,
-): Promise<[FakeUser, FakeContact[]]> {
-  let { input, slice, user } = opts || {};
-  if (!user) {
-    user = await createTestUser(input, opts?.ctx);
-  }
-  const userr = user!;
-
-  if (opts?.start) {
-    advanceTo(opts.start);
-  }
-  let userInputs = inputs.slice(0, slice || inputs.length);
-  const contacts = await Promise.all(
-    userInputs.map(async (input) => {
-      // just to make times deterministic so that tests can consistently work
-      advanceBy(100);
-      const builder = getContactBuilder(
-        userr.viewer,
-        getContactInput(userr, input),
-      );
-      // add edge from user to contact
-      builder.orchestrator.addInboundEdge(
-        userr.id,
-        EdgeType.UserToContacts,
-        NodeType.FakeUser,
-        {
-          time: new Date(), // set time to advanceBy time
-        },
-      );
-      await builder.saveX();
-      return await builder.editedEntX();
-    }),
-  );
-  expect(contacts.length).toBe(userInputs.length);
-  return [userr, contacts];
-}
-
-export async function createUserPlusFriendRequests(
-  input?: Partial<UserCreateInput>,
-  slice?: number,
-): Promise<[FakeUser, FakeUser[]]> {
-  const user = await createTestUser(input);
-
-  let userInputs = inputs.slice(0, slice || inputs.length);
-
-  const friendRequests = await Promise.all(
-    userInputs.map(async (input) => {
-      return createTestUser(input);
-    }),
-  );
-  expect(friendRequests.length).toBe(userInputs.length);
-
-  await addEdge(
-    user,
-    FakeUserSchema,
-    EdgeType.UserToFriendRequests,
-    true,
-    ...friendRequests,
-  );
-
-  return [user, friendRequests];
-}
-
-export async function addEdge<T extends Ent>(
-  source: T,
-  schema: BuilderSchema<T>,
-  edgeType: string,
-  inbound: boolean, // inbound or outbound
-  ...dest: Ent[]
-) {
-  const action = new SimpleAction(
-    source.viewer,
-    schema,
-    new Map(),
-    WriteOperation.Edit,
-    source,
-  );
-
-  dest.forEach(async (friendRequest) => {
-    // just to make times deterministic so that tests can consistently work
-    advanceBy(100);
-    // add edge
-    if (inbound) {
-      action.builder.orchestrator.addInboundEdge(
-        friendRequest.id,
-        edgeType,
-        dest[0].nodeType,
-        {
-          time: new Date(), // set time to advanceBy time
-        },
-      );
-    } else {
-      action.builder.orchestrator.addOutboundEdge(
-        friendRequest.id,
-        edgeType,
-        dest[0].nodeType,
-        {
-          time: new Date(), // set time to advanceBy time
-        },
-      );
-    }
-  });
-  await action.saveX();
-}
-
-export function verifyUserToContactEdges(
-  user: FakeUser,
-  edges: AssocEdge[],
-  contacts: FakeContact[],
-) {
-  expect(edges.length).toBe(contacts.length);
-
-  for (let i = 0; i < contacts.length; i++) {
-    const edge = edges[i];
-    const expectedEdge = {
-      id1: user.id,
-      id1Type: NodeType.FakeUser,
-      id2: contacts[i].id,
-      id2Type: NodeType.FakeContact,
-      data: null,
-      edgeType: EdgeType.UserToContacts,
-    };
-    expect(edge, `${i}th index`).toMatchObject(expectedEdge);
-    expect(edge.getCursor()).not.toBe("");
-  }
-}
-
-export function verifyUserToContactRawData(
-  user: FakeUser,
-  edges: Data[],
-  contacts: FakeContact[],
-) {
-  expect(edges.length).toBe(contacts.length);
-
-  for (let i = 0; i < contacts.length; i++) {
-    const edge = edges[i];
-    const expectedEdge = contacts[i].data;
-    // getting data from db so just checking that data's as expected
-
-    expect(edge, `${i}th index`).toMatchObject(expectedEdge);
-  }
-}
-
-export function verifyUserToContacts(
-  user: FakeUser,
-  ents: FakeContact[],
-  contacts: FakeContact[],
-) {
-  expect(ents.length).toBe(contacts.length);
-  const expectedContacts = contacts.map((contact) => contact.id);
-
-  expect(ents.map((contact) => contact.id)).toStrictEqual(expectedContacts);
-}
-
-export async function createEdges() {
-  // create all edges// for now all one-way
-  const edgeNames = Object.keys(EdgeType);
-  const edges = Object.values(EdgeType);
-
-  for (let i = 0; i < edges.length; i++) {
-    const edge = edges[i];
-    await createRowForTest({
-      tableName: "assoc_edge_config",
-      fields: {
-        edge_table: snakeCase(`${edge}_table`),
-        symmetric_edge: SymmetricEdges.has(edge),
-        inverse_edge_type: InverseEdges.get(edge) || null,
-        edge_type: edge,
-        edge_name: edgeNames[i],
-        created_at: new Date(),
-        updated_at: new Date(),
-      },
-    });
-    const edgeData = await loadEdgeData(edge);
-    expect(edgeData).toBeDefined();
-  }
-}
-
-export function edgeTableNames() {
-  const edges = Object.values(EdgeType);
-  return edges.map((edge) => snakeCase(`${edge}_table`));
-}
-
-export async function createTestEvent(
-  user: FakeUser,
-  input?: Partial<EventCreateInput>,
-) {
-  const vc = new IDViewer(user.id);
-  const builder = getEventBuilder(vc, {
-    startTime: new Date(),
-    location: "fun house",
-    description: "fun fun fun",
-    title: "fun time",
-    userID: user.id,
-    ...input,
-  });
-  builder.orchestrator.addOutboundEdge(user.id, EdgeType.EventToHosts, "User");
-
-  await builder.saveX();
-  return await builder.editedEntX();
-}
-
-export async function setupTempDB(global: boolean = false) {
-  const tdb = new TempDB(Dialect.Postgres, tempDBTables(global));
-
-  await tdb.beforeAll();
-
-  // create once
-  await createEdges();
-
-  return tdb;
-}
-
-export function tempDBTables(global: boolean = false) {
-  const tables = [
-    FakeUser.getTestTable(),
-    FakeContact.getTestTable(),
-    FakeEvent.getTestTable(),
-    FakeTag.getTestTable(),
-    assoc_edge_config_table(),
-  ];
-  edgeTableNames().forEach((tableName) =>
-    tables.push(assoc_edge_table(tableName, global)),
-  );
-
-  return tables;
-}
-
-interface options {
-  howMany: number;
-  interval: number;
-  userInput?: Partial<UserCreateInput>;
-  eventInputs?: Partial<EventCreateInput>[];
-  startTime?: number | Date;
-}
-export async function createAllEvents(
-  opts: options,
-): Promise<[FakeUser, FakeEvent[]]> {
-  const user = await createTestUser(opts.userInput);
-
-  let arr = new Array(opts.howMany);
-  arr.fill(1);
-
-  // start at date in case something else has used a date already
-  advanceTo(opts.startTime || MockDate.getDate());
-
-  const events = await Promise.all(
-    arr.map(async (v, idx: number) => {
-      // just to make times deterministic so that tests can consistently work
-      if (opts.interval > 0) {
-        advanceBy(opts.interval);
-      }
-      const input = opts.eventInputs?.[idx];
-      const builder = getEventBuilder(user.viewer, getEventInput(user, input));
-      await builder.saveX();
-      return builder.editedEntX();
-    }),
-  );
-  expect(events.length).toBe(opts.howMany);
-  return [user, events];
-}