[Bug]Fixing missing bytes when processing chunks of a file during upload (#1941)

fix: missing bytes when processing chunks of a file during upload

* Fixing spot bug issue

Author: adrian05-ms

src/main/java/com/microsoft/graph/core/tasks/LargeFileUploadTask.java

@@ -1,5 +1,20 @@
 package com.microsoft.graph.core.tasks;
 
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.time.OffsetDateTime;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
 import com.microsoft.graph.core.ErrorConstants;
 import com.microsoft.graph.core.exceptions.ClientException;
 import com.microsoft.graph.core.models.IProgressCallback;
@@ -18,19 +33,10 @@
 import com.microsoft.kiota.serialization.Parsable;
 import com.microsoft.kiota.serialization.ParsableFactory;
 import com.microsoft.kiota.serialization.ParseNode;
-import okhttp3.OkHttpClient;
 
 import jakarta.annotation.Nonnull;
 import jakarta.annotation.Nullable;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.reflect.InvocationTargetException;
-import java.time.OffsetDateTime;
-import java.util.*;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
+import okhttp3.OkHttpClient;
 
 /**
  * Task for uploading large files including pausing and resuming.
@@ -274,8 +280,15 @@ private long nextSliceSize(long rangeBegin, long rangeEnd)  {
     }
     private byte[] chunkInputStream(InputStream stream, int length) throws IOException {
         byte[] buffer = new byte[length];
-        int lengthAssert = stream.read(buffer);
-        assert lengthAssert == length;
+        int totalRead = 0;
+        while (totalRead < length) {
+            int bytesRead = stream.read(buffer, totalRead, length - totalRead);
+            if (bytesRead == -1) {
+                // End of stream reached
+                break;
+            }
+            totalRead += bytesRead;
+        }
         return buffer;
     }
 }

src/test/java/com/microsoft/graph/core/tasks/LargeFileUploadTest.java

@@ -5,9 +5,14 @@
 import com.microsoft.graph.core.models.UploadSession;
 import com.microsoft.kiota.authentication.AuthenticationProvider;
 import com.microsoft.kiota.http.OkHttpRequestAdapter;
+
 import org.junit.jupiter.api.Test;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.doReturn;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.mockito.ArgumentCaptor;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -17,6 +22,10 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 
+import org.mockito.internal.matchers.Any;
+
+import com.microsoft.graph.core.models.UploadResult;
+
 class LargeFileUploadTest {
 
     final OkHttpRequestAdapter adapter = new OkHttpRequestAdapter(mock(AuthenticationProvider.class));
@@ -106,4 +115,59 @@ void BreakStreamIntoCorrectRanges() throws IOException, NoSuchFieldException, Il
         assertEquals(size%maxSliceSize, lastSlice.getRangeLength());
         assertEquals(size-1, lastSlice.getRangeEnd());
     }
+    // Test for chunkInputStream method with a 5MB file
+        @Test
+    void uploads5MBFileSuccessfully() throws Exception {
+        // Arrange
+        UploadSession session = new UploadSession();
+        session.setNextExpectedRanges(Arrays.asList("0-"));
+        session.setUploadUrl("http://localhost");
+        session.setExpirationDateTime(OffsetDateTime.now().plusHours(1));
+
+        // 5MB file
+        byte[] data = new byte[5 * 1024 * 1024];
+            for (int i = 0; i < data.length; i++) {
+        data[i] = (byte)(i % 256);
+    }
+        ByteArrayInputStream stream = new ByteArrayInputStream(data);
+        int size = stream.available();
+
+    // Create a real task to get the real builder(s)
+        LargeFileUploadTask<TestDriveItem> realTask = new LargeFileUploadTask<>(adapter, session, stream, size, TestDriveItem::createFromDiscriminatorValue);
+        var realBuilders = realTask.getUploadSliceRequests();
+
+        // Spy the builder(s) and mock put()
+        ArrayList<UploadSliceRequestBuilder<TestDriveItem>> spyBuilders = new ArrayList<>();
+        ArgumentCaptor<ByteArrayInputStream> captor = ArgumentCaptor.forClass(ByteArrayInputStream.class);
+
+        for (UploadSliceRequestBuilder<TestDriveItem> builder : realBuilders) {
+            UploadSliceRequestBuilder<TestDriveItem> spyBuilder = spy(builder);
+            UploadResult<TestDriveItem> mockResult = new UploadResult<>();
+            TestDriveItem item = new TestDriveItem();
+            item.size = data.length;
+            mockResult.itemResponse = item;
+            doReturn(mockResult).when(spyBuilder).put(captor.capture());
+            spyBuilders.add(spyBuilder);
+        }
+
+        // Subclass LargeFileUploadTask to inject our spy builders
+        LargeFileUploadTask<TestDriveItem> task = new LargeFileUploadTask<>(adapter, session, stream, size, TestDriveItem::createFromDiscriminatorValue) {
+            @Override
+            protected java.util.List<UploadSliceRequestBuilder<TestDriveItem>> getUploadSliceRequests() {
+                return spyBuilders;
+            }
+        };
+
+        // Act
+        task.upload(3, null);
+
+        // Verify the chunkStream content
+        ByteArrayInputStream capturedStream = captor.getValue();
+        byte[] capturedBytes = new byte[data.length];
+        int read = capturedStream.read(capturedBytes);
+        assertEquals(data.length, read, "Should read all bytes from chunkStream");
+        for (int i = 0; i < data.length; i++) {
+            assertEquals(data[i], capturedBytes[i], "Byte at position " + i + " should match original data");
+        }
+    }
 }