chore: update project version to 2.1.9 and upgrade dependencies

gibiw · gibiw · commit 411590c93b42 · 2025-12-08T14:52:02.000+03:00
- Incremented project version to `2.1.9` in `composer.json`.
- Updated `composer.lock` with new content hash and upgraded dependencies, including `qase/qase-api-client` to `1.1.6` and `phpunit/phpunit` to `9.6.30`.
- Enhanced `uploadAttachment` method in `ApiClientV1` to support multiple attachments with validation and batching.
- Updated `ClientInterface` to reflect changes in the `uploadAttachment` method signature.
- Improved attachment handling in `ApiClientV2` to utilize the new batch upload functionality.
diff --git a/composer.json b/composer.json
@@ -29,8 +29,8 @@
   },
   "require": {
     "php": "^8.0",
-    "qase/qase-api-client": "^1.1.0",
-    "qase/qase-api-v2-client": "^1.1.0",
+    "qase/qase-api-client": "^1.1.5",
+    "qase/qase-api-v2-client": "^1.1.2",
     "ramsey/uuid": "^4.7"
   },
   "require-dev": {
@@ -40,7 +40,7 @@
   "scripts": {
     "test": "phpunit"
   },
-  "version": "2.1.8",
+  "version": "2.1.9",
   "config": {
     "platform": {
       "php": "8.0"
diff --git a/composer.lock b/composer.lock
diff --git a/src/Client/ApiClientV1.php b/src/Client/ApiClientV1.php
@@ -184,35 +184,219 @@ public function isTestRunExist(string $code, int $runId): bool
         }
     }
 
-    public function uploadAttachment(string $code, Attachment $attachment): ?string
+    /**
+     * Upload one or multiple attachments
+     * 
+     * Limitations:
+     * - Up to 32 MB per file
+     * - Up to 128 MB per single request
+     * - Up to 20 files per single request
+     * 
+     * @param string $code Project code
+     * @param Attachment|Attachment[] $attachments Single attachment or array of attachments
+     * @return string|string[]|null Hash(es) of uploaded attachment(s) or null on failure
+     */
+    public function uploadAttachment(string $code, Attachment|array $attachments): string|array|null
     {
+        // Normalize to array
+        $attachmentsArray = is_array($attachments) ? $attachments : [$attachments];
+        
+        // Check for empty array
+        if (empty($attachmentsArray)) {
+            $this->logger->warning('Empty attachments array provided');
+            return is_array($attachments) ? [] : null;
+        }
+        
         try {
-            $this->logger->debug('Upload attachment: ' . json_encode($attachment));
+            $this->logger->debug('Upload ' . count($attachmentsArray) . ' attachment(s)');
+
+            // Filter and validate individual file constraints (skip invalid files)
+            $validAttachments = $this->filterValidAttachments($attachmentsArray);
+            
+            if (empty($validAttachments)) {
+                $this->logger->warning('No valid attachments to upload after filtering');
+                return is_array($attachments) ? [] : null;
+            }
 
+            // Split into batches
+            $batches = $this->splitIntoBatches($validAttachments);
+            $this->logger->debug('Split into ' . count($batches) . ' batch(es)');
+
+            $allHashes = [];
             $attachApi = new AttachmentsApi($this->client, $this->clientConfig);
-            if ($attachment->path) {
-                $attachmentId = $attachApi->uploadAttachment($code, new SplFileObject($attachment->path));
-            } elseif ($attachment->content) {
-                $filepath = rtrim(getcwd(), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $attachment->title;
-                if (file_put_contents($filepath, $attachment->content) === false) {
-                    $this->logger->error('Can not save attachment: ' . $filepath);
-                    return null;
+
+            // Upload each batch
+            foreach ($batches as $batchIndex => $batch) {
+                $this->logger->debug('Uploading batch ' . ($batchIndex + 1) . '/' . count($batches) . ' with ' . count($batch) . ' file(s)');
+                
+                $fileObjects = [];
+                $tempFiles = [];
+
+                // Prepare files for this batch
+                foreach ($batch as $attachment) {
+                    if ($attachment->path) {
+                        $fileObjects[] = new SplFileObject($attachment->path);
+                    } elseif ($attachment->content) {
+                        $filepath = sys_get_temp_dir() . DIRECTORY_SEPARATOR . uniqid('qase_attach_', true) . '_' . ($attachment->title ?? 'attachment');
+                        if (file_put_contents($filepath, $attachment->content) === false) {
+                            $this->logger->error('Can not save attachment: ' . $filepath);
+                            // Clean up already created temp files
+                            foreach ($tempFiles as $tempFile) {
+                                if (file_exists($tempFile)) {
+                                    unlink($tempFile);
+                                }
+                            }
+                            return null;
+                        }
+                        $fileObjects[] = new SplFileObject($filepath);
+                        $tempFiles[] = $filepath;
+                    } else {
+                        $this->logger->error('Attachment has neither path nor content');
+                        // Clean up temp files
+                        foreach ($tempFiles as $tempFile) {
+                            if (file_exists($tempFile)) {
+                                unlink($tempFile);
+                            }
+                        }
+                        return null;
+                    }
                 }
-                $attachmentId = $attachApi->uploadAttachment($code, new SplFileObject($filepath));
-                if (unlink($filepath) === false) {
-                    $this->logger->error('Can not remove attachment: ' . $filepath);
+
+                // Upload batch
+                $result = $attachApi->uploadAttachment($code, $fileObjects);
+
+                // Clean up temp files for this batch
+                foreach ($tempFiles as $tempFile) {
+                    if (file_exists($tempFile) && unlink($tempFile) === false) {
+                        $this->logger->error('Can not remove temporary attachment: ' . $tempFile);
+                    }
+                }
+
+                // Extract hashes from result
+                if ($result && $result->getResult()) {
+                    foreach ($result->getResult() as $attachmentResult) {
+                        $allHashes[] = $attachmentResult->getHash();
+                    }
                 }
-            } else {
-                return null;
             }
 
-            return $attachmentId->getResult()[0]->getHash();
+            // Return single hash if single attachment was provided, array otherwise
+            if (!is_array($attachments)) {
+                return $allHashes[0] ?? null;
+            }
+
+            return $allHashes;
         } catch (Exception $e) {
-            $this->logger->error('Failed to upload attachment: ' . $e->getMessage());
+            $this->logger->error('Failed to upload attachment(s): ' . $e->getMessage());
             return null;
         }
     }
 
+    /**
+     * Filter attachments and return only valid ones, logging errors for invalid files
+     * 
+     * @param Attachment[] $attachments
+     * @return Attachment[] Array of valid attachments
+     */
+    private function filterValidAttachments(array $attachments): array
+    {
+        $maxFileSize = 32 * 1024 * 1024; // 32 MB
+        $validAttachments = [];
+
+        foreach ($attachments as $index => $attachment) {
+            $fileSize = 0;
+            $fileName = $attachment->title ?? $attachment->path ?? "attachment at index {$index}";
+
+            // Check if file has path or content
+            if ($attachment->path) {
+                if (!file_exists($attachment->path)) {
+                    $this->logger->warning("Skipping attachment '{$fileName}': file not found: {$attachment->path}");
+                    continue;
+                }
+                $fileSize = filesize($attachment->path);
+            } elseif ($attachment->content) {
+                $fileSize = strlen($attachment->content);
+            } else {
+                $this->logger->warning("Skipping attachment '{$fileName}': has neither path nor content");
+                continue;
+            }
+
+            // Check file size
+            if ($fileSize > $maxFileSize) {
+                $fileSizeMB = round($fileSize / 1024 / 1024, 2);
+                $this->logger->warning("Skipping attachment '{$fileName}': file size {$fileSizeMB} MB exceeds maximum of 32 MB per file");
+                continue;
+            }
+
+            $validAttachments[] = $attachment;
+        }
+
+        $skippedCount = count($attachments) - count($validAttachments);
+        if ($skippedCount > 0) {
+            $this->logger->info("Filtered out {$skippedCount} invalid attachment(s), proceeding with " . count($validAttachments) . " valid attachment(s)");
+        }
+
+        return $validAttachments;
+    }
+
+    /**
+     * Split attachments into batches respecting API constraints
+     * 
+     * @param Attachment[] $attachments
+     * @return Attachment[][] Array of batches
+     */
+    private function splitIntoBatches(array $attachments): array
+    {
+        $maxFilesPerBatch = 20;
+        $maxSizePerBatch = 128 * 1024 * 1024; // 128 MB
+
+        $batches = [];
+        $currentBatch = [];
+        $currentBatchSize = 0;
+
+        foreach ($attachments as $attachment) {
+            // Get file size (files should be validated already, but add safety check)
+            $fileSize = 0;
+            if ($attachment->path) {
+                if (file_exists($attachment->path)) {
+                    $fileSize = filesize($attachment->path);
+                } else {
+                    $this->logger->warning("Skipping attachment in batch: file not found: {$attachment->path}");
+                    continue;
+                }
+            } elseif ($attachment->content) {
+                $fileSize = strlen($attachment->content);
+            } else {
+                $this->logger->warning("Skipping attachment in batch: has neither path nor content");
+                continue;
+            }
+
+            // Check if we need to start a new batch
+            $wouldExceedFileLimit = count($currentBatch) >= $maxFilesPerBatch;
+            $wouldExceedSizeLimit = ($currentBatchSize + $fileSize) > $maxSizePerBatch;
+
+            if ($wouldExceedFileLimit || $wouldExceedSizeLimit) {
+                // Save current batch and start a new one
+                if (!empty($currentBatch)) {
+                    $batches[] = $currentBatch;
+                    $currentBatch = [];
+                    $currentBatchSize = 0;
+                }
+            }
+
+            // Add file to current batch
+            $currentBatch[] = $attachment;
+            $currentBatchSize += $fileSize;
+        }
+
+        // Add the last batch if it's not empty
+        if (!empty($currentBatch)) {
+            $batches[] = $currentBatch;
+        }
+
+        return $batches;
+    }
+
     public function sendResults(string $code, int $runId, array $results): void
     {
         // Use Api V2 client for sending results
diff --git a/src/Client/ApiClientV2.php b/src/Client/ApiClientV2.php
@@ -146,15 +146,20 @@ private function convertRelations(Relation $relation): ResultRelations
 
     private function convertAttachments(array $attachments): array
     {
-        $hashes = [];
-        foreach ($attachments as $item) {
-            $result = $this->uploadAttachment($this->config->getProject(), $item);
-            if ($result) {
-                $hashes[] = $result;
-            }
+        if (empty($attachments)) {
+            return [];
+        }
+
+        // Upload all attachments at once (method handles validation and batching if needed)
+        $result = $this->uploadAttachment($this->config->getProject(), $attachments);
+        
+        if (is_array($result)) {
+            return $result;
+        } elseif (is_string($result)) {
+            return [$result];
         }
 
-        return $hashes;
+        return [];
     }
 
     public function runUpdateExternalIssue(string $code, string $type, array $links): void
diff --git a/src/Interfaces/ClientInterface.php b/src/Interfaces/ClientInterface.php
@@ -21,7 +21,19 @@ public function completeTestRun(string $code, int $runId): void;
 
     public function isTestRunExist(string $code, int $runId): bool;
 
-    public function uploadAttachment(string $code, Attachment $attachment): ?string;
+    /**
+     * Upload one or multiple attachments
+     * 
+     * Limitations:
+     * - Up to 32 MB per file
+     * - Up to 128 MB per single request
+     * - Up to 20 files per single request
+     * 
+     * @param string $code Project code
+     * @param Attachment|Attachment[] $attachments Single attachment or array of attachments
+     * @return string|string[]|null Hash(es) of uploaded attachment(s) or null on failure
+     */
+    public function uploadAttachment(string $code, Attachment|array $attachments): string|array|null;
 
     public function sendResults(string $code, int $runId, array $results): void;
 
