testCliUtils.ts

/**
 * Copyright 2026 GitProxy Contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import fs from 'fs';
import util from 'util';
import { exec } from 'child_process';
import { expect } from 'vitest';
import { Request } from 'express';

import { Proxy } from '../../../src/proxy';
import { Action } from '../../../src/proxy/actions/Action';
import { Step } from '../../../src/proxy/actions/Step';
import { exec as execProcessor } from '../../../src/proxy/processors/post-processor/audit';
import * as db from '../../../src/db';
import { Repo } from '../../../src/db/types';
import { Service as service } from '../../../src/service';
import { CommitData } from '../../../src/proxy/processors/types';

const execAsync = util.promisify(exec);

// cookie file name
const GIT_PROXY_COOKIE_FILE = 'git-proxy-cookie';

/**
 * Type guard to check if error is from child_process exec
 */
function isExecError(error: unknown): error is Error & {
  code: number;
  stdout: string;
  stderr: string;
} {
  return error instanceof Error && 'code' in error && 'stdout' in error && 'stderr' in error;
}

/**
 * @async
 * @param {string} cli - The CLI command to be executed.
 * @param {number} expectedExitCode - The expected exit code after the command
 *        execution. Typically, `0` for successful execution.
 * @param {string} expectedMessages - The array of expected messages included
 *        in the output after the command execution.
 * @param {string} expectedErrorMessages - The array of expected messages
 *        included in the error output after the command execution.
 * @param {boolean} debug - Flag to enable detailed logging for debugging.
 * @throws {AssertionError} Throws an error if the actual exit code does not
 *         match the `expectedExitCode`.
 */
async function runCli(
  cli: string,
  expectedExitCode: number = 0,
  expectedMessages: string[] | null = null,
  expectedErrorMessages: string[] | null = null,
  debug: boolean = true,
) {
  try {
    console.log(`cli: '${cli}'`);
    const { stdout, stderr } = await execAsync(cli);
    if (debug) {
      console.log(`stdout: ${stdout}`);
      console.log(`stderr: ${stderr}`);
    }
    expect(0).toEqual(expectedExitCode);
    if (expectedMessages) {
      expectedMessages.forEach((expectedMessage) => {
        expect(stdout).toContain(expectedMessage);
      });
    }
    if (expectedErrorMessages) {
      expectedErrorMessages.forEach((expectedErrorMessage) => {
        expect(stderr).toContain(expectedErrorMessage);
      });
    }
  } catch (error: unknown) {
    if (isExecError(error)) {
      const exitCode = error.code;

      if (debug) {
        console.log(`error.stdout: ${error.stdout}`);
        console.log(`error.stderr: ${error.stderr}`);
      }
      expect(exitCode).toEqual(expectedExitCode);
      if (expectedMessages) {
        expectedMessages.forEach((expectedMessage) => {
          expect(error.stdout).toContain(expectedMessage);
        });
      }
      if (expectedErrorMessages) {
        expectedErrorMessages.forEach((expectedErrorMessage) => {
          expect(error.stderr).toContain(expectedErrorMessage);
        });
      }
    } else {
      // Assertion error, forward to Vitest to process
      throw error;
    }
  } finally {
    if (debug) {
      console.log(`cli: '${cli}': done`);
    }
  }
}

/**
 * Starts the server.
 * @param {*} service - The GitProxy API service to be started.
 * @return {Promise<void>} A promise that resolves when the service has
 * successfully started. Does not return any value upon resolution.
 */
async function startServer() {
  await service.start(new Proxy());
}

/**
 * Closes the specified HTTP server gracefully. This function wraps the
 * `close` method of the `http.Server` instance in a promise to facilitate
 * async/await usage. It ensures the server stops accepting new connections
 * and terminates existing ones before shutting down.
 *
 * @param {number} waitTime - The wait time after close.
 * @return {Promise<void>} A promise that resolves when the server has been
 * successfully closed, or rejects if an error occurs during closure. The
 * promise does not return any value upon resolution.
 *
 * @throws {Error} If the server cannot be closed properly or if an error
 * occurs during the close operation.
 */
async function closeServer(waitTime: number = 0) {
  const server = service.httpServer;

  if (!server) {
    throw new Error('Server not started');
  }

  return new Promise<void>((resolve, reject) => {
    server.closeAllConnections();
    server.close((err) => {
      if (err) {
        console.error('Failed to close the server:', err);
        reject(err); // Reject the promise if there's an error
      } else {
        setTimeout(() => {
          console.log(`Server closed successfully (wait time ${waitTime}).`);
          resolve(); // Resolve the promise when the server is closed
        }, waitTime);
      }
    });
  });
}

