Add upload progress tracking feature to LambdaTest plugin

ritwickrajmakhal · ritwickrajmakhal · commit b9f1fba0d6be · 2025-10-08T19:09:13.000+05:30
- Introduced `showUploadProgress` option in tasks and uploaders to enable console progress tracking during file uploads.
- Updated `UploaderUtil` to support progress tracking with a new `uploadAndGetId` method.
- Implemented `ProgressRequestBody` to handle progress updates and display them in the console.
- Modified relevant classes to accommodate the new progress tracking functionality.
diff --git a/README.md b/README.md
@@ -39,6 +39,7 @@ runLambdaTest {
     isFlutter = true //if you are running flutter dart tests
     appId = "lt//1234343" //provide this only if you have already uploaded the app
     testSuiteId = "lt//1223444" //provide this only if you have already uploaded the app
+    showUploadProgress = true //enable upload progress tracking in console
 }
 ```
 
@@ -50,6 +51,7 @@ uploadApkToLambdaTest {
     accessKey = 'yourLambdaTestAccessKey'
     appFilePath = 'pathToYourAppFile'
     testSuiteFilePath = 'pathToYourTestSuite'
+    showUploadProgress = true //enable upload progress tracking in console
 }
 ```
 
@@ -68,6 +70,7 @@ The following capabilities are supported:
 - `build`: Set the name of the Espresso test build. Example: My Espresso Build.
 - `geoLocation`: Set the geolocation country code if you want to enable the same in your test. Example - FR.
 - `tunnel`, `tunnelName`: Set tunnel as true and provide the tunnelName such as NewTunnel as needed if you are running a tunnel.
+- `showUploadProgress`: Display real-time upload progress in the console with percentage and data transferred. Example: true.
 
 - `appFilePath` : Path of your app file (this will be uploaded to LambdaTest)
 
diff --git a/build.gradle b/build.gradle
@@ -4,7 +4,7 @@ plugins {
     id 'com.diffplug.spotless' version '6.25.0'
 }
 
