askui 0.10.1 → 0.10.2

package/dist/esm/execution/ui-control-client.js

@@ -7,71 +7,98 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { CustomElement } from '../core/model/test-case-dto';
+import { CustomElement } from '../core/model/custom-element';
 import { ApiCommands, Separators, } from './dsl';
-import { HttpClientGot } from '../utils/http/http-client-got';
-import { UiControllerClient } from './ui-controller-client';
-import { ExecutionRuntime } from './execution-runtime';
-import { InferenceClient } from './inference-client';
 import { AnnotationWriter } from '../core/annotation/annotation-writer';
 import { logger } from '../lib/logger';
-import { TestStepState } from '../core/model/test-case-result-dto';
 import { AnnotationLevel } from './annotation-level';
 import { UiControlClientError } from './ui-control-client-error';
-import { envCredentials } from './read-environment-credentials';
-import { Analytics } from '../utils/analytics';
-import { buildProxyAgentArgsFromEnvironment } from '../utils/proxy/proxy-builder';
-const getClientArgsWithDefaults = (clientArgs = {}) => (Object.assign({ uiControllerUrl: 'http://127.0.0.1:6769', inferenceServerUrl: 'https://inference.askui.com', annotationLevel: AnnotationLevel.DISABLED }, clientArgs));
+import { UiControlClientDependencyBuilder } from './ui-control-client-dependency-builder';
 export class UiControlClient extends ApiCommands {
-    constructor(httpClient, clientArgs, workspaceId) {
+    constructor(config, executionRuntime, stepReporter) {
         super();
-        this.httpClient = httpClient;
-        this.clientArgs = clientArgs;
-        this.workspaceId = workspaceId;
+        this.config = config;
+        this.executionRuntime = executionRuntime;
+        this.stepReporter = stepReporter;
         this.secretText = undefined;
     }
-    static build(clientArgs) {
+    static build(clientArgs = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const analytics = new Analytics();
-            const analyticsHeaders = yield analytics.getAnalyticsHeaders();
-            const analyticsCookies = yield analytics.getAnalyticsCookies();
-            const cas = getClientArgsWithDefaults(clientArgs);
-            const credentialArgs = cas.credentials || envCredentials();
-            const proxyAgentArgs = cas.proxyAgents || (yield buildProxyAgentArgsFromEnvironment());
-            const httpClient = new HttpClientGot(credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.token, analyticsHeaders, analyticsCookies, proxyAgentArgs);
-            return new UiControlClient(httpClient, cas, credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.workspaceId);
+            const builder = UiControlClientDependencyBuilder;
+            const clientArgsWithDefaults = yield builder.getClientArgsWithDefaults(clientArgs);
+            const { executionRuntime, stepReporter } = yield builder.build(clientArgsWithDefaults);
+            return new UiControlClient({
+                annotationLevel: clientArgsWithDefaults.annotationLevel,
+            }, executionRuntime, stepReporter);
         });
     }
-    get uiControllerClient() {
-        if (!this._uiControllerClient) {
-            this._uiControllerClient = new UiControllerClient(this.clientArgs.uiControllerUrl);
-        }
-        return this._uiControllerClient;
+    /**
+     * Connects to the askui UI Controller.
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executionRuntime.connect();
+        });
+    }
+    /**
+     * Disconnects from the askui UI Controller.
+     */
+    disconnect() {
+        this.executionRuntime.disconnect();
     }
-    get inferenceClient() {
-        return new InferenceClient(this.clientArgs.inferenceServerUrl, this.httpClient, this.clientArgs.resize, this.workspaceId, this.clientArgs.modelComposition);
+    /**
+     * Disconnects from the askui UI Controller.
+     *
+     * @deprecated Use {@link disconnect} instead.
+     */
+    close() {
+        this.disconnect();
     }
-    get executionRuntime() {
-        return new ExecutionRuntime(this.uiControllerClient, this.inferenceClient);
+    startVideoRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.executionRuntime.startVideoRecording();
+        });
     }
-    annotateByDefault(testStepState, customElements = []) {
+    stopVideoRecording() {
         return __awaiter(this, void 0, void 0, function* () {
-            if ((testStepState === TestStepState.FAILED
-                && this.clientArgs.annotationLevel === AnnotationLevel.DISABLED)
-                || (testStepState === TestStepState.PASSED
-                    && this.clientArgs.annotationLevel !== AnnotationLevel.ALL)) {
-                return;
-            }
-            yield this.annotate({
-                customElements,
-                fileNamePrefix: `${testStepState.toLowerCase()}_testStep_annotation`,
-            });
+            yield this.executionRuntime.stopVideoRecording();
         });
     }
-    connect() {
+    readVideoRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.executionRuntime.readVideoRecording();
+        });
+    }
+    shouldWriteAnntotationAfterCommandExecution(error) {
+        const { annotationLevel } = this.config;
+        return annotationLevel === AnnotationLevel.ALL
+            || (annotationLevel === AnnotationLevel.ON_FAILURE && error !== undefined);
+    }
+    shouldAnnotateAfterCommandExecution(error) {
+        return this.shouldWriteAnntotationAfterCommandExecution(error)
+            || (this.stepReporter.config.withDetectedElements === 'onFailure' && error !== undefined)
+            || (this.stepReporter.config.withDetectedElements === 'always');
+    }
+    afterCommandExecution(instruction, error) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const connectionState = yield this.uiControllerClient.connect();
-            return connectionState;
+            const createdAt = new Date();
+            let annotation;
+            let screenshot;
+            if (this.shouldAnnotateAfterCommandExecution(error)) {
+                annotation = yield this.executionRuntime.annotateImage(undefined, instruction.customElements);
+            }
+            if (annotation !== undefined && this.shouldWriteAnntotationAfterCommandExecution(error)) {
+                AnnotationWriter.write(annotation.toHtml(), undefined, `${error !== undefined ? 'failed' : 'passed'}_testStep_annotation`);
+            }
+            if (annotation !== undefined || this.stepReporter.config.withScreenshots === 'always') {
+                screenshot = (_a = annotation === null || annotation === void 0 ? void 0 : annotation.image) !== null && _a !== void 0 ? _a : yield this.executionRuntime.getScreenshot();
+            }
+            yield this.stepReporter.onStepEnd({
+                createdAt,
+                detectedElements: annotation === null || annotation === void 0 ? void 0 : annotation.detected_elements,
+                screenshot,
+            }, error);
         });
     }
     annotate(annotationRequest = {}) {
@@ -95,25 +122,29 @@ export class UiControlClient extends ApiCommands {
     escapeSeparatorString(instruction) {
         return instruction.split(Separators.STRING).join('"');
     }
-    fluentCommandExecutor(instruction, customElementJson = []) {
+    buildInstruction(instructionString, customElementJson = []) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { secretText } = this;
-            const customElements = yield CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
-            const stringWithoutSeparators = this.escapeSeparatorString(instruction);
-            logger.debug(stringWithoutSeparators);
+            return {
+                customElements: yield CustomElement.fromJsonListWithImagePathOrImage(customElementJson),
+                value: instructionString,
+                secretText: this.getAndResetSecretText(),
+                valueHumanReadable: this.escapeSeparatorString(instructionString),
+            };
+        });
+    }
+    fluentCommandExecutor(instructionString, customElementJson = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instruction = yield this.buildInstruction(instructionString, customElementJson);
+            logger.debug(instruction);
             try {
-                yield this.executionRuntime.executeTestStep({
-                    instruction,
-                    customElements,
-                    secretText,
-                });
-                this.secretText = undefined;
-                yield this.annotateByDefault(TestStepState.PASSED, customElements);
+                yield this.stepReporter.resetStep(instruction);
+                yield this.executionRuntime.executeInstruction(instruction);
+                yield this.afterCommandExecution(instruction);
                 return yield Promise.resolve();
             }
             catch (error) {
-                yield this.annotateByDefault(TestStepState.FAILED, customElements);
-                return Promise.reject(new UiControlClientError(`A problem occurred while executing the instruction: ${stringWithoutSeparators}. Reason ${error}`));
+                yield this.afterCommandExecution(instruction, error instanceof Error ? error : new Error(String(error)));
+                return Promise.reject(new UiControlClientError(`A problem occurred while executing the instruction: ${instruction.valueHumanReadable}. Reason ${error}`));
             }
         });
     }
