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

// Licensed under the MIT License.

'use strict';

// tslint:disable:no-any

import { expect } from 'chai';

import * as fs from 'fs';

import * as glob from 'glob';

import * as path from 'path';

import { anyString, anything, instance, mock, when } from 'ts-mockito';

import { buildApi } from '../client/api';

import { ApplicationEnvironment } from '../client/common/application/applicationEnvironment';

import { IApplicationEnvironment } from '../client/common/application/types';

import { EXTENSION_ROOT_DIR } from '../client/common/constants';

import { ExperimentsManager } from '../client/common/experiments';

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

import { DebugAdapterDescriptorFactory } from '../client/debugger/extension/adapter/factory';

import { IDebugAdapterDescriptorFactory } from '../client/debugger/extension/types';

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

suite('Extension API Debugger', () => {

const expectedLauncherPath = `${EXTENSION_ROOT_DIR.fileToCommandArgument()}/pythonFiles/ptvsd_launcher.py`;

const ptvsdPath = path.join('path', 'to', 'ptvsd');

const ptvsdHost = 'somehost';

const ptvsdPort = 12345;

let experimentsManager: IExperimentsManager;

let debugAdapterFactory: IDebugAdapterDescriptorFactory;

setup(() => {

experimentsManager = mock(ExperimentsManager);

debugAdapterFactory = mock(DebugAdapterDescriptorFactory);

});

function mockInExperiment(host: string, port: number, wait: boolean) {

when(experimentsManager.inExperiment(anyString())).thenReturn(true);

when(debugAdapterFactory.useNewPtvsd(anyString())).thenResolve(true);

when(debugAdapterFactory.getPtvsdPath()).thenReturn(ptvsdPath);

if (wait) {

when(debugAdapterFactory.getRemotePtvsdArgs(anything())).thenReturn([

'--host',

host,

'--port',

port.toString(),

'--wait'

]);

} else {

when(debugAdapterFactory.getRemotePtvsdArgs(anything())).thenReturn([

'--host',

host,

'--port',

port.toString()

]);

}

}

function mockNotInExperiment(host: string, port: number, wait: boolean) {

when(experimentsManager.inExperiment(anyString())).thenReturn(false);

when(debugAdapterFactory.useNewPtvsd(anyString())).thenResolve(false);

if (wait) {

when(debugAdapterFactory.getRemotePtvsdArgs(anything())).thenReturn([

'--default',

'--host',

host,

'--port',

port.toString(),

'--wait'

]);

} else {

when(debugAdapterFactory.getRemotePtvsdArgs(anything())).thenReturn([

'--default',

'--host',

host,

'--port',

port.toString()

]);

}

}

test('Test debug launcher args (no-wait and not in experiment)', async () => {

const waitForAttach = false;

mockNotInExperiment(ptvsdHost, ptvsdPort, waitForAttach);

const args = await buildApi(

Promise.resolve(),

instance(experimentsManager),

instance(debugAdapterFactory)

).debug.getRemoteLauncherCommand(ptvsdHost, ptvsdPort, waitForAttach);

const expectedArgs = [expectedLauncherPath, '--default', '--host', ptvsdHost, '--port', ptvsdPort.toString()];

expect(args).to.be.deep.equal(expectedArgs);

});

test('Test debug launcher args (no-wait and in experiment)', async () => {

const waitForAttach = false;

mockInExperiment(ptvsdHost, ptvsdPort, waitForAttach);

const args = await buildApi(

Promise.resolve(),

instance(experimentsManager),

instance(debugAdapterFactory)

).debug.getRemoteLauncherCommand(ptvsdHost, ptvsdPort, waitForAttach);

const expectedArgs = [ptvsdPath, '--host', ptvsdHost, '--port', ptvsdPort.toString()];

expect(args).to.be.deep.equal(expectedArgs);

});

test('Test debug launcher args (wait and not in experiment)', async () => {

const waitForAttach = true;

mockNotInExperiment(ptvsdHost, ptvsdPort, waitForAttach);

const args = await buildApi(

Promise.resolve(),

instance(experimentsManager),

instance(debugAdapterFactory)

).debug.getRemoteLauncherCommand(ptvsdHost, ptvsdPort, waitForAttach);

const expectedArgs = [

expectedLauncherPath,

'--default',

'--host',

ptvsdHost,

'--port',

ptvsdPort.toString(),

'--wait'

];

expect(args).to.be.deep.equal(expectedArgs);

});

test('Test debug launcher args (wait and in experiment)', async () => {

const waitForAttach = true;

mockInExperiment(ptvsdHost, ptvsdPort, waitForAttach);

const args = await buildApi(

Promise.resolve(),

instance(experimentsManager),

instance(debugAdapterFactory)

).debug.getRemoteLauncherCommand(ptvsdHost, ptvsdPort, waitForAttach);

const expectedArgs = [ptvsdPath, '--host', ptvsdHost, '--port', ptvsdPort.toString(), '--wait'];

expect(args).to.be.deep.equal(expectedArgs);

});

});

suite('Extension version tests', () => {

let version: string;

let applicationEnvironment: IApplicationEnvironment;

const branchName = process.env.CI_BRANCH_NAME;

suiteSetup(async function() {

// Skip the entire suite if running locally

if (!branchName) {

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

return this.skip();

}

});

setup(() => {

applicationEnvironment = new ApplicationEnvironment(undefined as any, undefined as any, undefined as any);

version = applicationEnvironment.packageJson.version;

});

test('If we are running a pipeline in the master branch, the extension version in `package.json` should have the "-dev" suffix', async function() {

if (branchName !== 'master') {

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

return this.skip();

}

return expect(

version.endsWith('-dev'),

'When running a pipeline in the master branch, the extension version in package.json should have the -dev suffix'

).to.be.true;

});

test('If we are running a pipeline in the release branch, the extension version in `package.json` should not have the "-dev" suffix', async function() {

if (!branchName!.startsWith('release')) {

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

return this.skip();

}

return expect(

version.endsWith('-dev'),

'When running a pipeline in the release branch, the extension version in package.json should not have the -dev suffix'

).to.be.false;

});

});

suite('Extension localization files', () => {

test('Load localization file', () => {

const filesFailed: string[] = [];

glob.sync('package.nls.*.json', { sync: true, cwd: EXTENSION_ROOT_DIR }).forEach(localizationFile => {

try {

JSON.parse(fs.readFileSync(path.join(EXTENSION_ROOT_DIR, localizationFile)).toString());

} catch {

filesFailed.push(localizationFile);

}

});

expect(filesFailed).to.be.lengthOf(0, `Failed to load JSON for ${filesFailed.join(', ')}`);

});

});