Add file import report to testrail

index.d.ts

@@ -1,56 +1,57 @@
 interface TestrailOptions {
   testrail: {
-    host: string;
-    user: string;
-    password: string;
+    host: string
+    user: string
+    password: string
     filters: {
-      plan_id: number;
-      run_id?: number;
-      custom_status?: [number];
-    };
+      plan_id: number
+      run_id?: number
+      custom_status?: [number]
+    }
     verifyFilters?: {
-      custom_status?: [number];
+      custom_status?: [number]
     }
-  };
+  }
 }
 
 export interface ScenarioSynchronizerOptions extends TestrailOptions {
-  featuresDir: string;
-  stepDefinitionsDir: string;
+  featuresDir: string
+  resultsDir: string
+  stepDefinitionsDir: string
   overwrite?: {
-    local?: boolean | string;
-    remote?: boolean | string;
-  };
-  stepDefinitionsTemplate?: string;
-  stepDefinitionsStringPatterns?: boolean;
-  stepDefinitionsExpressions?: boolean;
-  indent?: string;
-  silent?: boolean;
+    local?: boolean | string
+    remote?: boolean | string
+  }
+  stepDefinitionsTemplate?: string
+  stepDefinitionsStringPatterns?: boolean
+  stepDefinitionsExpressions?: boolean
+  indent?: string
+  silent?: boolean
   directoryStructure?: {
-    type?: string;
-    skipRootFolder?: number;
-  };
-  verify?: boolean;
-  findUnused?: boolean;
-  pushResults?: boolean;
-  debug?: boolean;
+    type?: string
+    skipRootFolder?: number
+  }
+  verify?: boolean
+  findUnused?: boolean
+  pushResults?: boolean
+  debug?: boolean
   newTestCase?: {
-    section_id: number;
-    [key: string]: any;
-  };
+    section_id: number
+    [key: string]: any
+  }
 }
 
 export class ScenarioSynchronizer {
-  constructor();
-  synchronize(options: ScenarioSynchronizerOptions, callback: Function): void;
+  constructor()
+  synchronize(options: ScenarioSynchronizerOptions, callback: Function): void
 }
 
 export class ResultSynchronizer {
-  constructor(options: ScenarioSynchronizerOptions);
-  saveTestResult(scenario: any, callback: Function): void;
-  pushTestResults(callback: Function): void;
+  constructor(options: ScenarioSynchronizerOptions)
+  saveTestResult(scenario: any, callback: Function): void
+  pushTestResults(callback: Function): void
 }
 
-export function readConfig(): ScenarioSynchronizerOptions;
+export function readConfig(): ScenarioSynchronizerOptions
 
-export function install(cucumber: any): void;
+export function install(cucumber: any): void

src/CucumberReportParser.ts

@@ -0,0 +1,40 @@
+import { Scenario, TestCaseReport, Step } from './index';
+
+export class CucumberReportParser {
+  protected report: any[];
+  protected scenarios: Scenario[];
+
+  public parseReport(report: TestCaseReport[]): Scenario[] {
+    this.report = report;
+    this.scenarios = [];
+    report.forEach((result: any) => {
+      this.parseTestCases(result.elements);
+    });
+    return this.scenarios;
+  }
+
+  protected parseTestCases(testCases: TestCaseReport[]): void {
+    testCases.forEach((testCase: TestCaseReport) => {
+      const error = this.parseTestCase(testCase);
+      const scenario = <Scenario> {
+        tags: [testCase.tags[0].name],
+        isPending: false,
+        isUndefined: false,
+        isSkipped: false,
+        isSuccessful: error === null,
+        exception: error
+      };
+      this.scenarios.push(scenario);
+    });
+  }
+
+  protected parseTestCase(testCase: TestCaseReport): Error {
+    let error = null;
+    testCase.steps.forEach((step: Step) => {
+      if (step.result.status !== 'passed') {
+        error = `status[${step.result.status}] step[${step.name}]`;
+      }
+    });
+    return error;
+  }
+}

src/GherkinFormatter.ts

