testit-api-client 1.0.0 → 1.0.1

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ['@babel/preset-env', { targets: { node: 'current' } }],
+    '@babel/preset-typescript',
+  ],
+};

package/jest.config.ts

@@ -0,0 +1,194 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+export default {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "C:\\Users\\Andrey\\AppData\\Local\\Temp\\jest",
+
+  // Automatically clear mock calls and instances between every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  // collectCoverage: false,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  // coverageDirectory: undefined,
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "\\\\node_modules\\\\"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: 'v8',
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state between every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state between every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "\\\\node_modules\\\\"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // This option sets the URL for the jsdom environment. It is reflected in properties such as location.href
+  // testURL: "http://localhost",
+
+  // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
+  // timers: "real",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "\\\\node_modules\\\\",
+  //   "\\.pnp\\.[^\\\\]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testit-api-client",
-  "version": "1.0.0",
-  "description": "Client provides methods for communication with TestIt API.",
+  "version": "1.0.1",
+  "description": "Client provides methods for communication with Test IT API.",
   "main": "dist/index.js",
   "scripts": {
     "test": "jest",
@@ -33,9 +33,6 @@
     "querystring": "^0.2.1",
     "zod": "^3.11.6"
   },
-  "files": [
-    "dist"
-  ],
   "bugs": {
     "url": "https://github.com/testit-tms/api-client-js/issues"
   },

package/readme.md

@@ -3,11 +3,17 @@
 Client provides methods for communication with TestIt API.
 
 # Installation
+
 ```
 npm i <TBD>
 ```
+or
+```
+yarn add <TBD>
+```
 
 # Usage
+
 ```ts
 const client = new Client({
   url: 'http://test.com',

package/src/client.ts

@@ -0,0 +1,183 @@
+import axios, { AxiosInstance, AxiosResponse } from 'axios';
+import minimist from 'minimist';
+import {
+  Attachment,
+  Autotest,
+  AutotestPost,
+  AutotestPut,
+  AutotestQuery,
+  AutotestResultsForTestRun,
+  ClientConfig,
+  ClientConfigWithFile,
+  IClient,
+  TestRunGet,
+  TestRunPost,
+  WorkItemId,
+} from './types';
+import { existsSync, readFileSync } from 'fs';
+import FormData from 'form-data';
+import { basename } from 'path';
+import { validateConfig } from './validation';
+
+export class Client implements IClient {
+  private readonly axios: AxiosInstance;
+  private config: ClientConfig;
+
+  constructor(config: Partial<ClientConfigWithFile>) {
+    const { configFile, ...restConfig } = config;
+    let finalConfig = restConfig;
+    if (configFile) {
+      finalConfig = Client.mergeConfig(
+        finalConfig,
+        this.readConfigFile(configFile)
+      );
+    }
+    finalConfig = Client.mergeConfig(finalConfig, this.readEnvConfig());
+    finalConfig = Client.mergeConfig(finalConfig, this.readCliConfig());
+    this.config = validateConfig(finalConfig);
+    const baseURL = new URL('/api/v2', this.config.url).toString();
+    this.axios = axios.create({
+      baseURL,
+      headers: {
+        Authorization: `PrivateToken ${this.config.privateToken}`,
+      },
+    });
+  }
+
+  async checkConnection() {
+    try {
+      await axios.get(new URL('version.json', this.config.url).toString());
+    } catch (err) {
+      throw new Error('Cannot connect to TestIt');
+    }
+  }
+
+  // TODO: add query object
+  async getAutotest(query: AutotestQuery): Promise<Autotest[]> {
+    const params = new URLSearchParams();
+    Object.keys(query).forEach((key) => {
+      const value = query[key as keyof AutotestQuery];
+      if (value === undefined) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => params.append(key, v));
+      } else {
+        params.append(key, value.toString());
+      }
+    });
+    return this.axios
+      .get(`/autoTests?${params.toString()}`)
+      .then((res) => res.data);
+  }
+
+  async createAutotest(autotest: AutotestPost): Promise<Autotest> {
+    return this.axios.post('/autoTests', autotest).then((res) => res.data);
+  }
+
+  async updateAutotest(autotest: AutotestPut): Promise<void> {
+    return this.axios.put('/autoTests', autotest);
+  }
+
+  async linkToWorkItem(
+    autotestId: string,
+    workItem: WorkItemId
+  ): Promise<void> {
+    return this.axios.post(`/autoTests/${autotestId}/workItems`, workItem);
+  }
+
+  async createTestRun(testRun: TestRunPost): Promise<TestRunGet> {
+    return this.axios
+      .post('/testRuns', testRun)
+      .then((res) => res.data as TestRunGet);
+  }
+
+  async startTestRun(testRunId: string): Promise<void> {
+    return this.axios.post(`/testRuns/${testRunId}/start`);
+  }
+
+  async loadTestRunResults(
+    testRunId: string,
+    results: AutotestResultsForTestRun[]
+  ): Promise<string[]> {
+    return await this.axios
+      .post<AutotestResultsForTestRun[], AxiosResponse<string[]>>(
+        `/testRuns/${testRunId}/testResults`,
+        results
+      )
+      .then((res) => res.data);
+  }
+
+  async completeTestRun(testRunId: string): Promise<void> {
+    return this.axios.post(`/testRuns/${testRunId}/complete`);
+  }
+
+  getConfig(): ClientConfig {
+    return this.config;
+  }
+
+  async loadAttachment(filePath: string): Promise<Attachment> {
+    const form = new FormData();
+    form.append('file', readFileSync(filePath), basename(filePath));
+    return this.axios
+      .post<FormData, AxiosResponse<Attachment>>('/Attachments', form, {
+        headers: form.getHeaders(),
+      })
+      .then((res) => res.data);
+  }
+
+  private readCliConfig(): Partial<ClientConfig> {
+    const args = minimist(process.argv.slice(2));
+    let config = {};
+    if (args['testitConfig']) {
+      config = this.readConfigFile(args['testitConfig']);
+    }
+    return Client.mergeConfig(config, {
+      url: args['testitUrl'],
+      privateToken: args['testitPrivateToken'],
+      projectId: args['testitProjectId'],
+      configurationId: args['testitConfigurationId'],
+      testRunId: args['testitTestRunId'],
+    });
+  }
+
+  private readEnvConfig(): Partial<ClientConfig> {
+    let config = {};
+    if (process.env['TESTIT_CONFIG_FILE']) {
+      config = this.readConfigFile(process.env['TESTIT_CONFIG_FILE']);
+    }
+    return Client.mergeConfig(config, {
+      url: process.env['TESTIT_URL'],
+      privateToken: process.env['TESTIT_PRIVATE_TOKEN'],
+      projectId: process.env['TESTIT_PROJECT_ID'],
+      configurationId: process.env['TESTIT_CONFIGURATION_ID'],
+      testRunId: process.env['TESTIT_TEST_RUN_ID'],
+    });
+  }
+
+  private readConfigFile(path: string): Partial<ClientConfig> {
+    if (!existsSync(path)) {
+      throw new Error('Config file not found');
+    }
+    const config = JSON.parse(
+      readFileSync(path, { encoding: 'utf8' })
+    ) as Partial<ClientConfig>;
+    if (config.privateToken) {
+      console.warn('Private token is in config file, it is not secure');
+    }
+    return config;
+  }
+
+  static mergeConfig(
+    oldConfig: Partial<ClientConfig>,
+    newConfig: Partial<ClientConfig>
+  ): Partial<ClientConfig> {
+    return {
+      url: newConfig.url ?? oldConfig.url,
+      privateToken: newConfig.privateToken ?? oldConfig.privateToken,
+      projectId: newConfig.projectId ?? oldConfig.projectId,
+      configurationId: newConfig.configurationId ?? oldConfig.configurationId,
+      testRunId: newConfig.testRunId ?? oldConfig.testRunId,
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './types';

package/src/types/attachment.ts

@@ -0,0 +1,15 @@
+export interface AttachmentPut {
+  id: string;
+}
+
+export interface Attachment {
+  fileId: string;
+  type: string;
+  size: number;
+  name: string;
+  createDate?: string;
+  modifiedDate?: string;
+  createdById?: string;
+  modifiedById?: string;
+  id?: string;
+}

package/src/types/autotest.ts

@@ -0,0 +1,102 @@
+import { LabelPost, LabelShort } from './label';
+import { Link, LinkPost, LinkPut } from './link';
+import { AutotestStep } from './autotestStep';
+
+export interface AutotestPost {
+  globalId?: number;
+  isDeleted?: boolean;
+  id?: string;
+  createdDate?: string;
+  modifiedDate?: string;
+  createdById?: string;
+  modifiedById?: string;
+  mustBeApproved?: boolean;
+  externalId: string;
+  links?: LinkPost[];
+  projectId: string;
+  name: string;
+  namespace?: string;
+  classname?: string;
+  steps?: AutotestStep[];
+  setup?: AutotestStep[];
+  teardown?: AutotestStep[];
+  title?: string;
+  description?: string;
+  labels?: LabelPost[];
+}
+
+export interface AutotestPut {
+  id?: string;
+  externalId: string;
+  links?: LinkPost[];
+  projectId: string;
+  name: string;
+  namespace?: string;
+  classname?: string;
+  steps?: AutotestStep[];
+  setup?: AutotestStep[];
+  teardown?: AutotestStep[];
+  title?: string;
+  description?: string;
+  labels?: LabelPost[];
+}
+
+export interface Autotest {
+  globalId?: number;
+  isDeleted?: boolean;
+  id?: string;
+  createdDate?: string;
+  modifiedDate?: string;
+  createdById?: string;
+  modifiedById?: string;
+  mustBeApproved?: boolean;
+  externalId: string;
+  links?: LinkPut[];
+  projectId: string;
+  name: string;
+  namespace?: string;
+  classname?: string;
+  steps?: AutotestStep[];
+  setup?: AutotestStep[];
+  teardown?: AutotestStep[];
+  title?: string;
+  description?: string;
+  labels?: LabelPost[];
+}
+
+export interface AutotestGet {
+  externalId?: string;
+  links?: Link[];
+  projectId?: string;
+  name?: string;
+  namespace?: string;
+  classname?: string;
+  steps?: AutotestStep[];
+  setup?: AutotestStep[];
+  teardown: AutotestStep[];
+  global?: number;
+  createdDate?: string;
+  modifiedDate?: string;
+  createdById?: string;
+  modifiedById?: string;
+  labels?: LabelShort[];
+  id?: string;
+  isDeleted?: boolean;
+}
+
+export interface AutotestQuery {
+  projectId?: string;
+  externalId?: string;
+  globalId?: number;
+  namespace?: string;
+  isNamespaceNull?: boolean;
+  classname?: string;
+  isClassnameNull?: boolean;
+  isDeleted?: boolean;
+  labels?: string[];
+  skip?: number;
+  take?: number;
+  orderBy?: string;
+  searchField?: string;
+  searchValue?: string;
+}

package/src/types/autotestResults.ts

@@ -0,0 +1,23 @@
+import { AttachmentPut } from './attachment';
+import { LinkPost } from './link';
+import { OutcomeType } from './outcome';
+import { Parameters } from './parameters';
+import { AttachmentPutModelAutotestStepResults } from './stepResults';
+
+export interface AutotestResultsForTestRun {
+  configurationId: string;
+  links?: LinkPost[];
+  failureReasonName?: string;
+  autotestExternalId: string;
+  outcome: OutcomeType;
+  message?: string;
+  traces?: string;
+  startedOn?: string;
+  completeOn?: string;
+  duration?: number;
+  attachments?: AttachmentPut[];
+  parameters?: Parameters;
+  stepResults?: AttachmentPutModelAutotestStepResults[];
+  setupResults?: AttachmentPutModelAutotestStepResults[];
+  teardownResults?: AttachmentPutModelAutotestStepResults[];
+}

package/src/types/autotestStep.ts

@@ -0,0 +1,5 @@
+export interface AutotestStep {
+  title: string;
+  description?: string;
+  steps?: AutotestStep[];
+}

package/src/types/capabilities.ts

@@ -0,0 +1 @@
+export type Capabilities = Record<string, string>;

package/src/types/client.ts

@@ -0,0 +1,29 @@
+import {
+  Attachment,
+  Autotest,
+  AutotestPost,
+  AutotestPut,
+  AutotestQuery,
+  AutotestResultsForTestRun,
+  ClientConfig,
+  TestRunGet,
+  TestRunPost,
+  WorkItemId,
+} from '.';
+
+export interface IClient {
+  checkConnection(): Promise<void>;
+  getAutotest(query: AutotestQuery): Promise<Autotest[]>;
+  createAutotest(autotest: AutotestPost): Promise<Autotest>;
+  updateAutotest(autotest: AutotestPut): Promise<void>;
+  linkToWorkItem(autotestId: string, workItem: WorkItemId): Promise<void>;
+  createTestRun(testRun: TestRunPost): Promise<TestRunGet>;
+  startTestRun(testRunId: string): Promise<void>;
+  loadTestRunResults(
+    testRunId: string,
+    results: AutotestResultsForTestRun[]
+  ): Promise<string[]>;
+  completeTestRun(testRunId: string): Promise<void>;
+  getConfig(): ClientConfig;
+  loadAttachment(fileName: string): Promise<Attachment>;
+}

package/src/types/config.ts

@@ -0,0 +1,11 @@
+export interface ClientConfig {
+  url: string;
+  privateToken: string;
+  projectId: string;
+  configurationId: string;
+  testRunId?: string;
+}
+
+export interface ClientConfigWithFile extends ClientConfig {
+  configFile?: string;
+}

package/src/types/configuration.ts

@@ -0,0 +1,17 @@
+import { Capabilities } from './capabilities';
+
+export interface Configuration {
+  description?: string;
+  isActive?: boolean;
+  capabilities: Capabilities;
+  projectId?: string;
+  isDefault?: boolean;
+  name?: string;
+  createdDate?: string;
+  modifiedDate?: string;
+  createdById?: string;
+  modifiedById?: string;
+  globalId?: number;
+  id?: number;
+  isDeleted?: boolean;
+}

package/src/types/index.ts

@@ -0,0 +1,18 @@
+export * from './attachment';
+export * from './autotest';
+export * from './autotestResults';
+export * from './autotestStep';
+export * from './capabilities';
+export * from './client';
+export * from './config';
+export * from './configuration';
+export * from './label';
+export * from './link';
+export * from './outcome';
+export * from './parameters';
+export * from './properties';
+export * from './stepResults';
+export * from './tag';
+export * from './testResult';
+export * from './testRun';
+export * from './workItem';

package/src/types/label.ts

@@ -0,0 +1,8 @@
+export interface LabelShort {
+  globalId?: number;
+  name: string;
+}
+
+export interface LabelPost {
+  name: string;
+}

package/src/types/link.ts

@@ -0,0 +1,33 @@
+export type LinkType =
+  | 'Related'
+  | 'BlockedBy'
+  | 'Defect'
+  | 'Issue'
+  | 'Requirement'
+  | 'Repository';
+
+export interface LinkPost {
+  title?: string;
+  url: string;
+  description?: string;
+  type?: LinkType;
+  hasInfo?: boolean;
+}
+
+export interface LinkPut {
+  id?: string;
+  title?: string;
+  url: string;
+  description?: string;
+  type?: LinkType;
+  hasInfo?: boolean;
+}
+
+export interface Link {
+  id?: string;
+  title?: string;
+  url: string;
+  description?: string;
+  type?: LinkType;
+  hasInfo?: boolean;
+}

package/src/types/outcome.ts

@@ -0,0 +1,6 @@
+export type OutcomeType =
+  | 'Passed'
+  | 'Failed'
+  | 'Pending'
+  | 'Blocked'
+  | 'Skipped';

package/src/types/parameters.ts

@@ -0,0 +1 @@
+export type Parameters = Record<string, string>;

package/src/types/properties.ts

@@ -0,0 +1 @@
+export type Properties = Record<string, string>;

package/src/types/stepResults.ts

@@ -0,0 +1,15 @@
+import { AttachmentPut } from './attachment';
+import { OutcomeType } from './outcome';
+import { Parameters } from './parameters';
+
+export interface AttachmentPutModelAutotestStepResults {
+  title?: string;
+  description?: string;
+  startedOn?: string;
+  completedOn?: string;
+  duration?: number;
+  outcome?: OutcomeType;
+  stepResults?: AttachmentPutModelAutotestStepResults[];
+  attachments?: AttachmentPut[];
+  parameters?: Parameters;
+}

package/src/types/tag.ts

@@ -0,0 +1,3 @@
+export interface TagShort {
+  name: string;
+}

package/src/types/testPoint.ts

@@ -0,0 +1,9 @@
+export interface TestPointShort {
+  testSuiteId?: string;
+  id?: string;
+  testerId?: string;
+  workItemId?: string;
+  configurationId?: string;
+  status?: string;
+  lastTestResultId?: string;
+}

package/src/types/testResult.ts

@@ -0,0 +1,32 @@
+import { Attachment } from './attachment';
+import { AutotestGet } from './autotest';
+import { Configuration } from './configuration';
+import { Link } from './link';
+import { OutcomeType } from './outcome';
+import { Parameters } from './parameters';
+import { Properties } from './properties';
+import { TestPointShort } from './testPoint';
+
+export interface TestResultGet {
+  configuration?: Configuration;
+  autotest?: AutotestGet;
+  is?: string;
+  configurationId?: string;
+  workItemVersionId?: string;
+  autotestId?: string;
+  message?: string;
+  traces?: string;
+  startedOn?: string;
+  completedOn?: string;
+  runByUserId?: string;
+  stoppedByUserId?: string;
+  testPointId?: string;
+  testPoint?: TestPointShort;
+  testRunId?: string;
+  outcome?: OutcomeType;
+  comment?: string;
+  links?: Link[];
+  attachments?: Attachment[];
+  parameters?: Parameters;
+  properties?: Properties;
+}

package/src/types/testRun.ts

@@ -0,0 +1,27 @@
+import { TestResultGet } from './testResult';
+
+export type TestRunStateType =
+  | 'NotStarted'
+  | 'InProgress'
+  | 'Stopped'
+  | 'Completed';
+
+export interface TestRunPost {
+  projectId: string;
+  name?: string;
+}
+
+export interface TestRunGet {
+  startedOn?: string;
+  completedOn?: string;
+  stateName?: TestRunStateType;
+  projectId?: string;
+  testPlanId?: string;
+  testResults?: TestResultGet[];
+  createdDate?: string;
+  modifiedDate?: string;
+  createById?: string;
+  modifiedById?: string;
+  id: string;
+  name: string;
+}

package/src/types/workItem.ts

@@ -0,0 +1,3 @@
+export interface WorkItemId {
+  id: string;
+}

package/src/validation.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ClientConfig } from '.';
+
+const configSchema = z.object({
+  configurationId: z.string().uuid(),
+  privateToken: z.string(),
+  projectId: z.string().uuid(),
+  url: z.string().url(),
+  testRunId: z.string().uuid().optional(),
+});
+
+export function validateConfig(config: Partial<ClientConfig>): ClientConfig {
+  return configSchema.parse(config);
+}

package/test/client.test.ts

@@ -0,0 +1,191 @@
+import { Client } from '../src/client';
+import { ClientConfig } from '../src/types/config';
+
+jest.mock('fs', () => ({
+  existsSync: () => {
+    return true;
+  },
+  readFileSync: (path: string) => {
+    switch (path) {
+      case '/constructor/config':
+        return JSON.stringify({
+          url: 'http://file.com',
+        } as ClientConfig);
+      case '/cli/config':
+        return JSON.stringify({
+          configurationId: 'cliConfigConfigurationId',
+        } as ClientConfig);
+      case '/env/config':
+        return JSON.stringify({
+          projectId: 'envConfigProjectId',
+        } as ClientConfig);
+      default:
+        return {};
+    }
+  },
+}));
+
+describe('Client test', () => {
+  describe('Merge config', () => {
+    const baseConfig: ClientConfig = {
+      url: 'http://base.com',
+      projectId: 'baseProjectId',
+      configurationId: 'baseConfigurationId',
+      privateToken: 'basePrivateToken',
+      testRunId: 'baseTestRunId',
+    };
+
+    it('Merge url', () => {
+      const mergeUrl = 'http://merge.com';
+      const newConfig = Client.mergeConfig(baseConfig, { url: mergeUrl });
+
+      expect(newConfig).toEqual({ ...baseConfig, url: mergeUrl });
+    });
+
+    it('Merge project id', () => {
+      const mergeProjectId = 'mergeProjectId';
+      const newConfig = Client.mergeConfig(baseConfig, {
+        projectId: mergeProjectId,
+      });
+
+      expect(newConfig).toEqual({
+        ...baseConfig,
+        projectId: mergeProjectId,
+      });
+    });
+
+    it('Merge configuration id', () => {
+      const mergeConfigurationId = 'mergeConfigurationId';
+      const newConfig = Client.mergeConfig(baseConfig, {
+        configurationId: mergeConfigurationId,
+      });
+
+      expect(newConfig).toEqual({
+        ...baseConfig,
+        configurationId: mergeConfigurationId,
+      });
+    });
+
+    it('Merge private token', () => {
+      const mergePrivateToken = 'mergePrivateToken';
+      const newConfig = Client.mergeConfig(baseConfig, {
+        privateToken: mergePrivateToken,
+      });
+
+      expect(newConfig).toEqual({
+        ...baseConfig,
+        privateToken: mergePrivateToken,
+      });
+    });
+
+    it('Merge test run id', () => {
+      const mergeTestRunId = 'mergeTestRunId';
+      const newConfig = Client.mergeConfig(baseConfig, {
+        testRunId: mergeTestRunId,
+      });
+
+      expect(newConfig).toEqual({
+        ...baseConfig,
+        testRunId: mergeTestRunId,
+      });
+    });
+  });
+
+  describe('Configuration loading', () => {
+    let oldEnv = process.env;
+    let oldArgs = process.argv;
+
+    beforeEach(() => {
+      process.env = { ...oldEnv };
+      process.argv = [...oldArgs];
+    });
+
+    afterAll(() => {
+      process.env = oldEnv;
+      process.argv = oldArgs;
+    });
+
+    const config: ClientConfig = {
+      url: 'http://test.com',
+      configurationId: 'configurationId',
+      privateToken: 'privateToken',
+      projectId: 'projectId',
+      testRunId: 'testRunId',
+    };
+    it('Constructor config', () => {
+      const client = new Client(config);
+
+      expect(client.getConfig()).toEqual(config);
+    });
+
+    it('Constructor config with file', () => {
+      const client = new Client({
+        ...config,
+        configFile: '/constructor/config',
+      });
+
+      expect(client.getConfig()).toEqual({ ...config, url: 'http://file.com' });
+    });
+
+    it('Env config', () => {
+      const envConfig: ClientConfig = {
+        url: 'http://env.com',
+        configurationId: 'envConfigurationId',
+        privateToken: 'envPrivateToken',
+        projectId: 'envProjectId',
+        testRunId: 'envTestRunId',
+      };
+      process.env['TESTIT_URL'] = envConfig.url;
+      process.env['TESTIT_PRIVATE_TOKEN'] = envConfig.privateToken;
+      process.env['TESTIT_PROJECT_ID'] = envConfig.projectId;
+      process.env['TESTIT_CONFIGURATION_ID'] = envConfig.configurationId;
+      process.env['TESTIT_TEST_RUN_ID'] = envConfig.testRunId;
+      const client = new Client(config);
+
+      expect(client.getConfig()).toEqual(envConfig);
+    });
+
+    it('Env config with file', () => {
+      process.env['TESTIT_CONFIG_FILE'] = '/env/config';
+      const client = new Client(config);
+
+      expect(client.getConfig()).toEqual({
+        ...config,
+        projectId: 'envConfigProjectId',
+      });
+    });
+
+    it('Cli args config', () => {
+      const cliConfig: ClientConfig = {
+        url: 'http://cli.com',
+        configurationId: 'cliConfigurationId',
+        privateToken: 'cliPrivateToken',
+        projectId: 'cliProjectId',
+        testRunId: 'cliTestRunId',
+      };
+      process.argv.push(
+        `--testitUrl=${cliConfig.url}`,
+        `--testitPrivateToken`,
+        cliConfig.privateToken!,
+        `--testitProjectId=${cliConfig.projectId}`,
+        `--testitConfigurationId`,
+        cliConfig.configurationId!,
+        `--testitTestRunId=${cliConfig.testRunId}`
+      );
+      const client = new Client(config);
+
+      expect(client.getConfig()).toEqual(cliConfig);
+    });
+
+    it('Cli args config with config file', () => {
+      process.argv.push(`--testitConfig`, '/cli/config');
+
+      const client = new Client(config);
+
+      expect(client.getConfig()).toEqual({
+        ...config,
+        configurationId: 'cliConfigConfigurationId',
+      });
+    });
+  });
+});

package/test/validation.test.ts

@@ -0,0 +1,68 @@
+import { v4 } from 'uuid';
+import { ClientConfig } from '../src/types';
+import { validateConfig } from '../src/validation';
+
+describe('Config validation test', () => {
+  it('should return valid config', () => {
+    const config: Partial<ClientConfig> = {
+      projectId: v4(),
+      configurationId: v4(),
+      privateToken: 'random token',
+      url: 'http://localhost:5000',
+    };
+    const result = validateConfig(config);
+    expect(result).toEqual(config);
+  });
+
+  it('should return valid config with test run id', () => {
+    const config: Partial<ClientConfig> = {
+      projectId: v4(),
+      configurationId: v4(),
+      privateToken: 'random token',
+      url: 'http://localhost:5000',
+      testRunId: v4(),
+    };
+    const result = validateConfig(config);
+    expect(result).toEqual(config);
+  });
+
+  it('should thrown without project id', () => {
+    const config: Partial<ClientConfig> = {
+      configurationId: v4(),
+      privateToken: 'random token',
+      url: 'http://localhost:5000',
+      testRunId: v4(),
+    };
+    expect(() => validateConfig(config)).toThrow();
+  });
+
+  it('should thrown without configuration id', () => {
+    const config: Partial<ClientConfig> = {
+      projectId: v4(),
+      privateToken: 'random token',
+      url: 'http://localhost:5000',
+      testRunId: v4(),
+    };
+    expect(() => validateConfig(config)).toThrow();
+  });
+
+  it('should thrown without token', () => {
+    const config: Partial<ClientConfig> = {
+      projectId: v4(),
+      configurationId: v4(),
+      url: 'http://localhost:5000',
+      testRunId: v4(),
+    };
+    expect(() => validateConfig(config)).toThrow();
+  });
+
+  it('should thrown without url', () => {
+    const config: Partial<ClientConfig> = {
+      projectId: v4(),
+      configurationId: v4(),
+      privateToken: 'random token',
+      testRunId: v4(),
+    };
+    expect(() => validateConfig(config)).toThrow();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,102 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2017" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+    /* Modules */
+    "module": "CommonJS" /* Specify what module code is generated. */,
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src"],
+  "exclude": ["*.test.*"]
+}