9156831137

Committed 20 May 2024 09:47AM UTC coverage: 31.965% (+0.05%) from 31.916%

Build # 9156831137

Build Type

Pull #9211

github

Committed by

oetherington

Commit Message

Merge branch 'master' into playwright

Pull Request Pull Request #9211: Replace Cypress with Playwright

Run Details

4800 of 39013 branches covered (12.3%)

Branch coverage included in aggregate %.

34 of 82 new or added lines in 22 files covered. (41.46%)

6 existing lines in 5 files now uncovered.

27813 of 63014 relevant lines covered (44.14%)

180.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.7

/packages/lesswrong/server/testingSqlClient.ts

import { Application, json, Request, Response } from "express";
import { closeSqlClient, getSqlClient, replaceDbNameInPgConnectionString, setSqlClient } from "../lib/sql/sqlClient";
import { createSqlConnection } from "./sqlConnection";
import { testServerSetting } from "../lib/instanceSettings";
import { readFile } from "fs/promises";

const loadDbSchema = async (client: SqlClient) => {
  try {
    const schema = await readFile("./schema/accepted_schema.sql");
    await client.multi(schema.toString());
  } catch (e) {
    throw new Error("Failed to load db schema", {cause: e});
  }
}

const makeDbName = (id?: string) => {
  const jestWorkerIdSuffix = process.env.JEST_WORKER_ID ? `_${process.env.JEST_WORKER_ID}` : "";
  id ??= `${new Date().toISOString().replace(/[:.-]/g, "_")}_${process.pid}${jestWorkerIdSuffix}`;
  return `unittest_${id}`.toLowerCase();
}

const createTemporaryConnection = async () => {
  let client = getSqlClient();
  if (client) {
    return client;
  }
  const {PG_URL} = process.env;
  if (!PG_URL) {
    throw new Error("Can't initialize test DB - PG_URL not set");
  }
  client = await createSqlConnection(PG_URL, true);
  setSqlClient(client);
  return client;
}

export type TestingSqlClient = {
  sql: SqlClient,
  dbName: string,
}

export const createTestingSqlClient = async (
  id: string | undefined = undefined,
  dropExisting = false,
  setAsGlobalClient = true,
): Promise<TestingSqlClient> => {
  const {PG_URL} = process.env;
  if (!PG_URL) {
    throw new Error("Can't create testing SQL client - PG_URL not set");
  }
  const dbName = makeDbName(id);
  // eslint-disable-next-line no-console
  console.log(`Creating test database '${dbName}'...`);
  let sql = await createTemporaryConnection();
  if (dropExisting) {
    await sql.none(`DROP DATABASE IF EXISTS ${dbName}`);
  }
  await sql.none(`CREATE DATABASE ${dbName}`);
  const testUrl = replaceDbNameInPgConnectionString(PG_URL, dbName);
  sql = await createSqlConnection(testUrl, true);
  await loadDbSchema(sql);
  if (setAsGlobalClient) {
    setSqlClient(sql);
  }
  return {
    sql,
    dbName,
  };
}

export const createTestingSqlClientFromTemplate = async (template: string): Promise<TestingSqlClient> => {
  const {PG_URL} = process.env;
  if (!PG_URL) {
    throw new Error("Can't create testing SQL client from template - PG_URL not set");
  }
  if (!template) {
    throw new Error("No template database provided");
  }
  const dbName = makeDbName();
  let sql = await createTemporaryConnection();
  await sql.any('CREATE DATABASE "$1:value" TEMPLATE $2', [dbName, template]);
  const testUrl = replaceDbNameInPgConnectionString(PG_URL, dbName);
  sql = await createSqlConnection(testUrl, true);
  setSqlClient(sql);
  return {
    sql,
    dbName,
  };
}

/**
 * Our approach to database cleanup is to just delete all the runs older than 1 day.
 * This allows us to inspect the databases created during the last run if necessary
 * for debugging whilst also making sure that we clean up after ourselves eventually
 * (assuming that the tests are run again some day).
 */
export const dropTestingDatabases = async (olderThan?: string | Date) => {
  const sql = await createTemporaryConnection();
  const databases = await sql.any(`
    SELECT datname
    FROM pg_database
    WHERE datistemplate = FALSE AND
      datname LIKE 'unittest_%' AND
      pg_catalog.pg_get_userbyid(datdba) = CURRENT_USER
  `);
  const secondsPerDay = 1000 * 60 * 60 * 24;
  olderThan = new Date(olderThan ?? (Date.now() - secondsPerDay));
  for (const database of databases) {
    const {datname} = database;
    if (!datname.match(/^unittest_\d{4}_\d{2}_\d{2}t\d{2}_\d{2}_\d{2}_\d{3}z.*$/)) {
      continue;
    }

    // Replace underscores with dashes and colons etc
    const tokens = datname.split("_").slice(1, 7);
    const yearMonth = tokens.slice(0, 2);
    const dayTime = tokens.slice(2, 5);
    const millis = tokens[5];
    const dateString = (yearMonth.join("-") + "-" + dayTime.join(":") + "." + millis).toUpperCase();
    const dateCreated = new Date(dateString);
    if (dateCreated < olderThan) {
      await sql.none(`DROP DATABASE ${datname}`);
    }
  }
}

