1.2.0 (#41)

1.2.0

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jstestadapter",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "",
   "bundledDependencies": [
     "rewire",
@@ -26,7 +26,8 @@
     "lint:test": "tslint --project ./test/JSTest.Runner.UnitTests/tsconfig.json",
     "build:Debug": "./node_modules/.bin/tsc -p ./src/JSTest.Runner/tsconfig.json",
     "build:Release": "./node_modules/.bin/tsc -p ./src/JSTest.Runner/tsconfig.json --outDir ./src/JSTest.Runner/bin/Release",
-    "build:test": "./node_modules/.bin/tsc -p ./test/JSTest.Runner.UnitTests/tsconfig.json",
+    "tsc:test": "node_modules/.bin/tsc -p ./test/JSTest.Runner.UnitTests/tsconfig.json",
+    "build:test": "npm run lint:test && npm run tsc:test",
     "build": "npm run build:Debug",
     "test": "npm run build:test && node ./node_modules/mocha/bin/mocha -r source-map-support/register ./test/JSTest.Runner.UnitTests/bin/test/**/*Tests.js",
     "test:debug": "npm run build:test && node --inspect-brk=9229 ./node_modules/mocha/bin/_mocha -r source-map-support/register ./test/JSTest.Runner.UnitTests/bin/test/**/*Tests.js"

src/JSTest.Runner/Constants.ts

@@ -1,4 +1,5 @@
+// tslint:disable:variable-name
 export namespace Constants {
-    export const executorURI: string = 'executor://JSTestAdapter/v1';
-    export const messageProtocolVersion: number = 1;
+    export const ExecutorURI: string = 'executor://JSTestAdapter/v1';
+    export const MessageProtocolVersion: number = 1;
 }

src/JSTest.Runner/Environment/Browser/Environment.ts

@@ -32,12 +32,4 @@ export class Environment implements IEnvironment {
     public exit(exitCode: number) {
         throw new Exception('Not implemented', ExceptionType.NotImplementedException);
     }
-
-    public setupGlobalLogger() {
-        throw new Exception('Not implemented', ExceptionType.NotImplementedException);
-    }
-
-    public reinitializeConsoleLogger() {
-        throw new Exception('Not implemented', ExceptionType.NotImplementedException);
-    }
 }

src/JSTest.Runner/Environment/Node/EventDispatcher.ts

@@ -13,6 +13,7 @@ export class EventDispatcher extends BaseEventDispatcher {
     constructor() {
         super();
         this.events = new EventEmitter();
+        this.events.setMaxListeners(20);
     }
 
     public subscribe(eventId: string, callback: IEventHandler<IEventArgs>): void {

src/JSTest.Runner/ObjectModel/Attachment.ts

@@ -4,8 +4,8 @@ export class Attachment implements ISerializable {
     private uri: string;
     private description: string;
 
-    constructor(uri: string, description: string) {
-        this.uri = uri;
+    constructor(url: string, description: string) {
+        this.uri = this.getFileUrl(url);
         this.description = description;
     }
 
@@ -15,4 +15,15 @@ export class Attachment implements ISerializable {
             Description: this.description
         };
     }
+
+    private getFileUrl(url: string): string {
+        let pathName = url.replace(/\\/g, '/');
+
+        // Windows drive letter must be prefixed with a slash
+        if (pathName[0] !== '/') {
+            pathName = '/' + pathName;
+        }
+
+        return encodeURI('file://' + pathName);
+    }
 }

src/JSTest.Runner/ObjectModel/JSTestSettings.ts

@@ -1,14 +1,15 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { TestFrameworks } from './TestFramework';
 import { IEnvironment } from '../Environment/IEnvironment';
 import { Exception, ExceptionType } from '../Exceptions';
+import { TestFrameworks } from './TestFramework';
 
 export class JSTestSettings {
     // tslint:disable:variable-name
-    public JavaScriptTestFramework: TestFrameworks;
-    public TestFrameworkConfigJson: JSON;
-    public AttachmentsFolder: string;
+    public readonly JavaScriptTestFramework: TestFrameworks;
+    public readonly TestFrameworkConfigJson: JSON;
+    public readonly AttachmentsFolder: string;
+    public readonly CoverageEnabled: boolean;
 
     constructor(json: any, environment: IEnvironment) {
         this.JavaScriptTestFramework = -1;
@@ -25,19 +26,28 @@ export class JSTestSettings {
                 ExceptionType.UnSupportedTestFramework);
         }
 
-        if (json.TestFrameworkConfigJson !== null && json.TestFrameworkConfigJson !== '') {
+        if (json.TestFrameworkConfigJson && json.TestFrameworkConfigJson !== null && json.TestFrameworkConfigJson !== '') {
             try {
                 this.TestFrameworkConfigJson = JSON.parse(json.TestFrameworkConfigJson);
             } catch (e) {
                 throw new Exception('Invalid TestFrameworkConfigJson: ' + e.message, ExceptionType.InvalidJSONException);
             }
         } else {
-            this.TestFrameworkConfigJson = JSON.parse('{}');
+            this.TestFrameworkConfigJson = <any> {};
         }
 
-        let attachmentsFolder = json.AttachmentsFolder;
+        this.CoverageEnabled = json.CodeCoverageEnabled === true;
+
+        // Set attachments folder and environment variable
+        // TODO: we should probably get the env key from jstestcontext package
+        /* tslint:disable:no-string-literal max-line-length */
+        process.env['JSTEST_RESULTS_DIRECTORY'] = this.AttachmentsFolder = this.createAttachmentsFolder(json.AttachmentsFolder, environment.getTempDirectory());
+    }
+
+    private createAttachmentsFolder(baseAttachmentsFolder: string, tempDirectory: string): string {
+        let attachmentsFolder = baseAttachmentsFolder;
         if (!attachmentsFolder) {
-            attachmentsFolder = environment.getTempDirectory();
+            attachmentsFolder = tempDirectory;
         }
 
         if (!fs.existsSync(attachmentsFolder)) {
@@ -67,12 +77,6 @@ export class JSTestSettings {
             fs.mkdirSync(attachmentsFolder);
         }
 
-        // Set attachments folder
-        this.AttachmentsFolder = attachmentsFolder;
-
-        // Set environment variable
-        // TODO: we should probably get the env key from jstestcontext package
-        /* tslint:disable:no-string-literal */
-        process.env['JSTEST_RESULTS_DIRECTORY'] = attachmentsFolder;
+        return attachmentsFolder;
     }
 }

src/JSTest.Runner/ObjectModel/Message.ts

@@ -1,5 +1,6 @@
 import { MessageType } from '.';
 import { Exception, ExceptionType} from '../Exceptions';
+import { Constants } from '../Constants';
 
 export class Message {
     /* These variables serialize to a JSON that will be deserialized
@@ -13,6 +14,8 @@ export class Message {
     constructor(messageType: MessageType, payload: any, version?: number) {
         if (version) {
             this.Version = version;
+        } else {
+            this.Version = Constants.MessageProtocolVersion;
         }
 
         this.MessageType = messageType;

src/JSTest.Runner/ObjectModel/MessageType.ts

@@ -11,5 +11,6 @@ export enum MessageType {
     ConsoleMessage = 'JSTest.ConsoleMessage',
     StartTestExecutionWithSources = 'JSTest.StartWithSources',
     StartTestExecutionWithTests = 'JSTest.StartWithTests',
-    StartDiscovery = 'JSTest.StartDiscovery'
+    StartDiscovery = 'JSTest.StartDiscovery',
+    RunAttachments = 'JSTest.RunAttachments'
 }

src/JSTest.Runner/ObjectModel/Payloads/TestRunAttachmentsPayload.ts

@@ -0,0 +1,5 @@
+import { AttachmentSet } from '../AttachmentSet';
+
+export interface TestRunAttachmentsPayload {
+    Attachments: Array<AttachmentSet>;
+} 

src/JSTest.Runner/ObjectModel/Payloads/index.ts

@@ -1,3 +1,4 @@
 export { TestMessagePayload } from './TestMessagePayload';
+export { TestRunAttachmentsPayload } from './TestRunAttachmentsPayload';
 export { TestCaseEndEventArgs, TestCaseFoundEventArgs, TestCaseStartEventArgs } from './TestRunEventArgs';
-export { StartDiscoveryPayload, StartExecutionWithSourcesPayload, StartExecutionWithTestsPayload } from './TestRunRequestPayload';
+export { StartDiscoveryPayload, StartExecutionWithSourcesPayload, StartExecutionWithTestsPayload } from './TestRunRequestPayload';

src/JSTest.Runner/ObjectModel/TestFramework/ITestFramework.ts

@@ -1,14 +1,15 @@
-import { EnvironmentType } from '../Common/EnvironmentType';
-import { ITestFrameworkEvents } from './ITestFrameworkEvents';
 import { TestCase } from '../Common';
+import { EnvironmentType } from '../Common/EnvironmentType';
+import { ITestFrameworkEvents, TestFrameworkOptions } from './';
 
 export interface ITestFramework {
     readonly environmentType: EnvironmentType;
     readonly testFrameworkEvents: ITestFrameworkEvents;
     readonly canHandleMultipleSources: boolean;
     readonly supportsJsonOptions: boolean;
+    readonly supportsCodeCoverage: boolean;
 
-    initialize(): void;
+    initialize(options: TestFrameworkOptions): void;
     startExecutionWithSources(sources: Array<string>, options: JSON): void;
     startExecutionWithTests(sources: Array<string>, tests: Map<string, TestCase>, options: JSON): void;
     startDiscovery(sources: Array<string>): void;

src/JSTest.Runner/ObjectModel/TestFramework/ITestFrameworkEvents.ts

@@ -1,4 +1,4 @@
-import { TestSpecEventArgs, TestSuiteEventArgs, TestSessionEventArgs, TestErrorMessageEventArgs } from '.';
+import { TestSpecEventArgs, TestSuiteEventArgs, TestSessionEventArgs, TestErrorMessageEventArgs, TestRunAttachmentEventArgs} from '.';
 import { IEvent } from '../Common';
 
 export interface ITestFrameworkEvents {
@@ -9,4 +9,5 @@ export interface ITestFrameworkEvents {
     onTestSessionStart: IEvent<TestSessionEventArgs>;
     onTestSessionEnd: IEvent<TestSessionEventArgs>;
     onErrorMessage: IEvent<TestErrorMessageEventArgs>;
+    onRunAttachment: IEvent<TestRunAttachmentEventArgs>;
 }

src/JSTest.Runner/ObjectModel/TestFramework/TestFrameworkCriteria.ts

@@ -0,0 +1,4 @@
+export interface TestFrameworkCriteria {
+    RunAttachmentsDirectory: string;
+    CollectCoverage: boolean;
+}

src/JSTest.Runner/ObjectModel/TestFramework/TestFrameworkEventArgs.ts

@@ -1,5 +1,6 @@
 import { TestCase, TestOutcome, IEventArgs } from '../Common';
 import { FailedExpectation } from '.';
+import { AttachmentSet } from '..';
 
 interface BaseTestEventArgs extends IEventArgs {
     StartTime: Date;
@@ -38,4 +39,8 @@ export class TestSessionEventArgs implements BaseTestEventArgs {
 
 export interface TestErrorMessageEventArgs {
     Message: string;
+}
+
+export interface TestRunAttachmentEventArgs {
+    AttachmentCollection: Array<AttachmentSet>;
 }

src/JSTest.Runner/ObjectModel/TestFramework/index.ts

@@ -1,5 +1,7 @@
-export { ITestFramework } from './ITestFramework';
-export { TestSpecEventArgs, TestSessionEventArgs, TestSuiteEventArgs, TestErrorMessageEventArgs } from './TestFrameworkEventArgs';
 export { FailedExpectation } from './FailedExpectation';
+export { ITestFramework } from './ITestFramework';
 export { ITestFrameworkEvents } from './ITestFrameworkEvents';
-export { TestFrameworks } from './TestFrameworks';
+export { TestErrorMessageEventArgs, TestSessionEventArgs, TestSpecEventArgs,
+         TestSuiteEventArgs, TestRunAttachmentEventArgs } from './TestFrameworkEventArgs';
+export { TestFrameworkCriteria as TestFrameworkOptions } from './TestFrameworkCriteria';
+export { TestFrameworks } from './TestFrameworks';

src/JSTest.Runner/TestRunner/ExecutionManagers/BaseExecutionManager.ts

@@ -1,20 +1,24 @@
 import { IEnvironment } from '../../Environment/IEnvironment';
-import { MessageSender } from '../MessageSender';
-import { TestFrameworkFactory } from '../TestFrameworks/TestFrameworkFactory';
+import { Exception, ExceptionType } from '../../Exceptions';
+import { JSTestSettings } from '../../ObjectModel';
 import { IEvent, IEventArgs } from '../../ObjectModel/Common';
+import { EqtTrace } from '../../ObjectModel/EqtTrace';
+import { ITestFramework, TestFrameworks } from '../../ObjectModel/TestFramework';
+import { MessageSender } from '../MessageSender';
 import { TestFrameworkEventHandlers } from '../TestFrameworks/TestFrameworkEventHandlers';
+import { TestFrameworkFactory } from '../TestFrameworks/TestFrameworkFactory';
 import { TestSessionManager } from './TestSessionManager';
-import { TestFrameworks, ITestFramework } from '../../ObjectModel/TestFramework';
-import { Exception, ExceptionType } from '../../Exceptions';
-import { EqtTrace } from '../../ObjectModel/EqtTrace';
 
 export abstract class BaseExecutionManager {
     protected readonly environment: IEnvironment;
     protected readonly messageSender: MessageSender;
     protected readonly testFrameworkFactory: TestFrameworkFactory;
     protected readonly onComplete: IEvent<IEventArgs>;
     protected readonly testSessionManager: TestSessionManager;
-
+
+    protected readonly abstract jsTestSettings: JSTestSettings;
+    protected readonly abstract testFramework: TestFrameworks;
+
     protected abstract testFrameworkEventHandlers: TestFrameworkEventHandlers;
 
     constructor(environment: IEnvironment, messageSender: MessageSender, testFramework: TestFrameworks) {
@@ -47,7 +51,10 @@ export abstract class BaseExecutionManager {
     protected createTestFramework(framework: TestFrameworks): ITestFramework {
         const testFrameworkInstance = this.testFrameworkFactory.createTestFramework(framework);
         try {
-            testFrameworkInstance.initialize();
+            testFrameworkInstance.initialize({
+                RunAttachmentsDirectory: this.jsTestSettings.AttachmentsFolder,
+                CollectCoverage: this.jsTestSettings.CoverageEnabled
+            });
         } catch (e) {
             EqtTrace.error(`BaseExecutionManager: error initializing test framework`, e);
             throw new Exception('Error initializing test framework: ' + e.message, ExceptionType.TestFrameworkError);

src/JSTest.Runner/TestRunner/ExecutionManagers/DiscoveryManager.ts

@@ -1,14 +1,14 @@
-import { ITestFramework, TestSessionEventArgs, TestSpecEventArgs, TestFrameworks,
-         TestErrorMessageEventArgs } from '../../ObjectModel/TestFramework';
 import { IEnvironment } from '../../Environment/IEnvironment';
+import { JSTestSettings, TestMessageLevel } from '../../ObjectModel';
+import { ITestFramework, TestErrorMessageEventArgs, TestFrameworks, TestSessionEventArgs,
+         TestSpecEventArgs } from '../../ObjectModel/TestFramework';
 import { MessageSender } from '../MessageSender';
 import { TestFrameworkEventHandlers } from '../TestFrameworks/TestFrameworkEventHandlers';
 import { BaseExecutionManager } from './BaseExecutionManager';
-import { TestMessageLevel, JSTestSettings } from '../../ObjectModel';
 
 export class DiscoveryManager extends BaseExecutionManager {
-    private jsTestSettings: JSTestSettings;
-    private testFramework: TestFrameworks;
+    protected readonly jsTestSettings: JSTestSettings;
+    protected readonly testFramework: TestFrameworks;
 
     constructor(environment: IEnvironment, messageSender: MessageSender, jsTestSettings: JSTestSettings) {
         super(environment, messageSender, jsTestSettings.JavaScriptTestFramework);

src/JSTest.Runner/TestRunner/ExecutionManagers/ExecutionManager.ts

@@ -1,19 +1,22 @@
-import * as path from 'path';
 import * as fs from 'fs';
-import { ITestFramework, TestSessionEventArgs, TestSpecEventArgs, TestFrameworks,
-         TestErrorMessageEventArgs } from '../../ObjectModel/TestFramework';
-import { TestMessageLevel, TestResult, JSTestSettings, AttachmentSet } from '../../ObjectModel';
+import * as path from 'path';
+import { IEnvironment } from '../../Environment/IEnvironment';
+import { AttachmentSet, JSTestSettings, TestMessageLevel, TestResult } from '../../ObjectModel';
 import { TestCase } from '../../ObjectModel/Common';
 import { EqtTrace } from '../../ObjectModel/EqtTrace';
-import { IEnvironment } from '../../Environment/IEnvironment';
+import {
+    ITestFramework, TestErrorMessageEventArgs, TestFrameworks,
+    TestSessionEventArgs, TestSpecEventArgs, TestRunAttachmentEventArgs
+} from '../../ObjectModel/TestFramework';
 import { TimeSpan } from '../../Utils/TimeUtils';
 import { MessageSender } from '../MessageSender';
-import { BaseExecutionManager } from './BaseExecutionManager';
 import { TestFrameworkEventHandlers } from '../TestFrameworks/TestFrameworkEventHandlers';
+import { BaseExecutionManager } from './BaseExecutionManager';
 
 export class ExecutionManager extends BaseExecutionManager {
-    private jsTestSettings: JSTestSettings;
-    private testFramework: TestFrameworks;
+    protected readonly jsTestSettings: JSTestSettings;
+    protected readonly testFramework: TestFrameworks;
+
     private testCollection: Map<string, TestCase>;
 
     constructor(environment: IEnvironment, messageSender: MessageSender, jsTestSettings: JSTestSettings) {
@@ -63,6 +66,7 @@ export class ExecutionManager extends BaseExecutionManager {
             framework.testFrameworkEvents.onTestCaseStart.subscribe(this.testFrameworkEventHandlers.TestCaseStart);
             framework.testFrameworkEvents.onTestCaseEnd.subscribe(this.testFrameworkEventHandlers.TestCaseEnd);
             framework.testFrameworkEvents.onErrorMessage.subscribe(this.testFrameworkEventHandlers.TestErrorMessage);
+            framework.testFrameworkEvents.onRunAttachment.subscribe(this.testFrameworkEventHandlers.TestRunAttachment);
         },
 
         TestSessionStart: (sender: object, args: TestSessionEventArgs) => {
@@ -103,6 +107,10 @@ export class ExecutionManager extends BaseExecutionManager {
 
         TestErrorMessage: (sender: object, args: TestErrorMessageEventArgs) => {
             this.messageSender.sendMessage(args.Message, TestMessageLevel.Error);
+        },
+
+        TestRunAttachment: (sender: object, args: TestRunAttachmentEventArgs) => {
+            this.messageSender.sendRunAttachments(args.AttachmentCollection);
         }
     };
 
@@ -111,7 +119,7 @@ export class ExecutionManager extends BaseExecutionManager {
             this.messageSender.sendMessage(err.stack ?
                 err.stack :
                 (err.constructor.name + ': ' + err.message),
-            TestMessageLevel.Error);
+                TestMessageLevel.Error);
         }
     }
 
@@ -124,9 +132,9 @@ export class ExecutionManager extends BaseExecutionManager {
                 framework.startExecutionWithSources(sources, this.jsTestSettings.TestFrameworkConfigJson);
             }
         },
-        (e) => {
-            this.sessionError(sources, e);
-        });
+            (e) => {
+                this.sessionError(sources, e);
+            });
     }
 
     private executionComplete = () => {