Source file src/github.com/Azure/azure-sdk-for-go/storage/file_test.go

Documentation: github.com/Azure/azure-sdk-for-go/storage

     1  package storage
     2  
     3  // Copyright (c) Microsoft Corporation. All rights reserved.
     4  // Licensed under the MIT License. See License.txt in the project root for license information.
     5  
     6  import (
     7  	"bytes"
     8  	"crypto/md5"
     9  	"encoding/base64"
    10  	"io"
    11  
    12  	chk "gopkg.in/check.v1"
    13  )
    14  
    15  type StorageFileSuite struct{}
    16  
    17  var _ = chk.Suite(&StorageFileSuite{})
    18  
    19  func (s *StorageFileSuite) TestCreateFile(c *chk.C) {
    20  	cli := getFileClient(c)
    21  	rec := cli.client.appendRecorder(c)
    22  	defer rec.Stop()
    23  	cli.deleteAllShares()
    24  
    25  	// create share
    26  	share := cli.GetShareReference(shareName(c))
    27  	c.Assert(share.Create(nil), chk.IsNil)
    28  	defer share.Delete(nil)
    29  	root := share.GetRootDirectoryReference()
    30  
    31  	// create directory structure
    32  	dir1 := root.GetDirectoryReference("one")
    33  	c.Assert(dir1.Create(nil), chk.IsNil)
    34  	dir2 := dir1.GetDirectoryReference("two")
    35  	c.Assert(dir2.Create(nil), chk.IsNil)
    36  
    37  	// verify file doesn't exist
    38  	file := dir2.GetFileReference("some.file")
    39  	exists, err := file.Exists()
    40  	c.Assert(err, chk.IsNil)
    41  	c.Assert(exists, chk.Equals, false)
    42  
    43  	// create file
    44  	c.Assert(file.Create(1024, nil), chk.IsNil)
    45  
    46  	// delete file and verify
    47  	c.Assert(file.Delete(nil), chk.IsNil)
    48  	exists, err = file.Exists()
    49  	c.Assert(err, chk.IsNil)
    50  	c.Assert(exists, chk.Equals, false)
    51  }
    52  
    53  func (s *StorageFileSuite) TestGetFile(c *chk.C) {
    54  	cli := getFileClient(c)
    55  	rec := cli.client.appendRecorder(c)
    56  	defer rec.Stop()
    57  
    58  	// create share
    59  	share := cli.GetShareReference(shareName(c))
    60  	c.Assert(share.Create(nil), chk.IsNil)
    61  	defer share.Delete(nil)
    62  	root := share.GetRootDirectoryReference()
    63  
    64  	// create file
    65  	const size = uint64(1024)
    66  	byteStream, _ := newByteStream(size)
    67  	file := root.GetFileReference("some.file")
    68  	c.Assert(file.Create(size, nil), chk.IsNil)
    69  
    70  	// fill file with some data
    71  	c.Assert(file.WriteRange(byteStream, FileRange{End: size - 1}, nil), chk.IsNil)
    72  
    73  	// set some metadata
    74  	md := map[string]string{
    75  		"something": "somethingvalue",
    76  		"another":   "anothervalue",
    77  	}
    78  	file.Metadata = md
    79  	c.Assert(file.SetMetadata(nil), chk.IsNil)
    80  
    81  	options := GetFileOptions{
    82  		GetContentMD5: false,
    83  	}
    84  	// retrieve full file content and verify
    85  	stream, err := file.DownloadRangeToStream(FileRange{Start: 0, End: size - 1}, &options)
    86  	c.Assert(err, chk.IsNil)
    87  	defer stream.Body.Close()
    88  	var b1 [size]byte
    89  	count, _ := stream.Body.Read(b1[:])
    90  	c.Assert(count, chk.Equals, int(size))
    91  	var c1 [size]byte
    92  	bs, _ := newByteStream(size)
    93  	bs.Read(c1[:])
    94  	c.Assert(b1, chk.DeepEquals, c1)
    95  
    96  	// retrieve partial file content and verify
    97  	stream, err = file.DownloadRangeToStream(FileRange{Start: size / 2, End: size - 1}, &options)
    98  	c.Assert(err, chk.IsNil)
    99  	defer stream.Body.Close()
   100  	var b2 [size / 2]byte
   101  	count, _ = stream.Body.Read(b2[:])
   102  	c.Assert(count, chk.Equals, int(size)/2)
   103  	var c2 [size / 2]byte
   104  	bs, _ = newByteStream(size / 2)
   105  	bs.Read(c2[:])
   106  	c.Assert(b2, chk.DeepEquals, c2)
   107  }
   108  
   109  func (s *StorageFileSuite) TestFileRanges(c *chk.C) {
   110  	cli := getFileClient(c)
   111  	rec := cli.client.appendRecorder(c)
   112  	defer rec.Stop()
   113  
   114  	share := cli.GetShareReference(shareName(c))
   115  	c.Assert(share.Create(nil), chk.IsNil)
   116  	defer share.Delete(nil)
   117  	root := share.GetRootDirectoryReference()
   118  
   119  	fileSize := uint64(4096)
   120  	contentBytes := content(int(fileSize))
   121  
   122  	// --- File with no valid ranges
   123  	file1 := root.GetFileReference("file1.txt")
   124  	c.Assert(file1.Create(fileSize, nil), chk.IsNil)
   125  
   126  	ranges, err := file1.ListRanges(nil)
   127  	c.Assert(err, chk.IsNil)
   128  	c.Assert(ranges.ContentLength, chk.Equals, fileSize)
   129  	c.Assert(ranges.FileRanges, chk.IsNil)
   130  
   131  	// --- File after writing a range
   132  	file2 := root.GetFileReference("file2.txt")
   133  	c.Assert(file2.Create(fileSize, nil), chk.IsNil)
   134  	c.Assert(file2.WriteRange(bytes.NewReader(contentBytes), FileRange{End: fileSize - 1}, nil), chk.IsNil)
   135  
   136  	ranges, err = file2.ListRanges(nil)
   137  	c.Assert(err, chk.IsNil)
   138  	c.Assert(len(ranges.FileRanges), chk.Equals, 1)
   139  	c.Assert((ranges.FileRanges[0].End-ranges.FileRanges[0].Start)+1, chk.Equals, fileSize)
   140  
   141  	// --- File after writing and clearing
   142  	file3 := root.GetFileReference("file3.txt")
   143  	c.Assert(file3.Create(fileSize, nil), chk.IsNil)
   144  	c.Assert(file3.WriteRange(bytes.NewReader(contentBytes), FileRange{End: fileSize - 1}, nil), chk.IsNil)
   145  	c.Assert(file3.ClearRange(FileRange{End: fileSize - 1}, nil), chk.IsNil)
   146  
   147  	ranges, err = file3.ListRanges(nil)
   148  	c.Assert(err, chk.IsNil)
   149  	c.Assert(ranges.FileRanges, chk.IsNil)
   150  
   151  	// --- File with ranges and subranges
   152  	file4 := root.GetFileReference("file4.txt")
   153  	c.Assert(file4.Create(fileSize, nil), chk.IsNil)
   154  	putRanges := []FileRange{
   155  		{End: 511},
   156  		{Start: 1024, End: 1535},
   157  		{Start: 2048, End: 2559},
   158  		{Start: 3072, End: 3583},
   159  	}
   160  
   161  	for _, r := range putRanges {
   162  		err = file4.WriteRange(bytes.NewReader(contentBytes[:512]), r, nil)
   163  		c.Assert(err, chk.IsNil)
   164  	}
   165  
   166  	// validate all ranges
   167  	ranges, err = file4.ListRanges(nil)
   168  	c.Assert(err, chk.IsNil)
   169  	c.Assert(ranges.FileRanges, chk.DeepEquals, putRanges)
   170  
   171  	options := ListRangesOptions{
   172  		ListRange: &FileRange{
   173  			Start: 1000,
   174  			End:   3000,
   175  		},
   176  	}
   177  	// validate sub-ranges
   178  	ranges, err = file4.ListRanges(&options)
   179  	c.Assert(err, chk.IsNil)
   180  	c.Assert(ranges.FileRanges, chk.DeepEquals, putRanges[1:3])
   181  
   182  	// --- clear partial range and validate
   183  	file5 := root.GetFileReference("file5.txt")
   184  	c.Assert(file5.Create(fileSize, nil), chk.IsNil)
   185  	c.Assert(file5.WriteRange(bytes.NewReader(contentBytes), FileRange{End: fileSize - 1}, nil), chk.IsNil)
   186  	c.Assert(file5.ClearRange(putRanges[0], nil), chk.IsNil)
   187  	c.Assert(file5.ClearRange(putRanges[2], nil), chk.IsNil)
   188  
   189  	ranges, err = file5.ListRanges(nil)
   190  	c.Assert(err, chk.IsNil)
   191  	expectedtRanges := []FileRange{
   192  		{Start: 512, End: 2047},
   193  		{Start: 2560, End: 4095},
   194  	}
   195  	c.Assert(ranges.FileRanges, chk.HasLen, 2)
   196  	c.Assert(ranges.FileRanges[0], chk.DeepEquals, expectedtRanges[0])
   197  	c.Assert(ranges.FileRanges[1], chk.DeepEquals, expectedtRanges[1])
   198  }
   199  
   200  func (s *StorageFileSuite) TestFileProperties(c *chk.C) {
   201  	cli := getFileClient(c)
   202  	rec := cli.client.appendRecorder(c)
   203  	defer rec.Stop()
   204  
   205  	// create share
   206  	share := cli.GetShareReference(shareName(c))
   207  	c.Assert(share.Create(nil), chk.IsNil)
   208  	defer share.Delete(nil)
   209  	root := share.GetRootDirectoryReference()
   210  
   211  	fileSize := uint64(512)
   212  	file := root.GetFileReference("test.dat")
   213  	c.Assert(file.Create(fileSize, nil), chk.IsNil)
   214  
   215  	// get initial set of properties
   216  	c.Assert(file.Properties.Length, chk.Equals, fileSize)
   217  	c.Assert(file.Properties.Etag, chk.NotNil)
   218  
   219  	// set some file properties
   220  	cc := "cachecontrol"
   221  	ct := "mytype"
   222  	enc := "noencoding"
   223  	lang := "neutral"
   224  	disp := "friendly"
   225  	file.Properties.CacheControl = cc
   226  	file.Properties.Type = ct
   227  	file.Properties.Disposition = disp
   228  	file.Properties.Encoding = enc
   229  	file.Properties.Language = lang
   230  	c.Assert(file.SetProperties(nil), chk.IsNil)
   231  
   232  	// retrieve and verify
   233  	c.Assert(file.FetchAttributes(nil), chk.IsNil)
   234  	c.Assert(file.Properties.CacheControl, chk.Equals, cc)
   235  	c.Assert(file.Properties.Type, chk.Equals, ct)
   236  	c.Assert(file.Properties.Disposition, chk.Equals, disp)
   237  	c.Assert(file.Properties.Encoding, chk.Equals, enc)
   238  	c.Assert(file.Properties.Language, chk.Equals, lang)
   239  }
   240  
   241  func (s *StorageFileSuite) TestFileMetadata(c *chk.C) {
   242  	cli := getFileClient(c)
   243  	rec := cli.client.appendRecorder(c)
   244  	defer rec.Stop()
   245  
   246  	// create share
   247  	share := cli.GetShareReference(shareName(c))
   248  	c.Assert(share.Create(nil), chk.IsNil)
   249  	defer share.Delete(nil)
   250  	root := share.GetRootDirectoryReference()
   251  
   252  	fileSize := uint64(512)
   253  	file := root.GetFileReference("test.dat")
   254  	c.Assert(file.Create(fileSize, nil), chk.IsNil)
   255  
   256  	// get metadata, shouldn't be any
   257  	c.Assert(file.Metadata, chk.HasLen, 0)
   258  
   259  	// set some custom metadata
   260  	md := map[string]string{
   261  		"something": "somethingvalue",
   262  		"another":   "anothervalue",
   263  	}
   264  	file.Metadata = md
   265  	c.Assert(file.SetMetadata(nil), chk.IsNil)
   266  
   267  	// retrieve and verify
   268  	c.Assert(file.FetchAttributes(nil), chk.IsNil)
   269  	c.Assert(file.Metadata, chk.DeepEquals, md)
   270  }
   271  
   272  func (s *StorageFileSuite) TestFileMD5(c *chk.C) {
   273  	cli := getFileClient(c)
   274  	rec := cli.client.appendRecorder(c)
   275  	defer rec.Stop()
   276  
   277  	// create share
   278  	share := cli.GetShareReference(shareName(c))
   279  	c.Assert(share.Create(nil), chk.IsNil)
   280  	defer share.Delete(nil)
   281  	root := share.GetRootDirectoryReference()
   282  
   283  	// create file
   284  	const size = uint64(1024)
   285  	fileSize := uint64(size)
   286  	file := root.GetFileReference("test.dat")
   287  	c.Assert(file.Create(fileSize, nil), chk.IsNil)
   288  
   289  	// fill file with some data and MD5 hash
   290  	byteStream, contentMD5 := newByteStream(size)
   291  	options := WriteRangeOptions{
   292  		ContentMD5: contentMD5,
   293  	}
   294  	c.Assert(file.WriteRange(byteStream, FileRange{End: size - 1}, &options), chk.IsNil)
   295  
   296  	// download file and verify
   297  	downloadOptions := GetFileOptions{
   298  		GetContentMD5: true,
   299  	}
   300  	stream, err := file.DownloadRangeToStream(FileRange{Start: 0, End: size - 1}, &downloadOptions)
   301  	c.Assert(err, chk.IsNil)
   302  	defer stream.Body.Close()
   303  	c.Assert(stream.ContentMD5, chk.Equals, contentMD5)
   304  }
   305  
   306  // returns a byte stream along with a base-64 encoded MD5 hash of its contents
   307  func newByteStream(count uint64) (io.Reader, string) {
   308  	b := make([]uint8, count)
   309  	for i := uint64(0); i < count; i++ {
   310  		b[i] = 0xff
   311  	}
   312  
   313  	// create an MD5 hash of the array
   314  	hash := md5.Sum(b)
   315  
   316  	return bytes.NewReader(b), base64.StdEncoding.EncodeToString(hash[:])
   317  }
   318  
   319  func (s *StorageFileSuite) TestCopyFileSameAccountNoMetaData(c *chk.C) {
   320  	cli := getFileClient(c)
   321  	rec := cli.client.appendRecorder(c)
   322  	defer rec.Stop()
   323  
   324  	// create share
   325  	share := cli.GetShareReference(shareName(c))
   326  	c.Assert(share.Create(nil), chk.IsNil)
   327  	defer share.Delete(nil)
   328  	root := share.GetRootDirectoryReference()
   329  
   330  	// create directory structure
   331  	dir1 := root.GetDirectoryReference("one")
   332  	c.Assert(dir1.Create(nil), chk.IsNil)
   333  	dir2 := dir1.GetDirectoryReference("two")
   334  	c.Assert(dir2.Create(nil), chk.IsNil)
   335  
   336  	// create file
   337  	file := dir2.GetFileReference("some.file")
   338  	c.Assert(file.Create(1024, nil), chk.IsNil)
   339  	exists, err := file.Exists()
   340  	c.Assert(err, chk.IsNil)
   341  	c.Assert(exists, chk.Equals, true)
   342  
   343  	otherFile := dir2.GetFileReference("someother.file")
   344  
   345  	// copy the file, no timeout parameter
   346  	err = otherFile.CopyFile(file.URL(), nil)
   347  	c.Assert(err, chk.IsNil)
   348  
   349  	// delete files
   350  	c.Assert(file.Delete(nil), chk.IsNil)
   351  	c.Assert(otherFile.Delete(nil), chk.IsNil)
   352  }
   353  
   354  func (s *StorageFileSuite) TestCopyFileSameAccountTimeout(c *chk.C) {
   355  	cli := getFileClient(c)
   356  	rec := cli.client.appendRecorder(c)
   357  	defer rec.Stop()
   358  
   359  	// create share
   360  	share := cli.GetShareReference(shareName(c))
   361  	c.Assert(share.Create(nil), chk.IsNil)
   362  	defer share.Delete(nil)
   363  	root := share.GetRootDirectoryReference()
   364  
   365  	// create directory structure
   366  	dir1 := root.GetDirectoryReference("one")
   367  	c.Assert(dir1.Create(nil), chk.IsNil)
   368  	dir2 := dir1.GetDirectoryReference("two")
   369  	c.Assert(dir2.Create(nil), chk.IsNil)
   370  
   371  	// create file
   372  	file := dir2.GetFileReference("some.file")
   373  	c.Assert(file.Create(1024, nil), chk.IsNil)
   374  
   375  	// copy the file, 60 second timeout.
   376  	otherFile := dir2.GetFileReference("someother.file")
   377  	options := FileRequestOptions{}
   378  	options.Timeout = 60
   379  	c.Assert(otherFile.CopyFile(file.URL(), &options), chk.IsNil)
   380  
   381  	// delete files
   382  	c.Assert(file.Delete(nil), chk.IsNil)
   383  	c.Assert(otherFile.Delete(nil), chk.IsNil)
   384  }
   385  
   386  func (s *StorageFileSuite) TestCopyFileMissingFile(c *chk.C) {
   387  	cli := getFileClient(c)
   388  	rec := cli.client.appendRecorder(c)
   389  	defer rec.Stop()
   390  
   391  	// create share
   392  	share := cli.GetShareReference(shareName(c))
   393  	c.Assert(share.Create(nil), chk.IsNil)
   394  	defer share.Delete(nil)
   395  	root := share.GetRootDirectoryReference()
   396  
   397  	// create directory structure
   398  	dir1 := root.GetDirectoryReference("one")
   399  	c.Assert(dir1.Create(nil), chk.IsNil)
   400  
   401  	otherFile := dir1.GetFileReference("someother.file")
   402  
   403  	// copy the file, no timeout parameter
   404  	err := otherFile.CopyFile("", nil)
   405  	c.Assert(err, chk.NotNil)
   406  }
   407  

View as plain text