export const killAllConnections = async (id?: string) => {
  const sql = await createTemporaryConnection();
  const dbName = makeDbName(id);
  await sql.any(`
    SELECT pg_terminate_backend(pg_stat_activity.pid)
    FROM pg_stat_activity
    WHERE pg_stat_activity.datname = $1 AND pid <> pg_backend_pid()
  `, [dbName]);
  const client = getSqlClient();
  if (client) {
    await closeSqlClient(client);
  }
}

type DropAndCreatePgArgs = {
  templateId?: string,
  dropExisting?: boolean,
}

export const dropAndCreatePg = async ({templateId, dropExisting}: DropAndCreatePgArgs) => {
  const oldClient = getSqlClient();
  setSqlClient(await createSqlConnection());
  await oldClient?.$pool.end();
  // eslint-disable-next-line no-console
  console.log("Creating PG database");
  await createTestingSqlClient(templateId, dropExisting);
}

// In development mode, we need a clean way to recreate the integration test
// database. We definitely don't ever want this in prod though.
// TODO: There should be a much cleaner way to do this now we have a complete
// schema and dockerized postgres.
export const addTestingRoutes = (app: Application) => {
  // TODO: better check for dev mode
  if (testServerSetting.get()) {
    const integrationRoute = "/api/dropAndCreatePg";
    app.use(integrationRoute, json({ limit: "1mb" }));
    app.post(integrationRoute, async (req: Request, res: Response) => {
      try {
        const { templateId } = req.body;
        if (!templateId || typeof templateId !== "string") {
          throw new Error("No templateId provided");
        }
        await dropAndCreatePg({
          templateId,
          dropExisting: true,
        });
        res.status(200).send({status: "ok"});
      } catch (e) {
        res.status(500).send({status: "error", message: e.message});
      }
    });
  }
}

