@devicecloud.dev/dcd 4.1.2-beta.1 → 4.1.3

package/dist/services/metadata-extractor.service.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataExtractorService = exports.IosZipMetadataExtractor = exports.IosAppMetadataExtractor = exports.AndroidMetadataExtractor = void 0;
+const AppInfoParser = require("app-info-parser");
+const bplist_parser_1 = require("bplist-parser");
+const promises_1 = require("node:fs/promises");
+const path = require("node:path");
+const StreamZip = require("node-stream-zip");
+const plist_1 = require("plist");
+/**
+ * Extracts metadata from Android APK files
+ */
+class AndroidMetadataExtractor {
+    canHandle(filePath) {
+        return filePath.endsWith('.apk');
+    }
+    async extract(filePath) {
+        const parser = new AppInfoParser(filePath);
+        const result = await parser.parse();
+        return { appId: result.package, platform: 'android' };
+    }
+}
+exports.AndroidMetadataExtractor = AndroidMetadataExtractor;
+/**
+ * Extracts metadata from iOS .app directories
+ */
+class IosAppMetadataExtractor {
+    canHandle(filePath) {
+        return filePath.endsWith('.app');
+    }
+    async extract(filePath) {
+        const infoPlistPath = path.normalize(path.join(filePath, 'Info.plist'));
+        const buffer = await (0, promises_1.readFile)(infoPlistPath);
+        const data = await this.parseInfoPlist(buffer);
+        const appId = data.CFBundleIdentifier;
+        return { appId, platform: 'ios' };
+    }
+    async parseInfoPlist(buffer) {
+        let data;
+        const bufferType = buffer[0];
+        if (bufferType === 60 ||
+            bufferType === '<' ||
+            bufferType === 239) {
+            data = (0, plist_1.parse)(buffer.toString());
+        }
+        else if (bufferType === 98) {
+            data = (0, bplist_parser_1.parseBuffer)(buffer)[0];
+        }
+        else {
+            throw new Error('Unknown plist buffer type.');
+        }
+        return data;
+    }
+}
+exports.IosAppMetadataExtractor = IosAppMetadataExtractor;
+/**
+ * Extracts metadata from iOS .zip files containing .app bundles
+ */
+class IosZipMetadataExtractor {
+    canHandle(filePath) {
+        return filePath.endsWith('.zip');
+    }
+    async extract(filePath) {
+        return new Promise((resolve, reject) => {
+            const zip = new StreamZip({ file: filePath });
+            zip.on('ready', () => {
+                // Get all entries and sort them by path depth
+                const entries = Object.values(zip.entries());
+                const sortedEntries = entries.sort((a, b) => {
+                    const aDepth = a.name.split('/').length;
+                    const bDepth = b.name.split('/').length;
+                    return aDepth - bDepth;
+                });
+                // Find the first Info.plist in the shallowest directory
+                const infoPlist = sortedEntries.find((e) => e.name.endsWith('.app/Info.plist'));
+                if (!infoPlist) {
+                    reject(new Error('Failed to find info plist'));
+                    return;
+                }
+                const buffer = zip.entryDataSync(infoPlist.name);
+                this.parseInfoPlist(buffer)
+                    .then((data) => {
+                    const appId = data.CFBundleIdentifier;
+                    zip.close();
+                    resolve({ appId, platform: 'ios' });
+                })
+                    .catch(reject);
+            });
+            zip.on('error', reject);
+        });
+    }
+    async parseInfoPlist(buffer) {
+        let data;
+        const bufferType = buffer[0];
+        if (bufferType === 60 ||
+            bufferType === '<' ||
+            bufferType === 239) {
+            data = (0, plist_1.parse)(buffer.toString());
+        }
+        else if (bufferType === 98) {
+            data = (0, bplist_parser_1.parseBuffer)(buffer)[0];
+        }
+        else {
+            throw new Error('Unknown plist buffer type.');
+        }
+        return data;
+    }
+}
+exports.IosZipMetadataExtractor = IosZipMetadataExtractor;
+/**
+ * Service for extracting app metadata from various file formats
+ */
+class MetadataExtractorService {
+    extractors = [
+        new AndroidMetadataExtractor(),
+        new IosZipMetadataExtractor(),
+        new IosAppMetadataExtractor(),
+    ];
+    /**
+     * Extract app metadata from a file
+     * @param filePath - Path to the app file (.apk, .app, or .zip)
+     * @returns App metadata or undefined if extraction fails
+     */
+    async extract(filePath) {
+        const extractor = this.extractors.find((e) => e.canHandle(filePath));
+        if (!extractor) {
+            return undefined;
+        }
+        try {
+            return await extractor.extract(filePath);
+        }
+        catch {
+            console.warn('Failed to extract app metadata, please share with support@devicecloud.dev so we can improve our parsing.');
+            return undefined;
+        }
+    }
+}
+exports.MetadataExtractorService = MetadataExtractorService;

