Class TestRoot

src/test/test.ts:321–637

}

export class TestRoot {
  readonly initialize: Promise<Dap.InitializeResult>;
  readonly log: Log;
  readonly assertLog: AssertLog;

  private _targetToP = new Map<ITarget, ITestHandle>();
  private _root: Session;
  private _workspaceRoot: string;
  private _webRoot: string | undefined;
  _launchUrl: string | undefined;
  private _args: string[];

  private _worker: Promise<ITestHandle>;
  private _workerCallback: (session: ITestHandle) => void;
  private _launchCallback: (session: ITestHandle) => void;

  _browserLauncher: BrowserLauncher<AnyChromiumLaunchConfiguration> | undefined;
  readonly binder: Binder;

  private _onSessionCreatedEmitter = new EventEmitter<ITestHandle>();
  readonly onSessionCreated = this._onSessionCreatedEmitter.event;
  public readonly logger: ILogger;

  constructor(goldenText: GoldenText, private _testTitlePath: string) {
    this._args = ['--headless'];
    this.log = goldenText.log.bind(goldenText);
    this.assertLog = goldenText.assertLog.bind(goldenText);
    this._workspaceRoot = utils.platformPathToPreferredCase(testWorkspace);
    this._webRoot = path.join(this._workspaceRoot, 'web');

    const storagePath = path.join(__dirname, '..', '..');
    // todo: make a more proper mock here
    const workspaceState = new Map<string, unknown>();
    const services = createTopLevelSessionContainer(
      createGlobalContainer({
        storagePath,
        isVsCode: true,
        context: upcastPartial<ExtensionContext>({
          workspaceState: {
            keys: () => [],
            get<T>(key: string, defaultValue?: T) {
              return workspaceState.get(key) ?? defaultValue;
            },
            update(key: string, value: unknown) {
              workspaceState.set(key, value);
              return Promise.resolve();
            },
          },
        }),
      }),
    );

    this.logger = services.get(ILogger);
    this._root = new Session(this.logger);
    const dap = this._root.adapterConnection.dap();
    dap.on('initialize', async () => {
      dap.initialized({});
      return DebugAdapter.capabilities();