All files / src/services coverage-service.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import fs from "fs";
import { join } from "path";
import { Category } from "../api";
import { logger } from "../logger";
import { ensureDir } from "../utils";
 
export interface CoverageMap {
  [name: string]: number;
}
 
export class CoverageService {
  private coverageDirectory = "./coverage";
 
  private coverage: { [category: string]: CoverageMap } = {
    defaultCategoryName: {},
  };
 
  public getAllForCategory(category: string): CoverageMap {
    return this.coverage[category] ?? {};
  }
 
  /**
   * Track usage of a scenario.
   * @param category Category for the coverage
   * @param name Name of the scenario.
   * @param value {Optional} For legacy test set the value of the usage.
   */
  public async track(category: Category, name: string): Promise<void> {
    let map = this.coverage[category];
    Iif (!map) {
      map = this.coverage[category] = {};
    }
 
    Iif (!(name in map)) {
      map[name] = 0;
    }
 
    map[name] += 1;
    await this.saveCoverage(category);
  }
 
  /**
   * For LEGACY test only.
   * @deprecated
   */
  public legacyTrack(category: Category, name: string, value: number): void {
    let map = this.coverage[category];
    Iif (!map) {
      map = this.coverage[category] = {};
    }
 
    Iif (!(name in map)) {
      map[name] = 0;
    }
 
    Iif (value > map[name]) {
      map[name] = value;
    }
    this.legacySaveCoverage(category);
  }
 
  public register(category: string, name: string): void {
    let map = this.coverage[category];
    Iif (!map) {
      map = this.coverage[category] = {};
    }
 
    Iif (name in map) {
      throw new Error(`Name '${name}' already exists in category '${category}' make sure it is unique.`);
    }
 
    map[name] = 0;
  }
 
  public reset(): void {
    for (const categoryMap of Object.values(this.coverage)) {
      for (const name of Object.keys(categoryMap)) {
        categoryMap[name] = 0;
      }
    }
  }
 
  public init(coverageDirectory: string, loadExisting = false): void {
    this.coverageDirectory = coverageDirectory;
    Iif (loadExisting) {
      this.loadExistingCoverages();
    }
  }
 
  private async saveCoverage(category: Category) {
    const categoryMap = this.coverage[category];
    await ensureDir(this.coverageDirectory);
    const path = this.getReportPath(category);
 
    try {
      await fs.promises.writeFile(path, JSON.stringify(categoryMap, null, 2));
    } catch (e) {
      logger.warn("Error while saving coverage", e);
    }
  }
 
  private legacySaveCoverage(category: Category) {
    const categoryMap = this.coverage[category];
    fs.mkdirSync(this.coverageDirectory, { recursive: true });
    const path = this.getReportPath(category);
    try {
      fs.writeFileSync(path, JSON.stringify(categoryMap, null, 2));
    } catch (e) {
      logger.warn("Error while saving coverage", e);
    }
  }
 
  private loadExistingCoverages() {
    const categories: Category[] = ["vanilla", "azure", "optional", "dpg"];
    for (const category of categories) {
      this.loadExistingCoverage(category);
    }
  }
 
  private loadExistingCoverage(category: Category) {
    const path = this.getReportPath(category);
    try {
      Iif (!fs.existsSync(path)) {
        logger.warn(`Coverage for category '${category}' doesn't exists yet(File '${path}' is not found)`);
 
        return;
      }
      const content = fs.readFileSync(path);
      const data = JSON.parse(content.toString());
      for (const [key, value] of Object.entries(data)) {
        this.coverage[category][key] = value as number;
      }
    } catch (e) {
      logger.warn("Error while loading existing coverage", e);
    }
  }
 
  private getReportPath(category: Category) {
    return join(this.coverageDirectory, `report-${category}.json`);
  }
}
 
export const coverageService = new CoverageService();