@appium/base-driver 9.3.2 → 9.3.4

package/build/lib/basedriver/helpers.d.ts

@@ -1,112 +1,34 @@
-declare const _default: import("@appium/types").DriverHelpers<any>;
+declare const _default: import('@appium/types').DriverHelpers;
 export default _default;
-export type PostProcessOptions = {
-    /**
-     * The information about the previously cached app instance (if exists):
-     * - packageHash: SHA1 hash of the package if it is a file and not a folder
-     * - lastModified: Optional Date instance, the value of file's `Last-Modified` header
-     * - immutable: Optional boolean value. Contains true if the file has an `immutable` mark
-     * in `Cache-control` header
-     * - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header
-     * - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch
-     * milliseconds)
-     * - integrity: An object containing either `file` property with SHA1 hash of the file
-     * or `folder` property with total amount of cached files and subfolders
-     * - fullPath: the full path to the cached app
-     */
-    cachedAppInfo: any | null;
-    /**
-     * Whether the app has been downloaded from a remote URL
-     */
-    isUrl: boolean;
-    /**
-     * Optional headers object. Only present if `isUrl` is true and if the server
-     * responds to HEAD requests. All header names are normalized to lowercase.
-     */
-    headers: any | null;
-    /**
-     * A string containing full path to the preprocessed application package (either
-     * downloaded or a local one)
-     */
-    appPath: string;
+export type RemoteAppProps = {
+    lastModified: Date | null;
+    immutable: boolean;
+    maxAge: number | null;
+    etag: string | null;
 };
-export type PostProcessResult = {
+/**
+ * Properties of the remote application (e.g. GET HTTP response) to be downloaded.
+ */
+export type RemoteAppData = {
     /**
-     * The full past to the post-processed application package on the
-     * local file system (might be a file or a folder path)
+     * The HTTP status of the response
      */
-    appPath: string;
-};
-export type ConfigureAppOptions = {
+    status: number;
     /**
-     * Optional function, which should be applied
-     * to the application after it is downloaded/preprocessed. This function may be async
-     * and is expected to accept single object parameter.
-     * The function is expected to either return a falsy value, which means the app must not be
-     * cached and a fresh copy of it is downloaded each time. If this function returns an object
-     * containing `appPath` property then the integrity of it will be verified and stored into
-     * the cache.
+     * The HTTP response body represented as readable stream
      */
-    onPostProcess?: ((obj: PostProcessOptions) => (Promise<PostProcessResult | undefined> | PostProcessResult | undefined)) | undefined;
+    stream: import('stream').Readable;
     /**
-     * List of supported application extensions (
-     * including starting dots). This property is mandatory and must not be empty.
+     * HTTP response headers
      */
-    supportedExtensions: string[];
-};
-export type RemoteAppProps = {
-    lastModified: Date | null;
-    immutable: boolean;
-    maxAge: number | null;
+    headers: import('axios').RawAxiosResponseHeaders | import('axios').AxiosResponseHeaders;
 };
 /**
- * @typedef PostProcessOptions
- * @property {?Object} cachedAppInfo The information about the previously cached app instance (if exists):
- *    - packageHash: SHA1 hash of the package if it is a file and not a folder
- *    - lastModified: Optional Date instance, the value of file's `Last-Modified` header
- *    - immutable: Optional boolean value. Contains true if the file has an `immutable` mark
- *                 in `Cache-control` header
- *    - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header
- *    - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch
- *                 milliseconds)
- *    - integrity: An object containing either `file` property with SHA1 hash of the file
- *                 or `folder` property with total amount of cached files and subfolders
- *    - fullPath: the full path to the cached app
- * @property {boolean} isUrl Whether the app has been downloaded from a remote URL
- * @property {?Object} headers Optional headers object. Only present if `isUrl` is true and if the server
- * responds to HEAD requests. All header names are normalized to lowercase.
- * @property {string} appPath A string containing full path to the preprocessed application package (either
- * downloaded or a local one)
- */
-/**
- * @typedef PostProcessResult
- * @property {string} appPath The full past to the post-processed application package on the
- * local file system (might be a file or a folder path)
- */
-/**
- * @typedef ConfigureAppOptions
- * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} [onPostProcess]
- * Optional function, which should be applied
- * to the application after it is downloaded/preprocessed. This function may be async
- * and is expected to accept single object parameter.
- * The function is expected to either return a falsy value, which means the app must not be
- * cached and a fresh copy of it is downloaded each time. If this function returns an object
- * containing `appPath` property then the integrity of it will be verified and stored into
- * the cache.
- * @property {string[]} supportedExtensions List of supported application extensions (
- * including starting dots). This property is mandatory and must not be empty.
- */
-/**
- * Prepares an app to be used in an automated test. The app gets cached automatically
- * if it is an archive or if it is downloaded from an URL.
- * If the downloaded app has `.zip` extension, this method will unzip it.
- * The unzip does not work when `onPostProcess` is provided.
  *
- * @param {string} app Either a full path to the app or a remote URL
- * @param {string|string[]|ConfigureAppOptions} options
- * @returns The full path to the resulting application bundle
+ * @param {string} app
+ * @param {string|string[]|import('@appium/types').ConfigureAppOptions} options
  */
-export function configureApp(app: string, options?: string | string[] | ConfigureAppOptions): Promise<any>;
+export function configureApp(app: string, options?: string | string[] | import('@appium/types').ConfigureAppOptions): Promise<any>;
 export function isPackageOrBundle(app: any): boolean;
 /**
  * Finds all instances 'firstKey' and create a duplicate with the key 'secondKey',
@@ -133,5 +55,6 @@ export function parseCapsArray(cap: string | Array<string>): any[];
  * @param {string?} sessionId session identifier (if exists)
  * @returns {string}
  */
-export function generateDriverLogPrefix(obj: import('@appium/types').Core, sessionId?: string | null): string;
+export function generateDriverLogPrefix(obj: import("@appium/types").Core<any, import("@appium/types").StringRecord<any>>, sessionId?: string | null): string;
+export const BASEDRIVER_VER: string;
 //# sourceMappingURL=helpers.d.ts.map

package/build/lib/basedriver/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/helpers.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;WA8Kc,OAAO;;;;;;;;;;aAGP,MAAM;;;;;;;aAMN,MAAM;;;;;;;;;;;;2BAMA,kBAAkB,KAAK,CAAC,QAAQ,iBAAiB,GAAC,SAAS,CAAC,GAAC,iBAAiB,GAAC,SAAS,CAAC;;;;;yBAQ/F,MAAM,EAAE;;;kBA+ZR,IAAI;eACJ,OAAO;YACP,MAAM;;AArcpB;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;GASG;AACH,kCAJW,MAAM,YACN,MAAM,GAAC,MAAM,EAAE,GAAC,mBAAmB,gBA6N7C;AA8FD,qDAEC;AAED;;;;;;;;;GASG;AACH,oFAuBC;AAED;;;;;GAKG;AACH,oCAFW,MAAM,GAAC,aAAa,SAoB9B;AAED;;;;;;GAMG;AACH,6CAJW,OAAO,eAAe,EAAE,IAAI,cAC5B,MAAM,UACJ,MAAM,CAKlB"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../lib/basedriver/helpers.js"],"names":[],"mappings":"wBA2kBW,OAAO,eAAe,EAAE,aAAa;;;kBAmBlC,IAAI;eACJ,OAAO;YACP,MAAM;UACN,MAAM;;;;;;;;;YAKN,MAAM;;;;YACN,OAAO,QAAQ,EAAE,QAAQ;;;;aACzB,OAAO,OAAO,EAAE,uBAAuB,GAAG,OAAO,OAAO,EAAE,oBAAoB;;AAtgB5F;;;;GAIG;AACH,kCAHW,MAAM,YACN,MAAM,GAAC,MAAM,EAAE,GAAC,OAAO,eAAe,EAAE,mBAAmB,gBA6PrE;AA4JD,qDAEC;AAED;;;;;;;;;GASG;AACH,oFAuBC;AAED;;;;;GAKG;AACH,oCAFW,MAAM,GAAC,aAAa,SAoB9B;AAED;;;;;;GAMG;AACH,uIAHW,MAAM,UACJ,MAAM,CAKlB"}