1	import { Application, json, Request, Response } from "express";	93✔
2	import { closeSqlClient, getSqlClient, replaceDbNameInPgConnectionString, setSqlClient } from "../lib/sql/sqlClient";	18✔
3	import { createSqlConnection } from "./sqlConnection";	18✔
4	import { testServerSetting } from "../lib/instanceSettings";	18✔
5	import { readFile } from "fs/promises";	18✔
6
7	const loadDbSchema = async (client: SqlClient) => {	18✔
8	try {	×
9	const schema = await readFile("./schema/accepted_schema.sql");	×
10	await client.multi(schema.toString());	×
11	} catch (e) {
12	throw new Error("Failed to load db schema", {cause: e});	×
13	}
14	}
15
16	const makeDbName = (id?: string) => {	18✔
17	const jestWorkerIdSuffix = process.env.JEST_WORKER_ID ? `_${process.env.JEST_WORKER_ID}` : "";	16!
18	id ??= `${new Date().toISOString().replace(/[:.-]/g, "_")}_${process.pid}${jestWorkerIdSuffix}`;	16!
19	return `unittest_${id}`.toLowerCase();	16✔
20	}
21
22	const createTemporaryConnection = async () => {	18✔
23	let client = getSqlClient();	21✔
24	if (client) {	21!
25	return client;	×
26	}
27	const {PG_URL} = process.env;	21✔
28	if (!PG_URL) {	21!
29	throw new Error("Can't initialize test DB - PG_URL not set");	×
30	}
31	client = await createSqlConnection(PG_URL, true);	21✔
32	setSqlClient(client);	21✔
33	return client;	21✔
34	}
35
36	export type TestingSqlClient = {
37	sql: SqlClient,
38	dbName: string,
39	}
40
41	export const createTestingSqlClient = async (	18✔
42	id: string \| undefined = undefined,	×
43	dropExisting = false,	×
44	setAsGlobalClient = true,	×
45	): Promise<TestingSqlClient> => {
46	const {PG_URL} = process.env;	×
47	if (!PG_URL) {	×
48	throw new Error("Can't create testing SQL client - PG_URL not set");	×
49	}
50	const dbName = makeDbName(id);	×
51	// eslint-disable-next-line no-console
52	console.log(`Creating test database '${dbName}'...`);	×
53	let sql = await createTemporaryConnection();	×
54	if (dropExisting) {	×
55	await sql.none(`DROP DATABASE IF EXISTS ${dbName}`);	×
56	}
57	await sql.none(`CREATE DATABASE ${dbName}`);	×
58	const testUrl = replaceDbNameInPgConnectionString(PG_URL, dbName);	×
59	sql = await createSqlConnection(testUrl, true);	×
60	await loadDbSchema(sql);	×
61	if (setAsGlobalClient) {	×
62	setSqlClient(sql);	×
63	}
64	return {	×
65	sql,
66	dbName,
67	};
68	}
69
70	export const createTestingSqlClientFromTemplate = async (template: string): Promise<TestingSqlClient> => {	18✔
71	const {PG_URL} = process.env;	16✔
72	if (!PG_URL) {	16!
73	throw new Error("Can't create testing SQL client from template - PG_URL not set");	×
74	}
75	if (!template) {	16!
76	throw new Error("No template database provided");	×
77	}
78	const dbName = makeDbName();	16✔
79	let sql = await createTemporaryConnection();	16✔
80	await sql.any('CREATE DATABASE "$1:value" TEMPLATE $2', [dbName, template]);	16✔
81	const testUrl = replaceDbNameInPgConnectionString(PG_URL, dbName);	16✔
82	sql = await createSqlConnection(testUrl, true);	16✔
83	setSqlClient(sql);	16✔
84	return {	16✔
85	sql,
86	dbName,
87	};
88	}
89
90	/**
91	* Our approach to database cleanup is to just delete all the runs older than 1 day.
92	* This allows us to inspect the databases created during the last run if necessary
93	* for debugging whilst also making sure that we clean up after ourselves eventually
94	* (assuming that the tests are run again some day).
95	*/
96	export const dropTestingDatabases = async (olderThan?: string \| Date) => {	18✔
97	const sql = await createTemporaryConnection();	5✔
98	const databases = await sql.any(`	5✔
99	SELECT datname
100	FROM pg_database
101	WHERE datistemplate = FALSE AND
102	datname LIKE 'unittest_%' AND
103	pg_catalog.pg_get_userbyid(datdba) = CURRENT_USER
104	`);
105	const secondsPerDay = 1000 * 60 * 60 * 24;	5✔
106	olderThan = new Date(olderThan ?? (Date.now() - secondsPerDay));	5!
107	for (const database of databases) {	5✔
108	const {datname} = database;	50✔
109	if (!datname.match(/^unittest_\d{4}_\d{2}_\d{2}t\d{2}_\d{2}_\d{2}_\d{3}z.*$/)) {	50✔
110	continue;	5✔
111	}
112
113	// Replace underscores with dashes and colons etc
114	const tokens = datname.split("_").slice(1, 7);	45✔
115	const yearMonth = tokens.slice(0, 2);	45✔
116	const dayTime = tokens.slice(2, 5);	45✔
117	const millis = tokens[5];	45✔
118	const dateString = (yearMonth.join("-") + "-" + dayTime.join(":") + "." + millis).toUpperCase();	45✔
119	const dateCreated = new Date(dateString);	45✔
120	if (dateCreated < olderThan) {	45!
121	await sql.none(`DROP DATABASE ${datname}`);	×
122	}
123	}
124	}
125
126	export const killAllConnections = async (id?: string) => {	18✔
127	const sql = await createTemporaryConnection();	×
128	const dbName = makeDbName(id);	×
129	await sql.any(`	×
130	SELECT pg_terminate_backend(pg_stat_activity.pid)
131	FROM pg_stat_activity
132	WHERE pg_stat_activity.datname = $1 AND pid <> pg_backend_pid()
133	`, [dbName]);
134	const client = getSqlClient();	×
135	if (client) {	×
136	await closeSqlClient(client);	×
137	}
138	}
139
140	type DropAndCreatePgArgs = {
141	templateId?: string,
142	dropExisting?: boolean,
143	}
144
145	export const dropAndCreatePg = async ({templateId, dropExisting}: DropAndCreatePgArgs) => {	18✔
146	const oldClient = getSqlClient();	×
147	setSqlClient(await createSqlConnection());	×
148	await oldClient?.$pool.end();	×
149	// eslint-disable-next-line no-console
150	console.log("Creating PG database");	×
151	await createTestingSqlClient(templateId, dropExisting);	×
152	}
153
154	// In development mode, we need a clean way to recreate the integration test
155	// database. We definitely don't ever want this in prod though.
156	// TODO: There should be a much cleaner way to do this now we have a complete
157	// schema and dockerized postgres.
158	export const addTestingRoutes = (app: Application) => {	18✔
159	// TODO: better check for dev mode
160	if (testServerSetting.get()) {	×
161	const integrationRoute = "/api/dropAndCreatePg";	×
162	app.use(integrationRoute, json({ limit: "1mb" }));	×
163	app.post(integrationRoute, async (req: Request, res: Response) => {	×
164	try {	×
165	const { templateId } = req.body;	×
166	if (!templateId \|\| typeof templateId !== "string") {	×
167	throw new Error("No templateId provided");	×
168	}
169	await dropAndCreatePg({	×
170	templateId,
171	dropExisting: true,
172	});
UNCOV 173	res.status(200).send({status: "ok"});	×
174	} catch (e) {
175	res.status(500).send({status: "error", message: e.message});	×
176	}
177	});
178	}
179	}

ForumMagnum / ForumMagnum / 9156831137

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous