// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT License.

'use strict';

// tslint:disable:max-func-body-length

import { strictEqual } from 'assert';

import { expect } from 'chai';

import { spawnSync } from 'child_process';

import * as typeMoq from 'typemoq';

import { Product } from '../../client/common/types';

import { getNamesAndValues } from '../../client/common/utils/enum';

import { IServiceContainer } from '../../client/ioc/types';

import { ArgumentsHelper } from '../../client/testing/common/argumentsHelper';

import { UNIT_TEST_PRODUCTS } from '../../client/testing/common/constants';

import { ArgumentsService as NoseTestArgumentsService } from '../../client/testing/nosetest/services/argsService';

import { ArgumentsService as PyTestArgumentsService } from '../../client/testing/pytest/services/argsService';

import { IArgumentsHelper, IArgumentsService } from '../../client/testing/types';

import { ArgumentsService as UnitTestArgumentsService } from '../../client/testing/unittest/services/argsService';

import { PYTHON_PATH } from '../common';

import { TEST_TIMEOUT } from '../constants';

suite('ArgsService: Common', () => {

UNIT_TEST_PRODUCTS.forEach((product) => {

const productNames = getNamesAndValues(Product);

const productName = productNames.find((item) => item.value === product)!.name;

suite(productName, () => {

let argumentsService: IArgumentsService;

let moduleName = '';

let expectedWithArgs: string[] = [];

let expectedWithoutArgs: string[] = [];

setup(function () {

// Take the spawning of process into account.

// tslint:disable-next-line:no-invalid-this

this.timeout(TEST_TIMEOUT * 2);

const serviceContainer = typeMoq.Mock.ofType<IServiceContainer>();

const argsHelper = new ArgumentsHelper();

serviceContainer

.setup((s) => s.get(typeMoq.It.isValue(IArgumentsHelper), typeMoq.It.isAny()))

.returns(() => argsHelper);

switch (product) {

case Product.unittest: {

argumentsService = new UnitTestArgumentsService(serviceContainer.object);

moduleName = 'unittest';

break;

}

case Product.nosetest: {

argumentsService = new NoseTestArgumentsService(serviceContainer.object);

moduleName = 'nose';

break;

}

case Product.pytest: {

moduleName = 'pytest';

argumentsService = new PyTestArgumentsService(serviceContainer.object);

break;

}

default: {

throw new Error('Unrecognized Test Framework');

}

}

expectedWithArgs = getOptions(product, moduleName, true);

expectedWithoutArgs = getOptions(product, moduleName, false);

});

test('Check for new/unrecognized options with values', () => {

const options = argumentsService.getKnownOptions();

const optionsNotFound = expectedWithArgs.filter((item) => options.withArgs.indexOf(item) === -1);

strictEqual(optionsNotFound.length, 0, `unhandled flags: ${optionsNotFound.join(',')}`);

});

test('Check for new/unrecognized options without values', () => {

const options = argumentsService.getKnownOptions();

const optionsNotFound = expectedWithoutArgs.filter((item) => options.withoutArgs.indexOf(item) === -1);

strictEqual(optionsNotFound.length, 0, `unhandled flags: ${optionsNotFound.join(',')}`);

});

test('Test getting value for an option with a single value', () => {

for (const option of expectedWithArgs) {

const args = [

'--some-option-with-a-value',

'1234',

'--another-value-with-inline=1234',

option,

'abcd'

];

const value = argumentsService.getOptionValue(args, option);

expect(value).to.equal('abcd');

}

});

test('Test getting value for an option with a multiple value', () => {

for (const option of expectedWithArgs) {

const args = [

'--some-option-with-a-value',

'1234',

'--another-value-with-inline=1234',

option,

'abcd',

option,

'xyz'

];

const value = argumentsService.getOptionValue(args, option);

expect(value).to.deep.equal(['abcd', 'xyz']);

}

});

test('Test filtering of arguments', () => {

const args: string[] = [];

const knownOptions = argumentsService.getKnownOptions();

const argumentsToRemove: string[] = [];

const expectedFilteredArgs: string[] = [];

// Generate some random arguments.

for (let i = 0; i < 5; i += 1) {

args.push(knownOptions.withArgs[i], `Random Value ${i}`);

args.push(knownOptions.withoutArgs[i]);

if (i % 2 === 0) {

argumentsToRemove.push(knownOptions.withArgs[i], knownOptions.withoutArgs[i]);

} else {

expectedFilteredArgs.push(knownOptions.withArgs[i], `Random Value ${i}`);

expectedFilteredArgs.push(knownOptions.withoutArgs[i]);

}

}

const filteredArgs = argumentsService.filterArguments(args, argumentsToRemove);

expect(filteredArgs).to.be.deep.equal(expectedFilteredArgs);

});

});

});

});

function getOptions(product: Product, moduleName: string, withValues: boolean) {

const result = spawnSync(PYTHON_PATH, ['-m', moduleName, '-h']);

const output = result.stdout.toString();

// Our regex isn't the best, so lets exclude stuff that shouldn't be captured.

const knownOptionsWithoutArgs: string[] = [];

const knownOptionsWithArgs: string[] = [];

if (product === Product.pytest) {

knownOptionsWithArgs.push(...['-c', '-k', '-p', '-r']);

}

if (withValues) {

return getOptionsWithArguments(output)

.concat(...knownOptionsWithArgs)

.filter((item) => knownOptionsWithoutArgs.indexOf(item) === -1)

.sort();

} else {

return (

getOptionsWithoutArguments(output)

.concat(...knownOptionsWithoutArgs)

.filter((item) => knownOptionsWithArgs.indexOf(item) === -1)

// In pytest, any option beginning with --log- is known to have args.

.filter((item) => (product === Product.pytest ? !item.startsWith('--log-') : true))

.sort()

);

}

}

function getOptionsWithoutArguments(output: string) {

return getMatches('\\s{1,}(-{1,2}[A-Za-z0-9-]+)(?:,|\\s{2,})', output);

}

function getOptionsWithArguments(output: string) {

return getMatches('\\s{1,}(-{1,2}[A-Za-z0-9-]+)(?:=|\\s{0,1}[A-Z])', output);

}

// tslint:disable-next-line:no-any

function getMatches(pattern: any, str: string) {

const matches: string[] = [];

const regex = new RegExp(pattern, 'gm');

let result: RegExpExecArray | null = regex.exec(str);

while (result !== null) {

if (result.index === regex.lastIndex) {

regex.lastIndex += 1;

}

matches.push(result[1].trim());

result = regex.exec(str);

}

return matches

.sort()

.reduce<string[]>((items, item) => (items.indexOf(item) === -1 ? items.concat([item]) : items), []);

}