github.com/Files-com/files-sdk-go/v3@v3.1.81/file/uploadio_test.go (about) 1 //go:build LIVE_TESTS 2 // +build LIVE_TESTS 3 4 package file 5 6 import ( 7 "bytes" 8 "context" 9 "crypto/sha256" 10 "io" 11 "net/http" 12 "sort" 13 "strconv" 14 "testing" 15 "time" 16 17 files_sdk "github.com/Files-com/files-sdk-go/v3" 18 "github.com/Files-com/files-sdk-go/v3/lib" 19 "github.com/snabb/httpreaderat" 20 "github.com/stretchr/testify/assert" 21 "github.com/stretchr/testify/require" 22 ) 23 24 func TestClient_UploadIO(t *testing.T) { 25 client := &Client{} 26 assert := assert.New(t) 27 28 req, _ := http.NewRequest("GET", "https://download.virtualbox.org/virtualbox/6.1.26/VirtualBox-6.1.26-145957-OSX.dmg", nil) 29 30 f, err := httpreaderat.New(nil, req, nil) 31 if err != nil { 32 panic(err) 33 } 34 35 progressCounter := int64(0) 36 progress := func(i int64) { 37 progressCounter += i 38 } 39 var r UploadResumable 40 r, err = client.UploadWithResume( 41 UploadWithDestinationPath("VirtualBox.dmg"), 42 UploadWithReaderAt(f), 43 UploadWithSize(f.Size()), 44 UploadWithManager(lib.NewConstrainedWorkGroup(10)), 45 UploadWithProgress(progress), 46 ) 47 require.NoError(t, err) 48 assert.Equal(f.Size(), r.Size) 49 assert.Equal(23, len(r.Parts)) 50 assert.Equal(progressCounter, r.Size) 51 var buf bytes.Buffer 52 file, err := client.Download(context.Background(), files_sdk.FileDownloadParams{Path: r.File.Path}, files_sdk.ResponseBodyOption(func(closer io.ReadCloser) error { 53 _, err := io.Copy(&buf, closer) 54 return err 55 })) 56 assert.NoError(err) 57 assert.Equal(r.File.Size, int64(buf.Len())) 58 assert.Equal(f.Size(), int64(buf.Len())) 59 assert.Equal(f.Size(), file.Size) 60 assert.Equal(r.File.Size, file.Size) 61 remoteSHA := sha256.Sum256(buf.Bytes()) 62 response, err := client.GetHttpClient().Do(req) 63 b, err := io.ReadAll(response.Body) 64 localShow := sha256.Sum256(b) 65 66 assert.Equal(localShow, remoteSHA) 67 } 68 69 func TestClient_UploadIO_Cancel_Restart(t *testing.T) { 70 client := &Client{} 71 assert := assert.New(t) 72 73 req, _ := http.NewRequest("GET", "https://download.virtualbox.org/virtualbox/6.1.26/VirtualBox-6.1.26-145957-OSX.dmg", nil) 74 75 f, err := httpreaderat.New(nil, req, nil) 76 if err != nil { 77 panic(err) 78 } 79 80 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 81 defer cancel() 82 progressCounter := int64(0) 83 progress := func(i int64) { 84 progressCounter += i 85 } 86 var r UploadResumable 87 manager := lib.NewConstrainedWorkGroup(4) 88 r, err = client.UploadWithResume( 89 UploadWithContext(ctx), 90 UploadWithDestinationPath("VirtualBox.dmg"), 91 UploadWithReaderAt(f), 92 UploadWithSize(f.Size()), 93 UploadWithManager(manager), 94 UploadWithProgress(progress), 95 ) 96 assert.Equal(0, manager.RunningCount()) 97 assert.Error(err, "context canceled") 98 assert.Equal(int64(0), r.File.Size) 99 assert.GreaterOrEqual(len(r.Parts), 2) 100 var successful int 101 var alreadyRan Parts 102 for _, part := range r.Parts { 103 if part.Successful() { 104 alreadyRan = append(alreadyRan, part) 105 successful += 1 106 assert.Equal(1, len(part.requests)) 107 } else { 108 assert.LessOrEqual(len(part.requests), 1) 109 } 110 } 111 assert.InDelta(5, successful, 10) 112 assert.Equal(r.Parts.SuccessfulBytes(), progressCounter) 113 var uploadedBytes int64 114 ctx, cancel = context.WithCancel(context.Background()) 115 defer cancel() 116 progressCounter = 0 117 r, err = client.UploadWithResume( 118 UploadWithContext(ctx), 119 UploadWithDestinationPath("VirtualBox.dmg"), 120 UploadWithReaderAt(f), 121 UploadWithSize(f.Size()), 122 UploadWithManager(manager), 123 UploadWithProgress(progress), 124 UploadWithResume(r), 125 ) 126 require.NoError(t, err) 127 assert.Equal(r.File.Size, progressCounter) 128 assert.Equal(r.File.Size, r.Parts.SuccessfulBytes()) 129 successful = 0 130 for _, part := range r.Parts { 131 for _, rpart := range alreadyRan { 132 if rpart == part { 133 assert.Equal(1, len(part.requests)) 134 } 135 } 136 assert.Equal(true, part.Successful()) 137 assert.LessOrEqual(len(part.requests), 2) 138 uploadedBytes += part.bytes 139 assert.NoError(part.error) 140 } 141 142 sort.SliceStable(r.Parts, func(i, j int) bool { 143 x, _ := strconv.ParseInt(r.Parts[i].Part, 10, 64) 144 y, _ := strconv.ParseInt(r.Parts[j].Part, 10, 64) 145 return x < y 146 }) 147 148 assert.Equal(r.File.Size, uploadedBytes) 149 var buf bytes.Buffer 150 file, err := client.Download(context.Background(), files_sdk.FileDownloadParams{Path: r.File.Path}, files_sdk.ResponseBodyOption(func(closer io.ReadCloser) error { 151 _, err := io.Copy(&buf, closer) 152 return err 153 })) 154 assert.NoError(err) 155 assert.Equal(r.File.Size, int64(buf.Len())) 156 assert.Equal(f.Size(), int64(buf.Len())) 157 assert.Equal(f.Size(), file.Size) 158 assert.Equal(r.File.Size, file.Size) 159 remoteSHA := sha256.Sum256(buf.Bytes()) 160 response, err := client.GetHttpClient().Do(req) 161 b, err := io.ReadAll(response.Body) 162 localShow := sha256.Sum256(b) 163 164 assert.Equal(localShow, remoteSHA) 165 } 166 167 func TestClient_UploadIO_Cancel_Restart_Expired(t *testing.T) { 168 client := &Client{} 169 assert := assert.New(t) 170 171 req, _ := http.NewRequest("GET", "https://download.virtualbox.org/virtualbox/6.1.26/VirtualBox-6.1.26-145957-OSX.dmg", nil) 172 173 f, err := httpreaderat.New(nil, req, nil) 174 if err != nil { 175 panic(err) 176 } 177 178 ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 179 assert.NoError(err) 180 progressCounter := int64(0) 181 progress := func(i int64) { 182 progressCounter += i 183 } 184 var r UploadResumable 185 manager := lib.NewConstrainedWorkGroup(4) 186 r, err = client.UploadWithResume( 187 UploadWithContext(ctx), 188 UploadWithDestinationPath("VirtualBox.dmg"), 189 UploadWithReaderAt(f), 190 UploadWithSize(f.Size()), 191 UploadWithManager(manager), 192 UploadWithProgress(progress), 193 ) 194 195 require.Error(t, err) 196 var successful int 197 var alreadyRan Parts 198 for _, part := range r.Parts { 199 if part.Successful() { 200 alreadyRan = append(alreadyRan, part) 201 successful += 1 202 assert.Equal(1, len(part.requests)) 203 } else { 204 assert.LessOrEqual(len(part.requests), 1) 205 } 206 } 207 assert.InDelta(5, successful, 10) 208 assert.InDelta(r.Parts.SuccessfulBytes(), progressCounter, float64(lib.BasePart)) 209 var uploadedBytes int64 210 ctx, cancel = context.WithCancel(context.Background()) 211 defer cancel() 212 r.FileUploadPart.Expires = time.Now().AddDate(0, -1, 0).Format(time.RFC3339) 213 progressCounter = 0 214 r, err = client.UploadWithResume( 215 UploadWithContext(ctx), 216 UploadWithDestinationPath("VirtualBox.dmg"), 217 UploadWithReaderAt(f), 218 UploadWithSize(f.Size()), 219 UploadWithManager(manager), 220 UploadWithProgress(progress), 221 UploadWithResume(r), 222 ) 223 assert.NoError(err) 224 assert.InDelta(r.File.Size, progressCounter, 50_000) 225 successful = 0 226 for _, part := range r.Parts { 227 for _, rpart := range alreadyRan { 228 if rpart == part { 229 assert.Equal(1, len(part.requests)) 230 } 231 } 232 assert.Equal(true, part.Successful()) 233 assert.LessOrEqual(len(part.requests), 2) 234 uploadedBytes += part.bytes 235 assert.NoError(part.error) 236 } 237 238 sort.SliceStable(r.Parts, func(i, j int) bool { 239 x, _ := strconv.ParseInt(r.Parts[i].Part, 10, 64) 240 y, _ := strconv.ParseInt(r.Parts[j].Part, 10, 64) 241 return x < y 242 }) 243 244 assert.Equal(r.File.Size, uploadedBytes) 245 var buf bytes.Buffer 246 247 file, err := client.Download(context.Background(), files_sdk.FileDownloadParams{Path: r.File.Path}, files_sdk.ResponseBodyOption(func(closer io.ReadCloser) error { 248 _, err := io.Copy(&buf, closer) 249 return err 250 })) 251 assert.NoError(err) 252 assert.Equal(f.Size(), int64(buf.Len())) 253 assert.Equal(f.Size(), file.Size) 254 remoteSHA := sha256.Sum256(buf.Bytes()) 255 response, err := client.GetHttpClient().Do(req) 256 b, err := io.ReadAll(response.Body) 257 localShow := sha256.Sum256(b) 258 259 assert.Equal(localShow, remoteSHA) 260 }