/**
 * Create local cookies file with an expired connect cookie.
 */
async function createCookiesFileWithExpiredCookie() {
  await removeCookiesFile();
  const cookies = [
    'connect.sid=s%3AuWjJK_VGFbX9-03UfvoSt_HFU3a0vFOd.jd986YQ17Bw4j1xGJn2l9yiF3QPYhayaYcDqGsNgQY4; Path=/; HttpOnly',
  ];
  fs.writeFileSync(GIT_PROXY_COOKIE_FILE, JSON.stringify(cookies), 'utf8');
}

/**
 * Remove local cookies file.
 */
async function removeCookiesFile() {
  if (fs.existsSync(GIT_PROXY_COOKIE_FILE)) {
    fs.unlinkSync(GIT_PROXY_COOKIE_FILE);
  }
}

/**
 * Add a new repo to the database.
 * @param {object} newRepo The new repo attributes.
 * @param {boolean} debug Print debug messages to console if true.
 */
async function addRepoToDb(newRepo: Repo, debug = false) {
  const { data: repos } = await db.getRepos();
  const found = repos.find((y) => y.project === newRepo.project && newRepo.name === y.name);
  if (!found) {
    await db.createRepo(newRepo);
    const repo = await db.getRepoByUrl(newRepo.url);
    await db.addUserCanPush(repo?._id || '', 'admin');
    await db.addUserCanAuthorise(repo?._id || '', 'admin');
    if (debug) {
      console.log(`New repo added to database: ${newRepo}`);
    }
  } else {
    if (debug) {
      console.log(`New repo already found in database: ${newRepo}`);
    }
  }
}

/**
 * Removes a repo from the DB.
 * @param {string} repoUrl  The url of the repo to remove.
 */
async function removeRepoFromDb(repoUrl: string) {
  const repo = await db.getRepoByUrl(repoUrl);
  await db.deleteRepo(repo?._id || '');
}

/**
 * Add a new git push record to the database.
 * @param {string} id The ID of the git push.
 * @param {string} repoUrl The repository URL of the git push.
 * @param {string} user The user who pushed the git push.
 * @param {string} userEmail The email of the user who pushed the git push.
 * @param {boolean} debug Flag to enable logging for debugging.
 */
async function addGitPushToDb(
  id: string,
  repoUrl: string,
  user: string | null = null,
  userEmail: string | null = null,
  debug: boolean = false,
) {
  const action = new Action(
    id,
    'push', // type
    'get', // method
    Date.now(), // timestamp
    repoUrl,
  );
  action.user = user || '';
  action.userEmail = userEmail || '';
  const step = new Step(
    'authBlock', // stepName
    false, // error
    null, // errorMessage
    true, // blocked
    `\n\n\nGitProxy has received your push:\n\nhttp://localhost:8080/requests/${id}\n\n\n`, // blockedMessage
    null, // content
  );
  const commitData: CommitData[] = [];
  commitData.push({
    tree: 'tree test',
    parent: 'parent',
    author: 'author',
    committer: 'committer',
    message: 'message',
    authorEmail: 'authorEmail',
    committerEmail: 'committerEmail',
    commitTimestamp: '1234567890',
  });
  action.commitData = commitData;
  action.addStep(step);
  const result = await execProcessor({} as Request, action);
  if (debug) {
    console.log(`New git push added to DB: ${util.inspect(result)}`);
  }
}

/**
 * Removes a push from the DB
 * @param {string} id
 */
async function removeGitPushFromDb(id: string) {
  await db.deletePush(id);
}

/**
 * Add new user record to the database.
 * @param {string} username The user name.
 * @param {string} password The user password.
 * @param {string} email The user email.
 * @param {string} gitAccount The user git account.
 * @param {boolean} admin Flag to make the user administrator.
 * @param {boolean} debug Flag to enable logging for debugging.
 */
async function addUserToDb(
  username: string,
  password: string,
  email: string,
  gitAccount: string,
  admin: boolean = false,
  debug: boolean = false,
) {
  const result = await db.createUser(username, password, email, gitAccount, admin);
  if (debug) {
    console.log(`New user added to DB: ${util.inspect(result)}`);
  }
}

/**
 * Remove a user record from the database if present.
 * @param {string} username The user name.
 */
async function removeUserFromDb(username: string) {
  await db.deleteUser(username);
}

export {
  runCli,
  startServer,
  closeServer,
  addRepoToDb,
  removeRepoFromDb,
  addGitPushToDb,
  removeGitPushFromDb,
  addUserToDb,
  removeUserFromDb,
  createCookiesFileWithExpiredCookie,
  removeCookiesFile,
};