github.com/thiagoyeds/go-cloud@v0.26.0/blob/blob_writer_test.go (about) 1 // Copyright 2019 The Go Cloud Development Kit Authors 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // https://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package blob_test 16 17 import ( 18 "bytes" 19 "context" 20 "crypto/rand" 21 "fmt" 22 "io" 23 "testing" 24 25 "github.com/google/go-cmp/cmp" 26 "gocloud.dev/blob" 27 "gocloud.dev/blob/memblob" 28 ) 29 30 // TestWriteReturnValues verifies that blob.Writer returns the correct n 31 // even when it is doing content sniffing. 32 func TestWriteReturnValues(t *testing.T) { 33 ctx := context.Background() 34 35 for _, withContentType := range []bool{true, false} { 36 t.Run(fmt.Sprintf("withContentType %v", withContentType), func(t *testing.T) { 37 bucket := memblob.OpenBucket(nil) 38 defer bucket.Close() 39 40 var opts *blob.WriterOptions 41 if withContentType { 42 opts = &blob.WriterOptions{ContentType: "application/octet-stream"} 43 } 44 w, err := bucket.NewWriter(ctx, "testkey", opts) 45 if err != nil { 46 t.Fatalf("couldn't create writer with options: %v", err) 47 } 48 defer func() { 49 if err := w.Close(); err != nil { 50 t.Errorf("failed to close writer: %v", err) 51 } 52 }() 53 n, err := io.CopyN(w, rand.Reader, 182) 54 if err != nil || n != 182 { 55 t.Fatalf("CopyN(182) got %d, want 182: %v", n, err) 56 } 57 n, err = io.CopyN(w, rand.Reader, 1812) 58 if err != nil || n != 1812 { 59 t.Fatalf("CopyN(1812) got %d, want 1812: %v", n, err) 60 } 61 }) 62 } 63 } 64 65 func randomData(nBytes int64) ([]byte, error) { 66 var buf bytes.Buffer 67 n, err := io.CopyN(&buf, rand.Reader, nBytes) 68 if err != nil || n != nBytes { 69 return nil, fmt.Errorf("failed to get random data (%d want %d): %v", n, nBytes, err) 70 } 71 return buf.Bytes(), nil 72 } 73 74 func TestReadFrom(t *testing.T) { 75 const dstKey = "dstkey" 76 77 // Get some random data, of a large enough size to require multiple 78 // reads/writes given our buffer size of 1024. 79 data, err := randomData(1024*10 + 10) 80 81 bucket := memblob.OpenBucket(nil) 82 defer bucket.Close() 83 84 // Create a blob.Writer and write to it using ReadFrom given a buffer 85 // holding the random data. 86 ctx := context.Background() 87 w, err := bucket.NewWriter(ctx, dstKey, nil) 88 if err != nil { 89 t.Fatal(err) 90 } 91 n, err := w.ReadFrom(bytes.NewBuffer(data)) 92 if err != nil || n != int64(len(data)) { 93 t.Fatalf("failed to ReadFrom (%d want %d): %v", n, len(data), err) 94 } 95 if err := w.Close(); err != nil { 96 t.Fatal(err) 97 } 98 99 // Verify the data was copied correctly. 100 got, err := bucket.ReadAll(ctx, dstKey) 101 if err != nil { 102 t.Fatal(err) 103 } 104 if !cmp.Equal(got, data) { 105 t.Errorf("got %v, want %v", got, data) 106 } 107 } 108 109 // Ensure that blob.Reader implements io.WriterTo. 110 var _ io.WriterTo = &blob.Reader{} 111 112 // Ensure that blob.Writer implements io.ReaderFrom. 113 var _ io.ReaderFrom = &blob.Writer{} 114 115 func TestWriteTo(t *testing.T) { 116 const srcKey = "srckey" 117 118 // Get some random data, of a large enough size to require multiple 119 // reads/writes given our buffer size of 1024. 120 data, err := randomData(1024*10 + 10) 121 122 bucket := memblob.OpenBucket(nil) 123 defer bucket.Close() 124 125 // Write the data to a key. 126 ctx := context.Background() 127 if err := bucket.WriteAll(ctx, srcKey, data, nil); err != nil { 128 t.Fatal(err) 129 } 130 131 // Create a blob.Reader for that key and read from it, writing to a buffer. 132 r, err := bucket.NewReader(ctx, srcKey, nil) 133 if err != nil { 134 t.Fatal(err) 135 } 136 var buf bytes.Buffer 137 n, err := r.WriteTo(&buf) 138 if err != nil || n != int64(len(data)) { 139 t.Fatalf("failed to WriteTo (%d want %d): %v", n, len(data), err) 140 } 141 if err := r.Close(); err != nil { 142 t.Fatal(err) 143 } 144 145 // Verify the data was copied correctly. 146 got := buf.Bytes() 147 if !cmp.Equal(got, data) { 148 t.Errorf("got %v, want %v", got, data) 149 } 150 }