SCP-135 Includes policies on summary report

action.yml

@@ -46,6 +46,7 @@ inputs:
     required: false
     default: ${{ github.token }}
 
+
 # Define your outputs here.
 outputs:
   result-filepath:

src/main.ts

@@ -17,23 +17,29 @@ export async function run(): Promise<void> {
 
     // create policies
     core.debug(`Creating policies`);
+
+    //Read declared policies on input parameter 'policies' and create an instance for each one.
     const policies = policyManager.getPolicies();
-    policies.forEach(async policy => policy.start());
+    for (const policy of policies) {
+      await policy.start();
+    }
 
     // run scan
     const { scan, stdout } = await scanService.scan();
     await uploadResults();
 
     // run policies
-    policies.forEach(async policy => await policy.run(scan));
+    for (const policy of policies) {
+      await policy.run(scan);
+    }
 
     if (isPullRequest()) {
       // create reports
       const report = generateSummary(scan);
-      createCommentOnPR(report);
+      await createCommentOnPR(report);
     }
 
-    await generateJobSummary(scan);
+    await generateJobSummary(scan, policies);
     // set outputs for other workflow steps to use
     core.setOutput(outputs.RESULT_FILEPATH, inputs.OUTPUT_FILEPATH);
     core.setOutput(outputs.STDOUT_SCAN_COMMAND, stdout);

src/policies/policy-check.ts

@@ -5,8 +5,6 @@ import { ScannerResults } from '../services/result.interfaces';
 import { GitHub } from '@actions/github/lib/utils';
 import * as inputs from '../app.input';
 
-const UNINITIALIZED = -1;
-
 export enum CONCLUSION {
   ActionRequired = 'action_required',
   Cancelled = 'cancelled',
@@ -18,17 +16,32 @@ export enum CONCLUSION {
   TimedOut = 'timed_out'
 }
 
+export enum STATUS {
+  UNINITIALIZED = 'UNINITIALIZED',
+  INITIALIZED = 'INITIALIZED',
+  RUNNING = 'RUNNING',
+  FINISHED = 'FINISHED'
+}
+
 export abstract class PolicyCheck {
   private octokit: InstanceType<typeof GitHub>;
 
   private checkName: string;
 
   private checkRunId: number;
 
+  private _raw: any;
+
+  private _status: STATUS;
+
+  private _conclusion: CONCLUSION;
+
   constructor(checkName: string) {
     this.octokit = getOctokit(inputs.GITHUB_TOKEN);
     this.checkName = checkName;
-    this.checkRunId = UNINITIALIZED;
+    this._status = STATUS.UNINITIALIZED;
+    this._conclusion = CONCLUSION.Neutral;
+    this.checkRunId = -1;
   }
 
   async start(): Promise<any> {
@@ -40,37 +53,57 @@ export abstract class PolicyCheck {
     });
 
     this.checkRunId = result.data.id;
+    this._raw = result.data;
 
+    this._status = STATUS.INITIALIZED;
     return result.data;
   }
 
   get name(): string {
     return this.checkName;
   }
+
+  get conclusion(): CONCLUSION {
+    return this._conclusion;
+  }
+
+  get raw(): any {
+    return this._raw;
+  }
+
+  get url(): string {
+    return `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}/job/${this.raw.id}`;
+  }
+
   async run(scannerResults: ScannerResults): Promise<void> {
-    if (this.checkRunId === UNINITIALIZED)
+    if (this._status === STATUS.UNINITIALIZED)
       throw new Error(`Error on finish. Policy "${this.checkName}" is not created.`);
 
     core.debug(`Running policy check: ${this.checkName}`);
+    this._status = STATUS.RUNNING;
   }
 
   protected async success(summary: string, text: string): Promise<void> {
-    return await this.finish(CONCLUSION.Success, summary, text);
+    this._conclusion = CONCLUSION.Success;
+    return await this.finish(summary, text);
   }
 
   protected async reject(summary: string, text: string): Promise<void> {
-    return await this.finish(inputs.POLICIES_HALT_ON_FAILURE ? CONCLUSION.Failure : CONCLUSION.Neutral, summary, text);
+    if (inputs.POLICIES_HALT_ON_FAILURE) this._conclusion = CONCLUSION.Failure;
+    else this._conclusion = CONCLUSION.Neutral;
+    return await this.finish(summary, text);
   }
 
-  protected async finish(conclusion: CONCLUSION | undefined, summary: string, text: string): Promise<void> {
-    core.debug(`Finish policy check: ${this.checkName}. (conclusion=${conclusion})`);
+  protected async finish(summary: string, text: string): Promise<void> {
+    core.debug(`Finish policy check: ${this.checkName}. (conclusion=${this._conclusion})`);
+    this._status = STATUS.FINISHED;
 
     const result = await this.octokit.rest.checks.update({
       owner: context.repo.owner,
       repo: context.repo.repo,
       check_run_id: this.checkRunId,
       status: 'completed',
-      conclusion,
+      conclusion: this._conclusion,
       output: {
         title: this.checkName,
         summary,