@@ -32,14 +32,23 @@ export class GherkinFormatter {
     }
 
     public getGherkinFromTestcase(testcase: any): string {
+        let gherkinTest = '';
+        if (testcase.custom_preconds && testcase.custom_preconds.length > 0) {
+            gherkinTest += testcase.custom_preconds + '\n';
+        }
+
         if (testcase.custom_gherkin && testcase.custom_gherkin.length > 0) {
-            return testcase.custom_gherkin;
+            gherkinTest += testcase.custom_gherkin;
         } else if (testcase.custom_steps && testcase.custom_steps.length > 0) {
-            return testcase.custom_steps;
+            gherkinTest += testcase.custom_steps;
         } else if (testcase.custom_steps_separated && testcase.custom_steps_separated.length > 0) {
-            return testcase.custom_steps_separated.map((s: any) => s.content).join('\n');
+            gherkinTest += testcase.custom_steps_separated.map((s) => s.content).join('\n');
         }
-        return '';
+        if (testcase.custom_expected && testcase.custom_expected.length > 0) {
+            gherkinTest += '\n' + testcase.custom_expected + '\n';
+        }
+
+        return gherkinTest;
     }
 
     /**

src/bin/push-test-result-file.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import * as program from 'commander';
+import * as path from 'path';
+import { ResultSynchronizer, readConfig, CucumberReportParser } from '../index';
+import * as fs from 'fs';
+
+const parser = new CucumberReportParser();
+
+program.option('--file <String>', 'filename in results directory').parse(process.argv);
+
+const error = (s: string): void => {
+  program.outputHelp();
+  console.log();
+  console.log('Error: ' + s);
+  process.exit(1);
+};
+
+if (!(<any> program).file || [0, NaN].indexOf((<any> program).file) !== -1) {
+  error('<testcase file> is required and must be a string');
+}
+const config = readConfig();
+config.pushResults = true;
+
+const resultFile = String((<any> program).file);
+
+let results;
+try {
+  const jsonString = fs.readFileSync(path.resolve(config.resultsDir, resultFile));
+  results = JSON.parse(String(jsonString));
+} catch (err) {
+  error(`<testcase file> error reading file[${path.resolve(config.resultsDir, resultFile)}] exception[${err}]`);
+}
+
+if (!Array.isArray(results)) {
+  error(`<testcase file> wrong cucumber format result file ${path.resolve(config.resultsDir, resultFile)}`);
+}
+
+const scenarios = parser.parseReport(results);
+
+const sync = new ResultSynchronizer(config);
+const savePromises = [];
+for (const scenario of scenarios) {
+  savePromises.push(sync.saveTestResult(scenario));
+}
+Promise.all(savePromises)
+  .then(() => sync.readRemoteTestRuns().then(() => sync.pushTestResults().then(() => console.log('sync done'))))
+  .catch(e => error(e));

src/bin/push-test-result.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import * as program from 'commander';
-import {ResultSynchronizer, readConfig} from '../index';
+import { ResultSynchronizer, readConfig } from '../index';
 
 program
     .option('--id <id>', 'testcase id')

src/index.ts

@@ -1,15 +1,42 @@
 // tslint:disable-next-line:no-reference
 /// <reference path="../typings.d.ts" />
-export {ScenarioSynchronizer} from './ScenarioSynchronizer';
-export {ResultSynchronizer} from './ResultSynchronizer';
-export {readConfig} from './readConfig';
-export {install, legacyInstall} from './install';
+export { ScenarioSynchronizer } from './ScenarioSynchronizer';
+export { ResultSynchronizer } from './ResultSynchronizer';
+export { CucumberReportParser } from './CucumberReportParser';
+
+export { readConfig } from './readConfig';
+export { install, legacyInstall } from './install';
 
 export interface Scenario {
-    tags: string[];
-    isPending: boolean;
-    isUndefined: boolean;
-    isSkipped: boolean;
-    isSuccessful: boolean;
-    exception: Error;
+  tags: string[];
+  isPending: boolean;
+  isUndefined: boolean;
+  isSkipped: boolean;
+  isSuccessful: boolean;
+  exception: Error;
+}
+
+export interface TestCaseReport {
+  id: Number;
+  name: string;
+  tags: Tag[];
+  type: string;
+  steps: Step[];
+}
+
+export interface Step {
+  keyword: string;
+  line: Number;
+  name: string;
+  result: StepResult;
+}
+
+export interface StepResult {
+  status: string;
+  duration: Number;
+}
+
+export interface Tag {
+  line: Number;
+  name: String;
 }