testeranto 0.47.34 → 0.47.52

package/src/lib/index.ts

@@ -0,0 +1,226 @@
+import { PM } from "../PM/index.js";
+import { IBaseTest } from "../Types.js";
+
+import {
+  IGivens,
+  BaseCheck,
+  BaseSuite,
+  BaseWhen,
+  BaseThen,
+} from "./abstractBase.js";
+import { ITestInterface } from "./types.js";
+
+// import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
+
+export const BaseTestInterface: ITestInterface<
+  IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = {
+  beforeAll: async (s) => s,
+  beforeEach: async function (
+    subject: any,
+    initialValues: any,
+    x: any,
+    testResource: any,
+    pm: PM
+  ) {
+    return subject as any;
+  },
+  afterEach: async (s) => s,
+  afterAll: (
+    store: IBaseTest<
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>
+    >["istore"]
+  ) => undefined,
+  butThen: async (
+    store: IBaseTest<
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>
+    >["istore"],
+    thenCb
+  ) => thenCb(store),
+  andWhen: (a) => a,
+  assertThis: () => null,
+};
+
+export const DefaultTestInterface = (
+  p: Partial<ITestInterface<any>>
+): ITestInterface<any> => {
+  return {
+    ...BaseTestInterface,
+    ...p,
+  };
+};
+
+export type ITTestResourceConfiguration = {
+  name: string;
+  fs: string;
+  ports: number[];
+  browserWSEndpoint: string;
+};
+
+export type ITTestResourceRequirement = {
+  name: string;
+  ports: number;
+  fs: string;
+};
+
+export type ITTestResourceRequest = {
+  ports: number;
+};
+
+export type ITLog = (...string) => void;
+
+export type ILogWriter = {
+  createWriteStream: (line: string) => any | any;
+  writeFileSync: (fp: string, contents: string) => any;
+  mkdirSync: () => any;
+  testArtiFactoryfileWriter: (
+    tLog: ITLog,
+    n: (Promise) => void
+  ) => (fPath: string, value: unknown) => void;
+};
+
+export type ITestArtificer = (key: string, data: any) => void;
+
+type ITest = {
+  toObj(): object;
+  name: string;
+  givens: IGivens<
+    IBaseTest<
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>
+    >
+  >;
+  checks: BaseCheck<
+    IBaseTest<
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>
+    >
+  >[];
+  testResourceConfiguration: ITTestResourceConfiguration;
+};
+
+export type ITestJob<T = PM> = {
+  toObj(): object;
+  test: ITest;
+  runner: (
+    x: ITTestResourceConfiguration,
+    t: ITLog
+  ) => Promise<
+    BaseSuite<
+      IBaseTest<
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>
+      >
+    >
+  >;
+  testResourceRequirement: ITTestResourceRequirement;
+  receiveTestResourceConfig: (pm: PM) => Promise<{
+    failed: number;
+    artifacts: Promise<unknown>[];
+    logPromise: Promise<unknown>;
+  }>;
+};
+
+export type ITestResults = Promise<{ test: ITest }>[];
+
+export const defaultTestResourceRequirement: ITTestResourceRequest = {
+  ports: 0,
+};
+
+export type ITestArtifactory = (key: string, value: unknown) => unknown;
+
+export type ITestCheckCallback<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = {
+  [K in keyof ITestShape["checks"]]: (
+    name: string,
+    features: string[],
+    callbackA: (
+      whens: {
+        [K in keyof ITestShape["whens"]]: (...unknown) => BaseWhen<ITestShape>;
+      },
+      thens: {
+        [K in keyof ITestShape["thens"]]: (...unknown) => BaseThen<ITestShape>;
+      }
+    ) => Promise<any>,
+    ...xtrasA: ITestShape["checks"][K]
+  ) => BaseCheck<ITestShape>;
+};

package/src/lib/types.ts