package/build/lib/basedriver/helpers.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDriverLogPrefix = exports.parseCapsArray = exports.duplicateKeys = exports.isPackageOrBundle = exports.configureApp = void 0;
+exports.BASEDRIVER_VER = exports.generateDriverLogPrefix = exports.parseCapsArray = exports.duplicateKeys = exports.isPackageOrBundle = exports.configureApp = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const path_1 = __importDefault(require("path"));
 const url_1 = __importDefault(require("url"));
@@ -12,11 +12,20 @@ const support_1 = require("@appium/support");
 const lru_cache_1 = __importDefault(require("lru-cache"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const axios_1 = __importDefault(require("axios"));
+const bluebird_1 = __importDefault(require("bluebird"));
+// for compat with running tests transpiled and in-place
+const { version: BASEDRIVER_VER } = support_1.fs.readPackageJsonFrom(__dirname);
+exports.BASEDRIVER_VER = BASEDRIVER_VER;
 const IPA_EXT = '.ipa';
-const ZIP_EXTS = ['.zip', IPA_EXT];
+const ZIP_EXTS = new Set(['.zip', IPA_EXT]);
 const ZIP_MIME_TYPES = ['application/zip', 'application/x-zip-compressed', 'multipart/x-zip'];
 const CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms
 const MAX_CACHED_APPS = 1024;
+const HTTP_STATUS_NOT_MODIFIED = 304;
+const DEFAULT_REQ_HEADERS = Object.freeze({
+    'user-agent': `Appium (BaseDriver v${BASEDRIVER_VER})`,
+});
+const AVG_DOWNLOAD_SPEED_MEASUREMENT_THRESHOLD_SEC = 2;
 const APPLICATIONS_CACHE = new lru_cache_1.default({
     max: MAX_CACHED_APPS,
     ttl: CACHED_APPS_MAX_AGE,
@@ -51,65 +60,6 @@ process.on('exit', () => {
         }
     }
 });
-/**
- *
- * @param {string} url
- * @returns {Promise<import('axios').AxiosResponse['headers']>}
- */
-async function retrieveHeaders(url) {
-    try {
-        return (await (0, axios_1.default)({
-            url,
-            method: 'HEAD',
-            timeout: 5000,
-        })).headers;
-    }
-    catch (e) {
-        logger_1.default.info(`Cannot send HEAD request to '${url}'. Original error: ${e.message}`);
-    }
-    return {};
-}
-function getCachedApplicationPath(link, currentAppProps = {}, cachedAppInfo = {}) {
-    const refresh = () => {
-        logger_1.default.debug(`A fresh copy of the application is going to be downloaded from ${link}`);
-        return null;
-    };
-    if (!lodash_1.default.isPlainObject(cachedAppInfo) || !lodash_1.default.isPlainObject(currentAppProps)) {
-        // if an invalid arg is passed then assume cache miss
-        return refresh();
-    }
-    const { lastModified: currentModified, immutable: currentImmutable, 
-    // maxAge is in seconds
-    maxAge: currentMaxAge, } = currentAppProps;
-    const { 
-    // Date instance
-    lastModified, 
-    // boolean
-    immutable, 
-    // Unix time in milliseconds
-    timestamp, fullPath, } = cachedAppInfo;
-    if (lastModified && currentModified) {
-        if (currentModified.getTime() <= lastModified.getTime()) {
-            logger_1.default.debug(`The application at ${link} has not been modified since ${lastModified}`);
-            return fullPath;
-        }
-        logger_1.default.debug(`The application at ${link} has been modified since ${lastModified}`);
-        return refresh();
-    }
-    if (immutable && currentImmutable) {
-        logger_1.default.debug(`The application at ${link} is immutable`);
-        return fullPath;
-    }
-    if (currentMaxAge && timestamp) {
-        const msLeft = timestamp + currentMaxAge * 1000 - Date.now();
-        if (msLeft > 0) {
-            logger_1.default.debug(`The cached application '${path_1.default.basename(fullPath)}' will expire in ${msLeft / 1000}s`);
-            return fullPath;
-        }
-        logger_1.default.debug(`The cached application '${path_1.default.basename(fullPath)}' has expired`);
-    }
-    return refresh();
-}
 function verifyAppExtension(app, supportedAppExtensions) {
     if (supportedAppExtensions.map(lodash_1.default.toLower).includes(lodash_1.default.toLower(path_1.default.extname(app)))) {
         return app;
@@ -140,53 +90,11 @@ async function isAppIntegrityOk(currentPath, expectedIntegrity = {}) {
         : (await calculateFileIntegrity(currentPath)) === expectedIntegrity?.file;
 }
 /**
- * @typedef PostProcessOptions
- * @property {?Object} cachedAppInfo The information about the previously cached app instance (if exists):
- *    - packageHash: SHA1 hash of the package if it is a file and not a folder
- *    - lastModified: Optional Date instance, the value of file's `Last-Modified` header
- *    - immutable: Optional boolean value. Contains true if the file has an `immutable` mark
- *                 in `Cache-control` header
- *    - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header
- *    - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch
- *                 milliseconds)
- *    - integrity: An object containing either `file` property with SHA1 hash of the file
- *                 or `folder` property with total amount of cached files and subfolders
- *    - fullPath: the full path to the cached app
- * @property {boolean} isUrl Whether the app has been downloaded from a remote URL
- * @property {?Object} headers Optional headers object. Only present if `isUrl` is true and if the server
- * responds to HEAD requests. All header names are normalized to lowercase.
- * @property {string} appPath A string containing full path to the preprocessed application package (either
- * downloaded or a local one)
- */
-/**
- * @typedef PostProcessResult
- * @property {string} appPath The full past to the post-processed application package on the
- * local file system (might be a file or a folder path)
- */
-/**
- * @typedef ConfigureAppOptions
- * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} [onPostProcess]
- * Optional function, which should be applied
- * to the application after it is downloaded/preprocessed. This function may be async
- * and is expected to accept single object parameter.
- * The function is expected to either return a falsy value, which means the app must not be
- * cached and a fresh copy of it is downloaded each time. If this function returns an object
- * containing `appPath` property then the integrity of it will be verified and stored into
- * the cache.
- * @property {string[]} supportedExtensions List of supported application extensions (
- * including starting dots). This property is mandatory and must not be empty.
- */
-/**
- * Prepares an app to be used in an automated test. The app gets cached automatically
- * if it is an archive or if it is downloaded from an URL.
- * If the downloaded app has `.zip` extension, this method will unzip it.
- * The unzip does not work when `onPostProcess` is provided.
  *
- * @param {string} app Either a full path to the app or a remote URL
- * @param {string|string[]|ConfigureAppOptions} options
- * @returns The full path to the resulting application bundle
+ * @param {string} app
+ * @param {string|string[]|import('@appium/types').ConfigureAppOptions} options
  */
-async function configureApp(app, options = /** @type {ConfigureAppOptions} */ ({})) {
+async function configureApp(app, options = /** @type {import('@appium/types').ConfigureAppOptions} */ ({})) {
     if (!lodash_1.default.isString(app)) {
         // immediately shortcircuit if not given an app
         return;
@@ -208,13 +116,14 @@ async function configureApp(app, options = /** @type {ConfigureAppOptions} */ ({
     let newApp = app;
     let shouldUnzipApp = false;
     let packageHash = null;
-    /** @type {import('axios').AxiosResponse['headers']?} */
-    let headers = null;
+    /** @type {import('axios').AxiosResponse['headers']|undefined} */
+    let headers = undefined;
     /** @type {RemoteAppProps} */
     const remoteAppProps = {
         lastModified: null,
         immutable: false,
         maxAge: null,
+        etag: null,
     };
     const { protocol, pathname } = url_1.default.parse(newApp);
     const isUrl = protocol === null ? false : ['http:', 'https:'].includes(protocol);
@@ -223,86 +132,109 @@ async function configureApp(app, options = /** @type {ConfigureAppOptions} */ ({
         if (isUrl) {
             // Use the app from remote URL
             logger_1.default.info(`Using downloadable app '${newApp}'`);
-            headers = await retrieveHeaders(newApp);
-            if (!lodash_1.default.isEmpty(headers)) {
-                if (headers['last-modified']) {
-                    remoteAppProps.lastModified = new Date(headers['last-modified']);
+            const reqHeaders = {
+                ...DEFAULT_REQ_HEADERS,
+            };
+            if (cachedAppInfo?.etag) {
+                reqHeaders['if-none-match'] = remoteAppProps.etag;
+            }
+            else if (cachedAppInfo?.lastModified) {
+                reqHeaders['if-modified-since'] = remoteAppProps.lastModified?.toString();
+            }
+            let { headers, stream, status } = await queryAppLink(newApp, reqHeaders);
+            try {
+                if (!lodash_1.default.isEmpty(headers)) {
+                    logger_1.default.debug(`Etag: ${remoteAppProps?.etag} -> ${headers.etag}`);
+                    if (headers.etag) {
+                        remoteAppProps.etag = headers.etag;
+                    }
+                    logger_1.default.debug(`Last-Modified: ${remoteAppProps?.['last-modified']} -> ${headers['last-modified']}`);
+                    if (headers['last-modified']) {
+                        remoteAppProps.lastModified = new Date(headers['last-modified']);
+                    }
+                    logger_1.default.debug(`Cache-Control: ${remoteAppProps?.['cache-control']} -> ${headers['cache-control']}`);
+                    if (headers['cache-control']) {
+                        remoteAppProps.immutable = /\bimmutable\b/i.test(headers['cache-control']);
+                        const maxAgeMatch = /\bmax-age=(\d+)\b/i.exec(headers['cache-control']);
+                        if (maxAgeMatch) {
+                            remoteAppProps.maxAge = parseInt(maxAgeMatch[1], 10);
+                        }
+                    }
                 }
-                logger_1.default.debug(`Last-Modified: ${headers['last-modified']}`);
-                if (headers['cache-control']) {
-                    remoteAppProps.immutable = /\bimmutable\b/i.test(headers['cache-control']);
-                    const maxAgeMatch = /\bmax-age=(\d+)\b/i.exec(headers['cache-control']);
-                    if (maxAgeMatch) {
-                        remoteAppProps.maxAge = parseInt(maxAgeMatch[1], 10);
+                if (cachedAppInfo && status === HTTP_STATUS_NOT_MODIFIED) {
+                    if (await isAppIntegrityOk(cachedAppInfo.fullPath, cachedAppInfo.integrity)) {
+                        logger_1.default.info(`Reusing previously downloaded application at '${cachedAppInfo.fullPath}'`);
+                        return verifyAppExtension(cachedAppInfo.fullPath, supportedAppExtensions);
+                    }
+                    logger_1.default.info(`The application at '${cachedAppInfo.fullPath}' does not exist anymore ` +
+                        `or its integrity has been damaged. Deleting it from the internal cache`);
+                    APPLICATIONS_CACHE.delete(app);
+                    if (!stream.closed) {
+                        stream.destroy();
                     }
+                    ({ stream, headers, status } = await queryAppLink(newApp, { ...DEFAULT_REQ_HEADERS }));
                 }
-                logger_1.default.debug(`Cache-Control: ${headers['cache-control']}`);
-            }
-            const cachedPath = getCachedApplicationPath(app, remoteAppProps, cachedAppInfo);
-            if (cachedPath) {
-                if (await isAppIntegrityOk(cachedPath, cachedAppInfo?.integrity)) {
-                    logger_1.default.info(`Reusing previously downloaded application at '${cachedPath}'`);
-                    return verifyAppExtension(cachedPath, supportedAppExtensions);
+                let fileName = null;
+                const basename = support_1.fs.sanitizeName(path_1.default.basename(decodeURIComponent(pathname ?? '')), {
+                    replacement: SANITIZE_REPLACEMENT,
+                });
+                const extname = path_1.default.extname(basename);
+                // to determine if we need to unzip the app, we have a number of places
+                // to look: content type, content disposition, or the file extension
+                if (ZIP_EXTS.has(extname)) {
+                    fileName = basename;
+                    shouldUnzipApp = true;
                 }
-                logger_1.default.info(`The application at '${cachedPath}' does not exist anymore ` +
-                    `or its integrity has been damaged. Deleting it from the internal cache`);
-                APPLICATIONS_CACHE.delete(app);
-            }
-            let fileName = null;
-            const basename = support_1.fs.sanitizeName(path_1.default.basename(decodeURIComponent(pathname ?? '')), {
-                replacement: SANITIZE_REPLACEMENT,
-            });
-            const extname = path_1.default.extname(basename);
-            // to determine if we need to unzip the app, we have a number of places
-            // to look: content type, content disposition, or the file extension
-            if (ZIP_EXTS.includes(extname)) {
-                fileName = basename;
-                shouldUnzipApp = true;
-            }
-            if (headers['content-type']) {
-                const ct = headers['content-type'];
-                logger_1.default.debug(`Content-Type: ${ct}`);
-                // the filetype may not be obvious for certain urls, so check the mime type too
-                if (ZIP_MIME_TYPES.some((mimeType) => new RegExp(`\\b${lodash_1.default.escapeRegExp(mimeType)}\\b`).test(ct))) {
-                    if (!fileName) {
-                        fileName = `${DEFAULT_BASENAME}.zip`;
+                if (headers['content-type']) {
+                    const ct = headers['content-type'];
+                    logger_1.default.debug(`Content-Type: ${ct}`);
+                    // the filetype may not be obvious for certain urls, so check the mime type too
+                    if (ZIP_MIME_TYPES.some((mimeType) => new RegExp(`\\b${lodash_1.default.escapeRegExp(mimeType)}\\b`).test(ct))) {
+                        if (!fileName) {
+                            fileName = `${DEFAULT_BASENAME}.zip`;
+                        }
+                        shouldUnzipApp = true;
                     }
-                    shouldUnzipApp = true;
                 }
-            }
-            if (headers['content-disposition'] && /^attachment/i.test(headers['content-disposition'])) {
-                logger_1.default.debug(`Content-Disposition: ${headers['content-disposition']}`);
-                const match = /filename="([^"]+)/i.exec(headers['content-disposition']);
-                if (match) {
-                    fileName = support_1.fs.sanitizeName(match[1], {
-                        replacement: SANITIZE_REPLACEMENT,
-                    });
-                    shouldUnzipApp = shouldUnzipApp || ZIP_EXTS.includes(path_1.default.extname(fileName));
+                if (headers['content-disposition'] && /^attachment/i.test(headers['content-disposition'])) {
+                    logger_1.default.debug(`Content-Disposition: ${headers['content-disposition']}`);
+                    const match = /filename="([^"]+)/i.exec(headers['content-disposition']);
+                    if (match) {
+                        fileName = support_1.fs.sanitizeName(match[1], {
+                            replacement: SANITIZE_REPLACEMENT,
+                        });
+                        shouldUnzipApp = shouldUnzipApp || ZIP_EXTS.has(path_1.default.extname(fileName));
+                    }
                 }
+                if (!fileName) {
+                    // assign the default file name and the extension if none has been detected
+                    const resultingName = basename
+                        ? basename.substring(0, basename.length - extname.length)
+                        : DEFAULT_BASENAME;
+                    let resultingExt = extname;
+                    if (!supportedAppExtensions.includes(resultingExt)) {
+                        logger_1.default.info(`The current file extension '${resultingExt}' is not supported. ` +
+                            `Defaulting to '${lodash_1.default.first(supportedAppExtensions)}'`);
+                        resultingExt = /** @type {string} */ (lodash_1.default.first(supportedAppExtensions));
+                    }
+                    fileName = `${resultingName}${resultingExt}`;
+                }
+                const targetPath = await support_1.tempDir.path({
+                    prefix: fileName,
+                    suffix: '',
+                });
+                newApp = await fetchApp(stream, targetPath);
             }
-            if (!fileName) {
-                // assign the default file name and the extension if none has been detected
-                const resultingName = basename
-                    ? basename.substring(0, basename.length - extname.length)
-                    : DEFAULT_BASENAME;
-                let resultingExt = extname;
-                if (!supportedAppExtensions.includes(resultingExt)) {
-                    logger_1.default.info(`The current file extension '${resultingExt}' is not supported. ` +
-                        `Defaulting to '${lodash_1.default.first(supportedAppExtensions)}'`);
-                    resultingExt = /** @type {string} */ (lodash_1.default.first(supportedAppExtensions));
+            finally {
+                if (!stream.closed) {
+                    stream.destroy();
                 }
-                fileName = `${resultingName}${resultingExt}`;
             }
-            const targetPath = await support_1.tempDir.path({
-                prefix: fileName,
-                suffix: '',
-            });
-            newApp = await downloadApp(newApp, targetPath);
         }
         else if (await support_1.fs.exists(newApp)) {
             // Use the local app
             logger_1.default.info(`Using local app '${newApp}'`);
-            shouldUnzipApp = ZIP_EXTS.includes(path_1.default.extname(newApp));
+            shouldUnzipApp = ZIP_EXTS.has(path_1.default.extname(newApp));
         }
         else {
             let errorMessage = `The application at '${newApp}' does not exist or is not accessible`;
@@ -372,12 +304,13 @@ async function configureApp(app, options = /** @type {ConfigureAppOptions} */ ({
             return appPathToCache;
         };
         if (lodash_1.default.isFunction(onPostProcess)) {
-            const result = await onPostProcess({
+            const result = await onPostProcess(
+            /** @type {import('@appium/types').PostProcessOptions<import('axios').AxiosResponseHeaders>} */ ({
                 cachedAppInfo: lodash_1.default.clone(cachedAppInfo),
                 isUrl,
                 headers: lodash_1.default.clone(headers),
                 appPath: newApp,
-            });
+            }));
             return !result?.appPath || app === result?.appPath || !(await support_1.fs.exists(result?.appPath))
                 ? newApp
                 : await storeAppInCache(result.appPath);
@@ -389,17 +322,73 @@ async function configureApp(app, options = /** @type {ConfigureAppOptions} */ ({
     });
 }
 exports.configureApp = configureApp;
-async function downloadApp(app, targetPath) {
-    const { href } = url_1.default.parse(app);
+/**
+ * Sends a HTTP GET query to fetch the app with caching enabled.
+ * Follows https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching
+ *
+ * @param {string} appLink The URL to download an app from
+ * @param {import('axios').RawAxiosRequestHeaders} reqHeaders Additional HTTP request headers
+ * @returns {Promise<RemoteAppData>}
+ */
+async function queryAppLink(appLink, reqHeaders) {
+    const { href } = url_1.default.parse(appLink);
+    /**
+     * @type {import('axios').RawAxiosRequestConfig}
+     */
+    const requestOpts = {
+        url: href,
+        responseType: 'stream',
+        timeout: APP_DOWNLOAD_TIMEOUT_MS,
+        validateStatus: (status) => (status >= 200 && status < 300) || status === HTTP_STATUS_NOT_MODIFIED,
+        headers: reqHeaders,
+    };
     try {
-        await support_1.net.downloadFile(href, targetPath, {
-            timeout: APP_DOWNLOAD_TIMEOUT_MS,
+        const { data: stream, headers, status } = await (0, axios_1.default)(requestOpts);
+        return {
+            stream,
+            headers,
+            status,
+        };
+    }
+    catch (err) {
+        throw new Error(`Cannot download the app from ${href}: ${err.message}`);
+    }
+}
+/**
+ * Retrieves app payload from the given stream. Also meters the download performance.
+ *
+ * @param {import('stream').Readable} srcStream The incoming stream
+ * @param {string} dstPath The target file path to be written
+ * @returns {Promise<string>} The same dstPath
+ * @throws {Error} If there was a failure while downloading the file
+ */
+async function fetchApp(srcStream, dstPath) {
+    const timer = new support_1.timing.Timer().start();
+    try {
+        const writer = support_1.fs.createWriteStream(dstPath);
+        srcStream.pipe(writer);
+        await new bluebird_1.default((resolve, reject) => {
+            srcStream.once('error', reject);
+            writer.once('finish', resolve);
+            writer.once('error', (e) => {
+                srcStream.unpipe(writer);
+                reject(e);
+            });
         });
     }
     catch (err) {
-        throw new Error(`Unable to download the app: ${err.message}`);
+        throw new Error(`Cannot fetch the application: ${err.message}`);
     }
-    return targetPath;
+    const secondsElapsed = timer.getDuration().asSeconds;
+    const { size } = await support_1.fs.stat(dstPath);
+    logger_1.default.debug(`The application (${support_1.util.toReadableSizeString(size)}) ` +
+        `has been downloaded to '${dstPath}' in ${secondsElapsed.toFixed(3)}s`);
+    // it does not make much sense to approximate the speed for short downloads
+    if (secondsElapsed >= AVG_DOWNLOAD_SPEED_MEASUREMENT_THRESHOLD_SEC) {
+        const bytesPerSec = Math.floor(size / secondsElapsed);
+        logger_1.default.debug(`Approximate download speed: ${support_1.util.toReadableSizeString(bytesPerSec)}/s`);
+    }
+    return dstPath;
 }
 /**
  * Extracts the bundle from an archive into the given folder
@@ -553,5 +542,12 @@ exports.default = {
  * @property {Date?} lastModified
  * @property {boolean} immutable
  * @property {number?} maxAge
+ * @property {string?} etag
+ */
+/**
+ * @typedef RemoteAppData Properties of the remote application (e.g. GET HTTP response) to be downloaded.
+ * @property {number} status The HTTP status of the response
+ * @property {import('stream').Readable} stream The HTTP response body represented as readable stream
+ * @property {import('axios').RawAxiosResponseHeaders | import('axios').AxiosResponseHeaders} headers HTTP response headers
  */
 //# sourceMappingURL=helpers.js.map