-version = '1.0.6'
+version = '1.0.7'
 group = 'io.github.lambdatest'
 
 repositories {
diff --git a/src/main/java/io/github/lambdatest/gradle/AppUploader.java b/src/main/java/io/github/lambdatest/gradle/AppUploader.java
@@ -19,6 +19,7 @@ public class AppUploader {
     private String username;
     private String accessKey;
     private String appFilePath;
+    private boolean showProgress;
 
     /**
      * Creates a new AppUploader instance with the specified credentials and file path.
@@ -28,13 +29,28 @@ public class AppUploader {
      * @param appFilePath The path to the application file to be uploaded
      */
     public AppUploader(String username, String accessKey, String appFilePath) {
+        this(username, accessKey, appFilePath, false);
+    }
+
+    /**
+     * Creates a new AppUploader instance with the specified credentials, file path, and progress
+     * tracking option.
+     *
+     * @param username The LambdaTest account username
+     * @param accessKey The LambdaTest account access key
+     * @param appFilePath The path to the application file to be uploaded
+     * @param showProgress Whether to display upload progress in the console
+     */
+    public AppUploader(
+            String username, String accessKey, String appFilePath, boolean showProgress) {
         if (username == null) throw new IllegalArgumentException("Username cannot be null");
         if (accessKey == null) throw new IllegalArgumentException("Access Key cannot be null");
         if (appFilePath == null) throw new IllegalArgumentException("App File Path cannot be null");
 
         this.username = username;
         this.accessKey = accessKey;
         this.appFilePath = appFilePath;
+        this.showProgress = showProgress;
     }
 
     /**
@@ -49,7 +65,8 @@ public CompletableFuture<String> uploadAppAsync() {
                 () -> {
                     try {
                         String appId =
-                                UploaderUtil.uploadAndGetId(username, accessKey, appFilePath);
+                                UploaderUtil.uploadAndGetId(
+                                        username, accessKey, appFilePath, showProgress);
                         logger.info("Uploaded app ID: {}", appId);
                         return appId;
                     } catch (IOException e) {
diff --git a/src/main/java/io/github/lambdatest/gradle/LambdaTestTask.java b/src/main/java/io/github/lambdatest/gradle/LambdaTestTask.java
@@ -45,6 +45,7 @@ public class LambdaTestTask extends DefaultTask {
     private String appId;
     private String testSuiteId;
     private Integer queueTimeout;
+    private Boolean showUploadProgress;
 
     /**
      * Executes the LambdaTest task, which includes uploading the application and test suite,
@@ -64,16 +65,19 @@ public void runLambdaTest() {
         CompletableFuture<String> appIdFuture = null;
         CompletableFuture<String> testSuiteIdFuture = null;
 
+        boolean progressEnabled = showUploadProgress != null && showUploadProgress;
+
         if (appId == null && appFilePath != null) {
             logger.info("Uploading app...");
-            AppUploader appUploader = new AppUploader(username, accessKey, appFilePath);
+            AppUploader appUploader =
+                    new AppUploader(username, accessKey, appFilePath, progressEnabled);
             appIdFuture = appUploader.uploadAppAsync();
         }
 
         if (testSuiteId == null && testSuiteFilePath != null) {
             logger.info("Uploading test suite...");
             TestSuiteUploader testSuiteUploader =
-                    new TestSuiteUploader(username, accessKey, testSuiteFilePath);
+                    new TestSuiteUploader(username, accessKey, testSuiteFilePath, progressEnabled);
             testSuiteIdFuture = testSuiteUploader.uploadTestSuiteAsync();
         }
 
@@ -217,4 +221,8 @@ public void setTestSuiteId(String testSuiteId) {
             this.testSuiteId = testSuiteId;
         }
     }
+
+    public void setShowUploadProgress(Boolean showUploadProgress) {
+        this.showUploadProgress = showUploadProgress;
+    }
 }
diff --git a/src/main/java/io/github/lambdatest/gradle/LambdaUploaderTask.java b/src/main/java/io/github/lambdatest/gradle/LambdaUploaderTask.java
@@ -21,6 +21,7 @@ public class LambdaUploaderTask extends DefaultTask {
     private String accessKey;
     private String appFilePath;
     private String testSuiteFilePath;
+    private Boolean showUploadProgress;
 
     @TaskAction
     public void uploadApkToLambdaTest() {
@@ -31,16 +32,19 @@ public void uploadApkToLambdaTest() {
         CompletableFuture<String> testSuiteIdFuture = null;
         logger.lifecycle("Starting LambdaTest APK Uploader task...");
 
+        boolean progressEnabled = showUploadProgress != null && showUploadProgress;
+
         if (appFilePath != null) {
             logger.lifecycle("Uploading app ...");
-            AppUploader appUploader = new AppUploader(username, accessKey, appFilePath);
+            AppUploader appUploader =
+                    new AppUploader(username, accessKey, appFilePath, progressEnabled);
             appIdFuture = appUploader.uploadAppAsync();
         }
 
         if (testSuiteFilePath != null) {
             logger.lifecycle("Uploading test suite ...");
             TestSuiteUploader testSuiteUploader =
-                    new TestSuiteUploader(username, accessKey, testSuiteFilePath);
+                    new TestSuiteUploader(username, accessKey, testSuiteFilePath, progressEnabled);
             testSuiteIdFuture = testSuiteUploader.uploadTestSuiteAsync();
         }
 
@@ -80,4 +84,8 @@ public void setAppFilePath(String appFilePath) {
     public void setTestSuiteFilePath(String testSuiteFilePath) {
         this.testSuiteFilePath = testSuiteFilePath;
     }
+
+    public void setShowUploadProgress(Boolean showUploadProgress) {
+        this.showUploadProgress = showUploadProgress;
+    }
 }
diff --git a/src/main/java/io/github/lambdatest/gradle/ProgressRequestBody.java b/src/main/java/io/github/lambdatest/gradle/ProgressRequestBody.java
@@ -0,0 +1,134 @@
+package io.github.lambdatest.gradle;
+
+import java.io.File;
+import java.io.IOException;
+import okhttp3.MediaType;
+import okhttp3.RequestBody;
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.ForwardingSink;
+import okio.Okio;
+import okio.Sink;
+
+/**
+ * A RequestBody wrapper that tracks upload progress and displays it in the console. This class uses
+ * OkHttp's native Sink and BufferedSink APIs to monitor the upload progress.
+ */
+public class ProgressRequestBody extends RequestBody {
+
+    private final RequestBody delegate;
+    private final File file;
+    private final ProgressCallback progressCallback;
+
+    /** Interface for progress callbacks. */
+    public interface ProgressCallback {
+        void onProgress(long bytesWritten, long totalBytes, float percentage);
+    }
+
+    /**
+     * Creates a new ProgressRequestBody that wraps the given RequestBody.
+     *
+     * @param delegate The original RequestBody to wrap
+     * @param file The file being uploaded (used to get total size)
+     * @param progressCallback Callback to receive progress updates
+     */
+    public ProgressRequestBody(RequestBody delegate, File file, ProgressCallback progressCallback) {
+        this.delegate = delegate;
+        this.file = file;
+        this.progressCallback = progressCallback;
+    }
+
+    @Override
+    public MediaType contentType() {
+        return delegate.contentType();
+    }
+
+    @Override
+    public long contentLength() throws IOException {
+        return delegate.contentLength();
+    }
+
+    @Override
+    public void writeTo(BufferedSink sink) throws IOException {
+        long contentLength = contentLength();
+        ProgressSink progressSink = new ProgressSink(sink, contentLength, progressCallback);
+        BufferedSink bufferedSink = Okio.buffer(progressSink);
+
+        delegate.writeTo(bufferedSink);
+        bufferedSink.flush();
+    }
+
+    /**
+     * Custom Sink implementation that tracks progress while forwarding data to the original sink.
+     */
+    private static class ProgressSink extends ForwardingSink {
+        private final long totalBytes;
+        private final ProgressCallback progressCallback;
+        private long bytesWritten = 0L;
+        private long lastLoggedPercentage = -1L;
+        private long lastUpdateTime = System.currentTimeMillis();
+
+        public ProgressSink(Sink delegate, long totalBytes, ProgressCallback progressCallback) {
+            super(delegate);
+            this.totalBytes = totalBytes;
+            this.progressCallback = progressCallback;
+        }
+
+        @Override
+        public void write(Buffer source, long byteCount) throws IOException {
+            super.write(source, byteCount);
+            bytesWritten += byteCount;
+
+            if (progressCallback != null) {
+                float percentage = totalBytes > 0 ? (bytesWritten * 100.0f) / totalBytes : 0f;
+                long currentTime = System.currentTimeMillis();
+
+                // Update every 1% or every 250ms for more real-time updates
+                long currentPercentage = Math.round(percentage);
+                boolean timeBased = (currentTime - lastUpdateTime) >= 250; // 250ms intervals
+
+                if (currentPercentage != lastLoggedPercentage || timeBased) {
+                    progressCallback.onProgress(bytesWritten, totalBytes, percentage);
+                    lastLoggedPercentage = currentPercentage;
+                    lastUpdateTime = currentTime;
+                }
+            }
+        }
+    }
+
+    /**
+     * Creates a console-based progress callback that displays upload progress.
+     *
+     * @param fileName The name of the file being uploaded
+     * @return A ProgressCallback that logs to console
+     */
+    public static ProgressCallback createConsoleCallback(String fileName) {
+        return (bytesWritten, totalBytes, percentage) -> {
+            String formattedBytes = formatBytes(bytesWritten);
+            String formattedTotal = formatBytes(totalBytes);
+
+            System.out.printf(
+                    "\r\u001B[33mUploading %s: %.1f%% (%s / %s)\u001B[0m",
+                    fileName, percentage, formattedBytes, formattedTotal);
+            System.out.flush();
+
+            if (percentage >= 100.0f) {
+                System.out.println(); // New line when complete
+                System.out.flush();
+            }
+        };
+    }
+
+    /**
+     * Formats bytes into human-readable format.
+     *
+     * @param bytes The number of bytes to format
+     * @return Formatted string (e.g., "1.5 MB", "512 KB")
+     */
+    public static String formatBytes(long bytes) {
+        if (bytes < 1024) return bytes + " B";
+        if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
+        if (bytes < 1024 * 1024 * 1024) return String.format("%.1f MB", bytes / (1024.0 * 1024.0));
+        return String.format("%.1f GB", bytes / (1024.0 * 1024.0 * 1024.0));
+    }
+}
diff --git a/src/main/java/io/github/lambdatest/gradle/TestSuiteUploader.java b/src/main/java/io/github/lambdatest/gradle/TestSuiteUploader.java
@@ -16,6 +16,7 @@ public class TestSuiteUploader {
     private String username;
     private String accessKey;
     private String testSuiteFilePath;
+    private boolean showProgress;
 
     /**
      * Creates a new TestSuiteUploader instance with the specified credentials and file path.
@@ -25,9 +26,24 @@ public class TestSuiteUploader {
      * @param testSuiteFilePath The path to the test suite file to be uploaded
      */
     public TestSuiteUploader(String username, String accessKey, String testSuiteFilePath) {
+        this(username, accessKey, testSuiteFilePath, false);
+    }
+
+    /**
+     * Creates a new TestSuiteUploader instance with the specified credentials, file path, and
+     * progress tracking option.
+     *
+     * @param username The LambdaTest account username
+     * @param accessKey The LambdaTest account access key
+     * @param testSuiteFilePath The path to the test suite file to be uploaded
+     * @param showProgress Whether to display upload progress in the console
+     */
+    public TestSuiteUploader(
+            String username, String accessKey, String testSuiteFilePath, boolean showProgress) {
         this.username = username;
         this.accessKey = accessKey;
         this.testSuiteFilePath = testSuiteFilePath;
+        this.showProgress = showProgress;
     }
 
     /**
@@ -42,7 +58,8 @@ public CompletableFuture<String> uploadTestSuiteAsync() {
                 () -> {
                     try {
                         String testSuiteId =
-                                UploaderUtil.uploadAndGetId(username, accessKey, testSuiteFilePath);
+                                UploaderUtil.uploadAndGetId(
+                                        username, accessKey, testSuiteFilePath, showProgress);
                         logger.info("Uploaded test suite ID: {}", testSuiteId);
                         return testSuiteId;
                     } catch (IOException e) {
diff --git a/src/main/java/io/github/lambdatest/gradle/UploaderUtil.java b/src/main/java/io/github/lambdatest/gradle/UploaderUtil.java
@@ -40,23 +40,50 @@ private UploaderUtil() {
      */
     public static String uploadAndGetId(String username, String accessKey, String filePath)
             throws IOException {
+        return uploadAndGetId(username, accessKey, filePath, false);
+    }
+
+    /**
+     * Uploads a file to LambdaTest and returns its ID with optional progress tracking.
+     *
+     * @implNote This method sends the file to {@link Constants#API_URL} and handles the multipart
+     *     form data construction and response parsing. When showProgress is true, it uses {@link
+     *     ProgressRequestBody} to track and display upload progress.
+     * @param username The LambdaTest account username
+     * @param accessKey The LambdaTest account access key
+     * @param filePath The path to the file to be uploaded
+     * @param showProgress Whether to display upload progress in the console
+     * @return The ID of the uploaded file
+     * @throws IOException if there's an error during file upload or response parsing
+     */
+    public static String uploadAndGetId(
+            String username, String accessKey, String filePath, boolean showProgress)
+            throws IOException {
         OkHttpClient client =
                 new OkHttpClient.Builder()
                         .connectTimeout(1, TimeUnit.MINUTES) // Increase connection timeout
                         .readTimeout(0, TimeUnit.MILLISECONDS) // Increase read timeout
                         .writeTimeout(0, TimeUnit.MILLISECONDS) // Increase write timeout
                         .build();
 
+        File file = new File(filePath);
         MediaType mediaType = MediaType.parse("application/octet-stream");
+        RequestBody fileRequestBody = RequestBody.create(file, mediaType);
+
         RequestBody body =
                 new MultipartBody.Builder()
                         .setType(MultipartBody.FORM)
-                        .addFormDataPart(
-                                "appFile",
-                                filePath,
-                                RequestBody.create(new File(filePath), mediaType))
+                        .addFormDataPart("appFile", filePath, fileRequestBody)
                         .addFormDataPart("type", "espresso-android")
                         .build();
+
+        // Wrap the entire multipart body with progress tracking if requested
+        if (showProgress) {
+            String fileName = file.getName();
+            ProgressRequestBody.ProgressCallback callback =
+                    ProgressRequestBody.createConsoleCallback(fileName);
+            body = new ProgressRequestBody(body, file, callback);
+        }
         Request request =
                 new Request.Builder()
                         .url(Constants.API_URL)

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ plugins {`
`4`	`4`	`id 'com.diffplug.spotless' version '6.25.0'`
`5`	`5`	`}`
`6`	`6`
`7`		`-version = '1.0.6'`
	`7`	`+version = '1.0.7'`
`8`	`8`	`group = 'io.github.lambdatest'`
`9`	`9`
`10`	`10`	`repositories {`