import * as Docker from 'dockerode';
import * as fs from 'fs';
import * as R from 'ramda';
import { Connection, ConnectionOptions, createConnection } from 'typeorm';
import * as ormConfig from '../src/ormconfig';
// The name of the image to pull and use for the container. This also affects
// which version of Postgres we use.
const DOCKER_IMAGE_NAME = 'postgres:11-alpine';
// The name to use for the Docker container which will run Postgres.
const DOCKER_CONTAINER_NAME = '0x_pipeline_postgres_test';
// The port which will be exposed on the Docker container.
const POSTGRES_HOST_PORT = '15432';
// Number of milliseconds to wait for postgres to finish initializing after
// starting the docker container.
const POSTGRES_SETUP_DELAY_MS = 5000;
/**
* Sets up the database for testing purposes. If the
* ZEROEX_DATA_PIPELINE_TEST_DB_URL env var is specified, it will create a
* connection using that url. Otherwise it will spin up a new Docker container
* with a Postgres database and then create a connection to that database.
*/
export async function setUpDbAsync(): Promise<void> {
const connection = await createDbConnectionOnceAsync();
await connection.runMigrations({ transaction: true });
}
/**
* Tears down the database used for testing. This completely destroys any data.
* If a docker container was created, it destroys that container too.
*/
export async function tearDownDbAsync(): Promise<void> {
const connection = await createDbConnectionOnceAsync();
for (const _ of connection.migrations) {
await connection.undoLastMigration({ transaction: true });
}
if (needsDocker()) {
const docker = initDockerOnce();
const postgresContainer = docker.getContainer(DOCKER_CONTAINER_NAME);
await postgresContainer.kill();
await postgresContainer.remove();
}
}
let savedConnection: Connection;
/**
* The first time this is run, it creates and returns a new TypeORM connection.
* Each subsequent time, it returns the existing connection. This is helpful
* because only one TypeORM connection can be active at a time.
*/
export async function createDbConnectionOnceAsync(): Promise<Connection> {
if (savedConnection !== undefined) {
return savedConnection;
}
if (needsDocker()) {
await initContainerAsync();
}
const testDbUrl =
process.env.ZEROEX_DATA_PIPELINE_TEST_DB_URL ||
`postgresql://postgres@localhost:${POSTGRES_HOST_PORT}/postgres`;
const testOrmConfig = R.merge(ormConfig, { url: testDbUrl }) as ConnectionOptions;
savedConnection = await createConnection(testOrmConfig);
return savedConnection;
}
async function sleepAsync(ms: number): Promise<{}> {
return new Promise<{}>(resolve => setTimeout(resolve, ms));
}
let savedDocker: Docker;
function initDockerOnce(): Docker {
if (savedDocker !== undefined) {
return savedDocker;
}
// Note(albrow): Code for determining the right socket path is partially
// based on https://github.com/apocas/dockerode/blob/8f3aa85311fab64d58eca08fef49aa1da5b5f60b/test/spec_helper.js
const isWin = require('os').type() === 'Windows_NT';
const socketPath = process.env.DOCKER_SOCKET || (isWin ? '//./pipe/docker_engine' : '/var/run/docker.sock');
const isSocket = fs.existsSync(socketPath) ? fs.statSync(socketPath).isSocket() : false;
if (!isSocket) {
throw new Error(`Failed to connect to Docker using socket path: "${socketPath}".
The database integration tests need to be able to connect to a Postgres database. Make sure that Docker is running and accessible at the expected socket path. If Docker isn't working you have two options:
1) Set the DOCKER_SOCKET environment variable to a socket path that can be used to connect to Docker or
2) Set the ZEROEX_DATA_PIPELINE_TEST_DB_URL environment variable to connect directly to an existing Postgres database instead of trying to start Postgres via Docker
`);
}
savedDocker = new Docker({
socketPath,
});
return savedDocker;
}
// Creates the container, waits for it to initialize, and returns it.
async function initContainerAsync(): Promise<Docker.Container> {
const docker = initDockerOnce();
// Tear down any existing containers with the same name.
await tearDownExistingContainerIfAnyAsync();
// Pull the image we need.
await pullImageAsync(docker, DOCKER_IMAGE_NAME);
// Create the container.
const postgresContainer = await docker.createContainer({
name: DOCKER_CONTAINER_NAME,
Image: DOCKER_IMAGE_NAME,
ExposedPorts: {
'5432': {},
},
HostConfig: {
PortBindings: {
'5432': [
{
HostPort: POSTGRES_HOST_PORT,
},
],
},
},
});
await postgresContainer.start();
await sleepAsync(POSTGRES_SETUP_DELAY_MS);
return postgresContainer;
}
async function tearDownExistingContainerIfAnyAsync(): Promise<void> {
const docker = initDockerOnce();
// Check if a container with the desired name already exists. If so, this
// probably means we didn't clean up properly on the last test run.
const existingContainer = docker.getContainer(DOCKER_CONTAINER_NAME);
if (existingContainer != null) {
try {
await existingContainer.kill();
} catch {
// If this fails, it's fine. The container was probably already
// killed.
}
try {
await existingContainer.remove();
} catch {
// If this fails, it's fine. The container was probably already
// removed.
}
}
}
function needsDocker(): boolean {
return process.env.ZEROEX_DATA_PIPELINE_TEST_DB_URL === undefined;
}
// Note(albrow): This is partially based on
// https://stackoverflow.com/questions/38258263/how-do-i-wait-for-a-pull
async function pullImageAsync(docker: Docker, imageName: string): Promise<void> {
return new Promise<void>((resolve, reject) => {
docker.pull(imageName, {}, (err, stream) => {
if (err != null) {
reject(err);
return;
}
docker.modem.followProgress(stream, () => {
resolve();
});
});
});
}