package/dist/services/moropo.service.d.ts

@@ -0,0 +1,20 @@
+export interface MoropoDownloadOptions {
+    apiKey: string;
+    branchName?: string;
+    debug?: boolean;
+    json?: boolean;
+    logger?: (message: string) => void;
+    quiet?: boolean;
+}
+/**
+ * Service for downloading and extracting Moropo tests from the Moropo API
+ */
+export declare class MoropoService {
+    private readonly MOROPO_API_URL;
+    /**
+     * Download and extract Moropo tests from the API
+     * @param options Download configuration options
+     * @returns Path to the extracted Moropo tests directory
+     */
+    downloadAndExtract(options: MoropoDownloadOptions): Promise<string>;
+}

package/dist/services/moropo.service.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoropoService = void 0;
+const core_1 = require("@oclif/core");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const StreamZip = require("node-stream-zip");
+/**
+ * Service for downloading and extracting Moropo tests from the Moropo API
+ */
+class MoropoService {
+    MOROPO_API_URL = 'https://api.moropo.com/tests';
+    /**
+     * Download and extract Moropo tests from the API
+     * @param options Download configuration options
+     * @returns Path to the extracted Moropo tests directory
+     */
+    async downloadAndExtract(options) {
+        const { apiKey, branchName = 'main', debug = false, quiet = false, json = false, logger } = options;
+        if (debug && logger) {
+            logger('DEBUG: Moropo v1 API key detected, downloading tests from Moropo API');
+            logger(`DEBUG: Using branch name: ${branchName}`);
+        }
+        try {
+            if (!quiet && !json) {
+                core_1.ux.action.start('Downloading Moropo tests', 'Initializing', {
+                    stdout: true,
+                });
+            }
+            const response = await fetch(this.MOROPO_API_URL, {
+                headers: {
+                    accept: 'application/zip',
+                    'x-app-api-key': apiKey,
+                    'x-branch-name': branchName,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to download Moropo tests: ${response.statusText}`);
+            }
+            const contentLength = response.headers.get('content-length');
+            const totalSize = contentLength
+                ? Number.parseInt(contentLength, 10)
+                : 0;
+            let downloadedSize = 0;
+            const moropoDir = path.join(os.tmpdir(), `moropo-tests-${Date.now()}`);
+            if (debug && logger) {
+                logger(`DEBUG: Extracting Moropo tests to: ${moropoDir}`);
+            }
+            // Create moropo directory if it doesn't exist
+            if (!fs.existsSync(moropoDir)) {
+                fs.mkdirSync(moropoDir, { recursive: true });
+            }
+            // Write zip file to moropo directory
+            const zipPath = path.join(moropoDir, 'moropo-tests.zip');
+            const fileStream = fs.createWriteStream(zipPath);
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('Failed to get response reader');
+            }
+            let readerResult = await reader.read();
+            while (!readerResult.done) {
+                const { value } = readerResult;
+                downloadedSize += value.length;
+                if (!quiet && !json && totalSize) {
+                    const progress = Math.round((downloadedSize / totalSize) * 100);
+                    core_1.ux.action.status = `Downloading: ${progress}%`;
+                }
+                fileStream.write(value);
+                readerResult = await reader.read();
+            }
+            fileStream.end();
+            await new Promise((resolve) => {
+                fileStream.on('finish', () => {
+                    resolve();
+                });
+            });
+            if (!quiet && !json) {
+                core_1.ux.action.status = 'Extracting tests...';
+            }
+            // Extract zip file
+            // eslint-disable-next-line new-cap
+            const zip = new StreamZip.async({ file: zipPath });
+            await zip.extract(null, moropoDir);
+            await zip.close();
+            // Delete zip file after extraction
+            fs.unlinkSync(zipPath);
+            if (!quiet && !json) {
+                core_1.ux.action.stop('completed');
+            }
+            if (debug && logger) {
+                logger('DEBUG: Successfully extracted Moropo tests');
+            }
+            // Create config.yaml file
+            const configPath = path.join(moropoDir, 'config.yaml');
+            fs.writeFileSync(configPath, 'flows:\n- ./**/*.yaml\n- ./*.yaml\n');
+            if (debug && logger) {
+                logger('DEBUG: Created config.yaml file');
+            }
+            return moropoDir;
+        }
+        catch (error) {
+            if (!quiet && !json) {
+                core_1.ux.action.stop('failed');
+            }
+            if (debug && logger) {
+                logger(`DEBUG: Error downloading/extracting Moropo tests: ${error}`);
+            }
+            throw new Error(`Failed to download/extract Moropo tests: ${error}`);
+        }
+    }
+}
+exports.MoropoService = MoropoService;

package/dist/services/report-download.service.d.ts

@@ -0,0 +1,40 @@
+export interface DownloadOptions {
+    apiKey: string;
+    apiUrl: string;
+    debug?: boolean;
+    logger?: (message: string) => void;
+    uploadId: string;
+    warnLogger?: (message: string) => void;
+}
+export interface ArtifactsDownloadOptions extends DownloadOptions {
+    artifactsPath?: string;
+    downloadType: 'ALL' | 'FAILED';
+}
+export interface ReportDownloadOptions extends DownloadOptions {
+    allurePath?: string;
+    htmlPath?: string;
+    junitPath?: string;
+    reportType: 'allure' | 'html' | 'junit';
+}
+/**
+ * Service for downloading test artifacts and reports
+ */
+export declare class ReportDownloadService {
+    /**
+     * Download test artifacts as a zip file
+     * @param options Download configuration
+     */
+    downloadArtifacts(options: ArtifactsDownloadOptions): Promise<void>;
+    /**
+     * Handle downloading reports based on the report type specified
+     * @param options Report download configuration
+     */
+    downloadReports(options: ReportDownloadOptions): Promise<void>;
+    /**
+     * Download a specific report type
+     * @param type Report type to download
+     * @param filePath Path where report should be saved
+     * @param options Download configuration
+     */
+    private downloadReport;
+}

package/dist/services/report-download.service.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportDownloadService = void 0;
+const path = require("node:path");
+const api_gateway_1 = require("../gateways/api-gateway");
+/**
+ * Service for downloading test artifacts and reports
+ */
+class ReportDownloadService {
+    /**
+     * Download test artifacts as a zip file
+     * @param options Download configuration
+     */
+    async downloadArtifacts(options) {
+        const { apiUrl, apiKey, uploadId, downloadType, artifactsPath = './artifacts.zip', debug = false, logger, warnLogger, } = options;
+        try {
+            if (debug && logger) {
+                logger(`DEBUG: Downloading artifacts: ${downloadType}`);
+            }
+            await api_gateway_1.ApiGateway.downloadArtifactsZip(apiUrl, apiKey, uploadId, downloadType, artifactsPath);
+            if (logger) {
+                logger('\n');
+                logger(`Test artifacts have been downloaded to ${artifactsPath}`);
+            }
+        }
+        catch (error) {
+            if (debug && logger) {
+                logger(`DEBUG: Error downloading artifacts: ${error}`);
+            }
+            if (warnLogger) {
+                warnLogger('Failed to download artifacts');
+            }
+        }
+    }
+    /**
+     * Handle downloading reports based on the report type specified
+     * @param options Report download configuration
+     */
+    async downloadReports(options) {
+        const { reportType, junitPath, allurePath, htmlPath, warnLogger, ...downloadOptions } = options;
+        switch (reportType) {
+            case 'junit': {
+                const reportPath = path.resolve(process.cwd(), junitPath || 'report.xml');
+                await this.downloadReport('junit', reportPath, {
+                    ...downloadOptions,
+                    warnLogger,
+                });
+                break;
+            }
+            case 'allure': {
+                const reportPath = path.resolve(process.cwd(), allurePath || 'report.html');
+                await this.downloadReport('allure', reportPath, {
+                    ...downloadOptions,
+                    warnLogger,
+                });
+                break;
+            }
+            case 'html': {
+                const htmlReportPath = path.resolve(process.cwd(), htmlPath || 'report.html');
+                await this.downloadReport('html', htmlReportPath, {
+                    ...downloadOptions,
+                    warnLogger,
+                });
+                break;
+            }
+            default: {
+                if (warnLogger) {
+                    warnLogger(`Unknown report type: ${reportType}`);
+                }
+            }
+        }
+    }
+    /**
+     * Download a specific report type
+     * @param type Report type to download
+     * @param filePath Path where report should be saved
+     * @param options Download configuration
+     */
+    async downloadReport(type, filePath, options) {
+        const { apiUrl, apiKey, uploadId, debug = false, logger, warnLogger } = options;
+        try {
+            if (debug && logger) {
+                logger(`DEBUG: Downloading ${type.toUpperCase()} report`);
+            }
+            await api_gateway_1.ApiGateway.downloadReportGeneric(apiUrl, apiKey, uploadId, type, filePath);
+            if (logger) {
+                logger(`${type.toUpperCase()} test report has been downloaded to ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (debug && logger) {
+                logger(`DEBUG: Error downloading ${type.toUpperCase()} report: ${error}`);
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (warnLogger) {
+                warnLogger(`Failed to download ${type.toUpperCase()} report: ${errorMessage}`);
+                if (errorMessage.includes('404')) {
+                    warnLogger(`No ${type.toUpperCase()} reports found for this upload. Make sure your tests generated results.`);
+                }
+                else if (errorMessage.includes('EACCES') || errorMessage.includes('EPERM')) {
+                    warnLogger('Permission denied. Check write permissions for the current directory.');
+                }
+                else if (errorMessage.includes('ENOENT')) {
+                    warnLogger('Directory does not exist. Make sure you have write access to the current directory.');
+                }
+            }
+        }
+    }
+}
+exports.ReportDownloadService = ReportDownloadService;

package/dist/services/results-polling.service.d.ts

@@ -0,0 +1,45 @@
+import { paths } from '../types/generated/schema.types';
+type TestResult = paths['/results/{uploadId}']['get']['responses']['200']['content']['application/json']['results'][number];
+/**
+ * Custom error for run failures that includes the polling result
+ */
+export declare class RunFailedError extends Error {
+    result: PollingResult;
+    constructor(result: PollingResult);
+}
+export interface PollingOptions {
+    apiKey: string;
+    apiUrl: string;
+    consoleUrl: string;
+    debug?: boolean;
+    json?: boolean;
+    logger?: (message: string) => void;
+    quiet?: boolean;
+    uploadId: string;
+}
+export interface PollingResult {
+    consoleUrl: string;
+    status: 'FAILED' | 'PASSED';
+    tests: Array<{
+        durationSeconds: null | number;
+        failReason?: string;
+        name: string;
+        status: string;
+    }>;
+    uploadId: string;
+}
+/**
+ * Service for polling test results from the API
+ */
+export declare class ResultsPollingService {
+    private readonly MAX_SEQUENTIAL_FAILURES;
+    private readonly POLL_INTERVAL_MS;
+    /**
+     * Poll for test results until all tests complete
+     * @param results Initial test results from submission
+     * @param options Polling configuration
+     * @returns Promise that resolves with final test results or rejects if tests fail
+     */
+    pollUntilComplete(results: TestResult[], options: PollingOptions): Promise<PollingResult>;
+}
+export {};

package/dist/services/results-polling.service.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultsPollingService = exports.RunFailedError = void 0;
+const core_1 = require("@oclif/core");
+const cli_ux_1 = require("@oclif/core/lib/cli-ux");
+const api_gateway_1 = require("../gateways/api-gateway");
+const methods_1 = require("../methods");
+const connectivity_1 = require("../utils/connectivity");
+/**
+ * Custom error for run failures that includes the polling result
+ */
+class RunFailedError extends Error {
+    result;
+    constructor(result) {
+        super('RUN_FAILED');
+        this.result = result;
+        this.name = 'RunFailedError';
+    }
+}
+exports.RunFailedError = RunFailedError;
+/**
+ * Service for polling test results from the API
+ */
+class ResultsPollingService {
+    MAX_SEQUENTIAL_FAILURES = 10;
+    POLL_INTERVAL_MS = 5000;
+    /**
+     * Poll for test results until all tests complete
+     * @param results Initial test results from submission
+     * @param options Polling configuration
+     * @returns Promise that resolves with final test results or rejects if tests fail
+     */
+    async pollUntilComplete(results, options) {
+        const { apiUrl, apiKey, uploadId, consoleUrl, quiet = false, json = false, debug = false, logger } = options;
+        if (!json) {
+            core_1.ux.action.start('Waiting for results', 'Initializing', {
+                stdout: true,
+            });
+            if (logger) {
+                logger('\nYou can safely close this terminal and the tests will continue\n');
+            }
+        }
+        let sequentialPollFailures = 0;
+        let previousSummary = '';
+        if (debug && logger) {
+            logger(`DEBUG: Starting polling loop for results`);
+        }
+        return new Promise((resolve, reject) => {
+            const intervalId = setInterval(async () => {
+                try {
+                    if (debug && logger) {
+                        logger(`DEBUG: Polling for results: ${uploadId}`);
+                    }
+                    const { results: updatedResults } = await api_gateway_1.ApiGateway.getResultsForUpload(apiUrl, apiKey, uploadId);
+                    if (!updatedResults) {
+                        throw new Error('no results');
+                    }
+                    if (debug && logger) {
+                        logger(`DEBUG: Poll received ${updatedResults.length} results`);
+                        for (const result of updatedResults) {
+                            logger(`DEBUG: Result status: ${result.test_file_name} - ${result.status}`);
+                        }
+                    }
+                    // Calculate summary statistics
+                    const statusCounts = {};
+                    for (const result of updatedResults) {
+                        statusCounts[result.status] = (statusCounts[result.status] || 0) + 1;
+                    }
+                    const passed = statusCounts.PASSED || 0;
+                    const failed = statusCounts.FAILED || 0;
+                    const pending = statusCounts.PENDING || 0;
+                    const running = statusCounts.RUNNING || 0;
+                    const total = updatedResults.length;
+                    const completed = passed + failed;
+                    // Display quantitative summary in quiet mode only
+                    const summary = `${completed}/${total} | ✓ ${passed} | ✗ ${failed} | ▶ ${running} | ⏸ ${pending}`;
+                    if (!json) {
+                        if (quiet) {
+                            // Only update status when the summary changes in quiet mode
+                            if (summary !== previousSummary) {
+                                core_1.ux.action.status = summary;
+                                previousSummary = summary;
+                            }
+                        }
+                        else {
+                            // Show detailed table in non-quiet mode (no summary)
+                            core_1.ux.action.status =
+                                '\nStatus      Test\n─────────── ───────────────';
+                            for (const { retry_of: isRetry, status, test_file_name: test, } of updatedResults) {
+                                core_1.ux.action.status += `\n${status.padEnd(10, ' ')}  ${test} ${isRetry ? '(retry)' : ''}`;
+                            }
+                        }
+                    }
+                    if (updatedResults.every((result) => !['PENDING', 'RUNNING'].includes(result.status))) {
+                        if (debug && logger) {
+                            logger(`DEBUG: All tests completed, stopping poll`);
+                        }
+                        if (!json) {
+                            core_1.ux.action.stop('completed');
+                            if (logger) {
+                                logger('\n');
+                            }
+                            const hasFailedTests = updatedResults.some((result) => result.status === 'FAILED');
+                            (0, cli_ux_1.table)(updatedResults, {
+                                status: { get: (row) => row.status },
+                                test: {
+                                    get: (row) => `${row.test_file_name} ${row.retry_of ? '(retry)' : ''}`,
+                                },
+                                duration: {
+                                    get: (row) => row.duration_seconds
+                                        ? (0, methods_1.formatDurationSeconds)(Number(row.duration_seconds))
+                                        : '-',
+                                },
+                                ...(hasFailedTests && {
+                                    // eslint-disable-next-line camelcase
+                                    fail_reason: {
+                                        get: (row) => row.status === 'FAILED' && row.fail_reason
+                                            ? row.fail_reason
+                                            : '',
+                                    },
+                                }),
+                            }, { printLine: logger });
+                            if (logger) {
+                                logger('\n');
+                                logger('Run completed, you can access the results at:');
+                                logger(consoleUrl);
+                                logger('\n');
+                            }
+                        }
+                        clearInterval(intervalId);
+                        const resultsWithoutEarlierTries = updatedResults.filter((result) => {
+                            const originalTryId = result.retry_of || result.id;
+                            const tries = updatedResults.filter((r) => r.retry_of === originalTryId || r.id === originalTryId);
+                            return result.id === Math.max(...tries.map((t) => t.id));
+                        });
+                        const output = {
+                            consoleUrl,
+                            status: resultsWithoutEarlierTries.some((result) => result.status === 'FAILED')
+                                ? 'FAILED'
+                                : 'PASSED',
+                            tests: resultsWithoutEarlierTries.map((r) => ({
+                                durationSeconds: r.duration_seconds,
+                                failReason: r.status === 'FAILED'
+                                    ? r.fail_reason || 'No reason provided'
+                                    : undefined,
+                                name: r.test_file_name,
+                                status: r.status,
+                            })),
+                            uploadId,
+                        };
+                        if (output.status === 'FAILED') {
+                            if (debug && logger) {
+                                logger(`DEBUG: Some tests failed, returning failed status`);
+                            }
+                            reject(new RunFailedError(output));
+                        }
+                        else {
+                            if (debug && logger) {
+                                logger(`DEBUG: All tests passed, returning success status`);
+                            }
+                            sequentialPollFailures = 0;
+                            resolve(output);
+                        }
+                    }
+                }
+                catch (error) {
+                    sequentialPollFailures++;
+                    if (debug && logger) {
+                        logger(`DEBUG: Error polling for results: ${error}`);
+                        logger(`DEBUG: Sequential poll failures: ${sequentialPollFailures}`);
+                    }
+                    if (sequentialPollFailures > this.MAX_SEQUENTIAL_FAILURES) {
+                        // dropped poll requests shouldn't err user CI
+                        clearInterval(intervalId);
+                        // Check if the failure is due to internet connectivity issues
+                        if (debug && logger) {
+                            logger('DEBUG: Checking internet connectivity...');
+                        }
+                        const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
+                        if (debug && logger) {
+                            logger(`DEBUG: ${connectivityCheck.message}`);
+                            for (const result of connectivityCheck.endpointResults) {
+                                if (result.success) {
+                                    logger(`DEBUG: ✓ ${result.endpoint} - ${result.statusCode} (${result.latencyMs}ms)`);
+                                }
+                                else {
+                                    logger(`DEBUG: ✗ ${result.endpoint} - ${result.error} (${result.latencyMs}ms)`);
+                                }
+                            }
+                        }
+                        if (!connectivityCheck.connected) {
+                            // Build detailed error message with endpoint diagnostics
+                            const endpointDetails = connectivityCheck.endpointResults
+                                .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
+                                .join('\n');
+                            reject(new Error(`Unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts.\n\nInternet connectivity check failed - all test endpoints unreachable:\n${endpointDetails}\n\nPlease verify your network connection and DNS resolution.`));
+                            return;
+                        }
+                        reject(new Error(`unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts`));
+                        return;
+                    }
+                    if (logger) {
+                        logger('unable to fetch results, trying again...');
+                    }
+                }
+            }, this.POLL_INTERVAL_MS);
+        });
+    }
+}
+exports.ResultsPollingService = ResultsPollingService;