directus

1
/* eslint-disable no-console */
2
import axios from 'axios';
3
import { spawn, spawnSync } from 'child_process';
4
import knex from 'knex';
5
import { Listr } from 'listr2';
6
import { clone } from 'lodash-es';
7
import fs from 'node:fs/promises';
8
import { join } from 'node:path';
9
import config, { getUrl, paths } from '../common/config';
10
import vendors from '../common/get-dbs-to-test';
11
import { USER } from '../common/variables';
12
import { awaitDatabaseConnection, awaitDirectusConnection } from '../utils/await-connection';
13
import global from './global';
14

15
export async function setup() {
16
	console.log(`👮‍♀️ Starting tests!\n`);
17

18
	await new Listr([
19
		{
20
			title: 'Bootstrap databases and start servers',
21
			task: async () => {
22
				return new Listr(
23
					vendors.map((vendor) => {
24
						return {
25
							title: config.names[vendor],
26
							task: async () => {
27
								const database = knex(config.knexConfig[vendor]);
28
								await awaitDatabaseConnection(database, config.knexConfig[vendor].waitTestSQL);
29

30
								if (vendor === 'sqlite3') {
31
									await fs.writeFile(join(paths.cwd, 'test.db'), '');
32
								}
33

34
								const bootstrap = spawnSync('node', [paths.cli, 'bootstrap'], {
35
									cwd: paths.cwd,
36
									env: config.envs[vendor],
37
								});
38

39
								if (bootstrap.status !== null && bootstrap.status !== 0) {
40
									throw new Error(
41
										`Directus-${vendor} bootstrap failed (${bootstrap.status}): \n ${bootstrap.stderr.toString()}`,
42
									);
43
								}
44

45
								await database.migrate.latest();
46
								await database.seed.run();
47
								await database.destroy();
48

49
								if (!process.env['TEST_LOCAL']) {
50
									const server = spawn('node', [paths.cli, 'start'], {
51
										cwd: paths.cwd,
52
										env: config.envs[vendor],
53
									});
54

55
									global.directus[vendor] = server;
56
									let serverOutput = '';
57
									server.stdout.setEncoding('utf8');
58

59
									server.stdout.on('data', (data) => {
60
										serverOutput += data.toString();
61
									});
62

63
									server.stderr.on('data', (data) => {
64
										console.log(data.toString());
65
									});
66

67
									server.on('exit', async (code) => {
68
										if (process.env['TEST_SAVE_LOGS']) {
69
											await fs.writeFile(join(paths.cwd, `server-log-${vendor}.txt`), serverOutput);
70
										}
71

72
										if (code !== null)
73
											throw new Error(`Directus-${vendor} server failed (${code}): \n ${serverOutput}`);
74
									});
75

76
									// Give the server some time to start
77
									await awaitDirectusConnection(Number(config.envs[vendor].PORT));
78

79
									// Set up separate directus instance without system cache
80
									const noCacheEnv = clone(config.envs[vendor]);
81
									noCacheEnv['CACHE_SCHEMA'] = 'false';
82
									noCacheEnv['PORT'] = String(parseInt(noCacheEnv.PORT) + 50);
83
									const serverNoCache = spawn('node', [paths.cli, 'start'], { cwd: paths.cwd, env: noCacheEnv });
84
									global.directusNoCache[vendor] = serverNoCache;
85
									let serverNoCacheOutput = '';
86
									serverNoCache.stdout.setEncoding('utf8');
87

88
									serverNoCache.stdout.on('data', (data) => {
89
										serverNoCacheOutput += data.toString();
90
									});
91

92
									serverNoCache.on('exit', async (code) => {
93
										if (process.env['TEST_SAVE_LOGS']) {
94
											await fs.writeFile(join(paths.cwd, `server-log-${vendor}-no-cache.txt`), serverNoCacheOutput);
95
										}
96

97
										if (code !== null) {
98
											throw new Error(`Directus-${vendor}-no-cache server failed (${code}): \n ${serverNoCacheOutput}`);
99
										}
100
									});
101

102
									// Give the server some time to start
103
									await awaitDirectusConnection(Number(noCacheEnv['PORT']));
104
								}
105
							},
106
						};
107
					}),
108
					{ concurrent: true, rendererOptions: { collapseErrors: false } },
109
				);
110
			},
111
		},
112
		{
113
			title: 'Test server connectivity',
114
			task: async () => {
115
				for (const vendor of vendors) {
116
					try {
117
						const serverUrl = getUrl(vendor);
118

119
						const response = await axios.get(
120
							`${serverUrl}/items/tests_flow_data?access_token=${USER.TESTS_FLOW.TOKEN}`,
121
						);
122

123
						if (response.status === 200) {
124
							process.env['serverUrl'] = serverUrl;
125
							break;
126
						}
127
					} catch (err) {
128
						continue;
129
					}
130
				}
131

132
				if (!process.env['serverUrl']) {
133
					throw new Error('Unable to connect to any Directus server');
134
				}
135
			},
136
		},
137
	])
138
		.run()
139
		.catch((reason) => {
140
			for (const server of Object.values(global.directus)) {
141
				server?.kill();
142
			}
143

144
			for (const serverNoCache of Object.values(global.directusNoCache)) {
145
				serverNoCache?.kill();
146
			}
147

148
			throw new Error(reason);
149
		});
150

151
	console.log('\n');
152
}
153

154
export async function teardown() {
155
	try {
156
		await fs.unlink('sequencer-data.json');
157
	} catch {
158
		// Ignore
159
	}
160

161
	if (!process.env['TEST_LOCAL']) {
162
		await new Listr([
163
			{
164
				title: 'Stop Directus servers',
165
				task: () => {
166
					return new Listr(
167
						vendors.map((vendor) => {
168
							return {
169
								title: config.names[vendor]!,
170
								task: async () => {
171
									const directus = global.directus[vendor];
172
									directus?.kill();
173

174
									const directusNoCache = global.directusNoCache[vendor];
175
									directusNoCache?.kill();
176
								},
177
							};
178
						}),
179
						{ concurrent: true, exitOnError: false },
180
					);
181
				},
182
			},
183
		]).run();
184
	}
185

186
	console.log('\n');
187

188
	console.log(`👮‍♀️ Tests complete!\n`);
189
}
190