@@ -125,6 +156,11 @@ export class UiControlClient extends ApiCommands {
             return this.executionRuntime.getDetectedElements(instruction, customElements);
         });
     }
+    getAndResetSecretText() {
+        const { secretText } = this;
+        this.secretText = undefined;
+        return secretText;
+    }
     /**
      * Types a text inside the filtered element.
      *
@@ -192,10 +228,4 @@ export class UiControlClient extends ApiCommands {
             },
         };
     }
-    /**
-    * Closes the connection to the askui UI Controller
-    */
-    close() {
-        this.uiControllerClient.close();
-    }
 }

package/dist/esm/execution/ui-controller-client-interface.d.ts

@@ -2,6 +2,7 @@ import { AnnotationLevel } from './annotation-level';
 import { CredentialArgs } from './credentials-args';
 import { ProxyAgentArgs } from '../shared/proxy-agent-args';
 import { ModelCompositionBranch } from './model-composition-branch';
+import { Reporter, ReporterConfig } from '@/core/reporting';
 /**
  * Configuration options for the askui UI Control Client
  *
@@ -25,18 +26,26 @@ import { ModelCompositionBranch } from './model-composition-branch';
  * the authentication of the askui Inference Server.
  * You have three options: `DISABLED`, `ON_FAILURE`, `ALL`.
  * @param {ProxyAgentArgs} proxyAgents - To configure the proxy agents for http(s) requests.
+ * @param {Reporter} reporter - To configure the reporter to report on step runs.
  */
 export interface ClientArgs {
     readonly uiControllerUrl?: string;
     readonly inferenceServerUrl?: string;
     readonly annotationLevel?: AnnotationLevel;
-    readonly credentials?: CredentialArgs;
-    readonly proxyAgents?: ProxyAgentArgs;
+    readonly credentials?: CredentialArgs | undefined;
+    readonly proxyAgents?: ProxyAgentArgs | undefined;
     readonly resize?: number;
     readonly modelComposition?: ModelCompositionBranch[];
+    readonly reporter?: Reporter | undefined;
 }
 export interface ClientArgsWithDefaults extends ClientArgs {
     readonly uiControllerUrl: string;
     readonly inferenceServerUrl: string;
     readonly annotationLevel: AnnotationLevel;
+    readonly reporter: Required<Reporter> & {
+        config: Required<ReporterConfig>;
+    };
+}
+export interface UiControlClientConfig {
+    annotationLevel: AnnotationLevel;
 }