@@ -0,0 +1,303 @@
+import { IBaseTest } from "../Types";
+
+// import puppeteer from "puppeteer-core";
+import {
+  IGivens,
+  BaseCheck,
+  BaseSuite,
+  BaseGiven,
+  BaseWhen,
+  BaseThen,
+} from "./abstractBase";
+import { ITTestResourceConfiguration, ITestArtificer } from ".";
+import { PM } from "../PM/index";
+
+export type IRunTime = `node` | `web`;
+
+export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];
+
+export type IJsonConfig = {
+  outdir: string;
+  tests: ITestTypes[];
+  botEmail: string;
+};
+
+export type IBaseConfig = {
+  clearScreen: boolean;
+  debugger: boolean;
+  devMode: boolean;
+  externals: string[];
+  minify: boolean;
+  nodePlugins: any[];
+  outbase: string;
+  outdir: string;
+  ports: string[];
+  tests: ITestTypes[];
+  webPlugins: any[];
+  botEmail: string;
+};
+
+export type IBuiltConfig = { buildDir: string } & IBaseConfig;
+
+export type IWebTestInterface<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = {
+  assertThis: (x: ITestShape["then"]) => void;
+
+  andWhen: (
+    store: ITestShape["istore"],
+    whenCB: ITestShape["when"],
+    testResource: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<ITestShape["istore"]>;
+  butThen: (
+    store: ITestShape["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape["iselection"]>;
+
+  afterAll: (
+    store: ITestShape["istore"],
+    artificer: ITestArtificer,
+    utils: PM
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    utils: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    utils: PM
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    utils: PM
+  ) => Promise<ITestShape["istore"]>;
+};
+// & ITestInterface<ITestShape>;
+
+export type INodeTestInterface<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = {
+  assertThis: (x: ITestShape["then"]) => void;
+  andWhen: (
+    store: ITestShape["istore"],
+    whenCB: ITestShape["when"],
+    testResource: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<ITestShape["istore"]>;
+  butThen: (
+    store: ITestShape["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<ITestShape["iselection"]>;
+  afterAll: (
+    store: ITestShape["istore"],
+    artificer: ITestArtificer,
+    pm: PM
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    pm: PM
+  ) => Promise<ITestShape["istore"]>;
+};
+// & ITestInterface<ITestShape>;
+
+export type ITestInterface<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = {
+  assertThis: (x: ITestShape["then"]) => void;
+
+  andWhen: (
+    store: ITestShape["istore"],
+    whenCB: ITestShape["when"],
+    testResource: ITTestResourceConfiguration,
+    pm: PM
+  ) => Promise<ITestShape["istore"]>;
+  butThen: (
+    store: ITestShape["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration,
+    pm: PM
+  ) => Promise<ITestShape["iselection"]>;
+
+  afterAll: (
+    store: ITestShape["istore"],
+    artificer: ITestArtificer,
+    pm: PM
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    pm: PM
+  ) => Promise<ITestShape["istore"]>;
+};
+
+export type ISuiteKlasser<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = (
+  name: string,
+  index: number,
+  givens: IGivens<ITestShape>,
+  checks: BaseCheck<ITestShape>[]
+) => BaseSuite<ITestShape>;
+
+export type IGivenKlasser<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = (name, features, whens, thens, givenCB) => BaseGiven<ITestShape>;
+
+export type IWhenKlasser<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = (s, o) => BaseWhen<ITestShape>;
+
+export type IThenKlasser<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = (s, o) => BaseThen<ITestShape>;
+
+export type ICheckKlasser<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = (n, f, cb, w, t) => BaseCheck<ITestShape>;

package/src/mongooseSchemas.ts

@@ -0,0 +1,105 @@
+import mongoose from "mongoose";
+
+export interface IUser {
+  email: string;
+  channels: string[];
+  dmgroups: string[];
+}
+
+export const userSchema = new mongoose.Schema<IUser>({
+  email: String,
+  channels: [{ type: mongoose.Schema.Types.ObjectId, ref: "Channel" }],
+  dmgroups: [{ type: mongoose.Schema.Types.ObjectId, ref: "Dmgroup" }],
+});
+
+userSchema.virtual("features", {
+  ref: "Feature",
+  localField: "_id",
+  foreignField: "owner",
+});
+
+export interface IKanban {
+  title: string;
+}
+
+export const kanbanSchema = new mongoose.Schema<IKanban>({
+  title: String,
+});
+
+export interface IGantt {
+  name: string;
+  type: "task" | "milestone" | "project";
+  start: Date;
+  end: Date;
+}
+
+export const ganttSchema = new mongoose.Schema<IGantt>({
+  name: String,
+  type: String,
+  start: Date,
+  end: Date,
+});
+
+export interface IFeature {
+  title: string;
+  state: string;
+  owner: {
+    type: mongoose.Schema.Types.ObjectId;
+    required: true;
+    ref: "User";
+  };
+}
+
+export const featuresSchema = new mongoose.Schema<IFeature>({
+  title: String,
+  state: String,
+});
+
+export const channelsFeature = new mongoose.Schema<IChatChannel>({});
+
+export const chatCatMessageSchema = new mongoose.Schema({
+  user: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
+    required: true,
+  },
+  room: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "ChatCatRoom",
+    required: true,
+    maxlength: 100,
+  },
+  timestamp: {
+    type: Date,
+    default: Date.now(),
+  },
+  text: {
+    type: String,
+    maxlength: 1000,
+  },
+});
+
+// A channel is a base type, extended by both a huddle and room
+export interface IChatChannel {
+  users: string[];
+  messages: [{ type: mongoose.Schema.Types.ObjectId; ref: "Message" }];
+}
+
+export interface IChatCatHuddle {
+  users: {
+    type: String;
+    unique: true;
+    required: true;
+  }[];
+}
+
+export const HuddleSchema = new mongoose.Schema<IChatCatHuddle>({});
+
+// a room is just a channel with a name
+export interface IChatCatRoom {
+  name: string;
+}
+
+export const RoomSchema = new mongoose.Schema<IChatCatRoom>({
+  name: { type: String, required: true },
+});

package/src/preload.ts

@@ -1,31 +1,17 @@
-import { NodeWriter } from "./NodeWriter";
-import { ipcRenderer } from "electron";
+// import puppeteer from "puppeteer-core";
 
-(window as any).NodeWriter = NodeWriter;
-(window as any).exit = (x) => {
-  ipcRenderer.invoke('quit-app', x);
-}
+// import { NodeWriter } from "./NodeWriter";
+// import puppeteerConfiger from "./puppeteerConfiger";
 
-var oldLog = console.log;
-console.log = function (message) {
-  ipcRenderer.invoke('web-log', message);
-  oldLog.apply(console, arguments);
-};
+// (window as any).NodeWriter = NodeWriter;
 
-var oldLog = console.error;
-console.error = function (message) {
-  ipcRenderer.invoke('web-error', message);
-  oldLog.apply(console, arguments);
-};
-
-var oldLog = console.warn;
-console.warn = function (message) {
-  ipcRenderer.invoke('web-warn', message);
-  oldLog.apply(console, arguments);
-};
-
-var oldLog = console.info;
-console.info = function (message) {
-  ipcRenderer.invoke('web-info', message);
-  oldLog.apply(console, arguments);
-};
+// (window as any).browser = new Promise(async (res, rej) => {
+//   const browser = await puppeteerConfiger("2999").then(async (json) => {
+//     const b = await puppeteer.connect({
+//       browserWSEndpoint: json.webSocketDebuggerUrl,
+//       defaultViewport: null,
+//     });
+//     console.log("connected!", b.isConnected());
+//     return res(b);
+//   });
+// });

package/src/puppeteerConfiger.ts

@@ -0,0 +1,26 @@
+import http from "http";
+
+export default async (
+  port: string
+): Promise<{ webSocketDebuggerUrl: string }> =>
+  new Promise((resolve, reject) => {
+    let json = "";
+    const request = http.request(
+      {
+        host: "127.0.0.1",
+        path: "/json/version",
+        port,
+      },
+      (response) => {
+        response.on("error", reject);
+        response.on("data", (chunk: Buffer) => {
+          json += chunk.toString();
+        });
+        response.on("end", () => {
+          resolve(JSON.parse(json));
+        });
+      }
+    );
+    request.on("error", reject);
+    request.end();
+  });