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  }