package/dist/esm/execution/ui-controller-client.d.ts

@@ -17,14 +17,14 @@ export declare class UiControllerClient {
     private clearResponse;
     private onMessage;
     connect(): Promise<UiControllerClientConnectionState>;
-    close(): void;
+    disconnect(): void;
     private sendAndReceive;
     private send;
     requestScreenshot(): Promise<CaptureScreenshotResponse>;
     getServerPid(): Promise<GetProcessPidResponse>;
-    startRecording(): Promise<StartRecordingResponse>;
-    stopRecording(): Promise<StopRecordingResponse>;
-    readRecording(): Promise<ReadRecordingPartResponse>;
+    startVideoRecording(): Promise<StartRecordingResponse>;
+    stopVideoRecording(): Promise<StopRecordingResponse>;
+    readVideoRecording(): Promise<ReadRecordingPartResponse>;
     annotateInteractively(boundingBoxes: DetectedElement[], imageString: string): Promise<InteractiveAnnotationResponse>;
     requestControl(controlCommand: ControlCommand): Promise<ControlResponse>;
 }

package/dist/esm/execution/ui-controller-client.js

@@ -51,7 +51,7 @@ export class UiControllerClient {
             }
         });
     }
-    close() {
+    disconnect() {
         var _a;
         (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
     }
@@ -82,17 +82,17 @@ export class UiControllerClient {
     getServerPid() {
         return this.sendAndReceive(new GetProcessPidRequest());
     }
-    startRecording() {
+    startVideoRecording() {
         return this.sendAndReceive(new StartRecordingRequest());
     }
-    stopRecording() {
+    stopVideoRecording() {
         return this.sendAndReceive(new StopRecordingRequest());
     }
-    readRecording() {
+    readVideoRecording() {
         return new Promise((resolve, reject) => {
             const readRecordingStreamHandler = new ReadRecordingResponseStreamHandler(resolve, reject);
-            this.currentResolve = readRecordingStreamHandler.onMessage;
-            this.currentReject = readRecordingStreamHandler.onError;
+            this.currentResolve = readRecordingStreamHandler.onMessage.bind(readRecordingStreamHandler);
+            this.currentReject = readRecordingStreamHandler.onError.bind(readRecordingStreamHandler);
             this.send(new ReadRecordingRequest(), 60 * 15 * 1000);
         });
     }

package/dist/esm/lib/ui-controller-facade.js

@@ -18,7 +18,7 @@ import { downloadServerBinaries, getBinaryFilePath } from './download-binaries';
 import { logger } from './logger';
 import { TimeoutError } from './timeout-error';
 import { UnkownError } from './unkown-error';
-import { buildProxyAgentArgsFromEnvironment } from '../utils/proxy/proxy-builder';
+import { envProxyAgents } from '../utils/proxy/proxy-builder';
 export class UiControllerFacade {
     constructor() {
         this.binaryFilePath = getBinaryFilePath('latest');
@@ -30,7 +30,7 @@ export class UiControllerFacade {
             const argsWithDefaults = createArgsWithDefaults(args);
             const argsWithLogPath = this.serverLogFilePath(argsWithDefaults);
             this.binaryFilePath = getBinaryFilePath(argsWithLogPath.binaryVersion);
-            yield this.getBinary(argsWithLogPath.binaryVersion, argsWithLogPath.overWriteBinary, argsWithLogPath.proxyAgents || (yield buildProxyAgentArgsFromEnvironment()));
+            yield this.getBinary(argsWithLogPath.binaryVersion, argsWithLogPath.overWriteBinary, argsWithLogPath.proxyAgents || (yield envProxyAgents()));
             this.makeBinaryExecutable();
             logger.debug(`UI Controller log path "${this.serverLogFile}"`);
             yield this.startWithDefaults(argsWithLogPath, maxWaitingForStartingInSeconds);

package/dist/esm/main.d.ts

@@ -1,3 +1,4 @@
 export { UiController } from './lib';
-export { UiControlClient, AnnotationLevel } from './execution';
+export { AnnotationLevel, UiControlClient } from './execution';
+export { Instruction, Reporter, ReporterConfig, Snapshot, SnapshotDetailLevel, Step, StepStatus, StepStatusEnd, } from './core/reporting';
 export { LogLevels } from './shared';

package/dist/esm/main.js

@@ -1,3 +1,3 @@
 export { UiController } from './lib';
-export { UiControlClient, AnnotationLevel } from './execution';
+export { AnnotationLevel, UiControlClient } from './execution';
 export { LogLevels } from './shared';

package/dist/esm/utils/proxy/proxy-builder.d.ts

@@ -1,4 +1,4 @@
 import { ProxyAgentArgs } from '../../shared/proxy-agent-args';
 export declare class ProxyImportError extends Error {
 }
-export declare function buildProxyAgentArgsFromEnvironment(): Promise<ProxyAgentArgs | undefined>;
+export declare function envProxyAgents(): Promise<ProxyAgentArgs | undefined>;

package/dist/esm/utils/proxy/proxy-builder.js

@@ -21,7 +21,7 @@ function dynmicImportHpagent() {
         }
     });
 }
-export function buildProxyAgentArgsFromEnvironment() {
+export function envProxyAgents() {
     return __awaiter(this, void 0, void 0, function* () {
         const httpProxyUrl = process.env['HTTP_PROXY'];
         const httpsProxyUrl = process.env['HTTPS_PROXY'];

package/dist/example_projects_templates/typescript_jest/test/my-first-askui-test-suite.test.ts

@@ -1,8 +1,15 @@
 import { aui } from './helper/jest.setup';
 
 describe('jest with askui', () => {
-  it('should generate an interactive annotation', async () => {
-    await aui.annotateInteractively();
+  it('should generate an (interactive) annotation', async () => {
+    // For Windows users:
+    // Use annotate() to create an annotated HTML file
+    // of your screen that is saved under <project_root>/report
+    await aui.annotate();
+
+    // Uncomment for macOS and Linux
+    // Delete the lines above to not trigger annotate()
+    // await aui.annotateInteractively();
   });
 
   it('should click on my element', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "askui",
-    "version": "v0.10.1",
+    "version": "0.10.2",
     "license": "MIT",
     "author": "askui GmbH <info@askui.com> (http://www.askui.com/)",
     "description": "Reliable, automated end-to-end-testing that depends on what is shown on your screen instead of the technology you are running on",