Source file src/github.com/Azure/azure-sdk-for-go/storage/container_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  	"net/url"
     8  	"sort"
     9  	"strconv"
    10  	"time"
    11  
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	chk "gopkg.in/check.v1"
    14  )
    15  
    16  type ContainerSuite struct{}
    17  
    18  var _ = chk.Suite(&ContainerSuite{})
    19  
    20  func (s *ContainerSuite) Test_containerBuildPath(c *chk.C) {
    21  	cli := getBlobClient(c)
    22  	cnt := cli.GetContainerReference("lol")
    23  	c.Assert(cnt.buildPath(), chk.Equals, "/lol")
    24  }
    25  
    26  func (s *ContainerSuite) TestListContainersPagination(c *chk.C) {
    27  	cli := getBlobClient(c)
    28  	rec := cli.client.appendRecorder(c)
    29  	defer rec.Stop()
    30  	cli.deleteTestContainers(c)
    31  
    32  	const n = 5
    33  	const pageSize = 2
    34  
    35  	cntNames := []string{}
    36  	for i := 0; i < n; i++ {
    37  		cntNames = append(cntNames, containerName(c, strconv.Itoa(i)))
    38  	}
    39  	sort.Strings(cntNames)
    40  
    41  	// Create test containers
    42  	created := []*Container{}
    43  	for i := 0; i < n; i++ {
    44  		cnt := cli.GetContainerReference(cntNames[i])
    45  		c.Assert(cnt.Create(nil), chk.IsNil)
    46  		created = append(created, cnt)
    47  		cnt.Metadata = map[string]string{
    48  			"hello": "world",
    49  			"name":  cnt.Name,
    50  		}
    51  		c.Assert(cnt.SetMetadata(nil), chk.IsNil)
    52  		defer cnt.Delete(nil)
    53  	}
    54  
    55  	// Paginate results
    56  	seen := []Container{}
    57  	marker := ""
    58  	for {
    59  		resp, err := cli.ListContainers(ListContainersParameters{
    60  			MaxResults: pageSize,
    61  			Marker:     marker,
    62  			Include:    "metadata",
    63  		})
    64  
    65  		c.Assert(err, chk.IsNil)
    66  
    67  		if len(resp.Containers) > pageSize {
    68  			c.Fatalf("Got a bigger page. Expected: %d, got: %d", pageSize, len(resp.Containers))
    69  		}
    70  
    71  		for _, c := range resp.Containers {
    72  			seen = append(seen, c)
    73  		}
    74  
    75  		marker = resp.NextMarker
    76  		if marker == "" || len(resp.Containers) == 0 {
    77  			break
    78  		}
    79  	}
    80  
    81  	for i := range created {
    82  		c.Assert(seen[i].Name, chk.DeepEquals, created[i].Name)
    83  		c.Assert(seen[i].Metadata, chk.DeepEquals, created[i].Metadata)
    84  	}
    85  }
    86  
    87  func (s *ContainerSuite) TestContainerExists(c *chk.C) {
    88  	cli := getBlobClient(c)
    89  	rec := cli.client.appendRecorder(c)
    90  	defer rec.Stop()
    91  
    92  	// Container does not exist
    93  	cnt1 := cli.GetContainerReference(containerName(c, "1"))
    94  	ok, err := cnt1.Exists()
    95  	c.Assert(err, chk.IsNil)
    96  	c.Assert(ok, chk.Equals, false)
    97  
    98  	// Container exists
    99  	cnt2 := cli.GetContainerReference(containerName(c, "2"))
   100  	err = cnt2.Create(nil)
   101  	defer cnt2.Delete(nil)
   102  	c.Assert(err, chk.IsNil)
   103  	ok, err = cnt2.Exists()
   104  	c.Assert(err, chk.IsNil)
   105  	c.Assert(ok, chk.Equals, true)
   106  
   107  	// Service SASURI test (funcs should fail, service SAS has not enough permissions)
   108  	sasuriOptions := ContainerSASOptions{}
   109  	sasuriOptions.Expiry = fixedTime
   110  	sasuriOptions.Read = true
   111  	sasuriOptions.Add = true
   112  	sasuriOptions.Create = true
   113  	sasuriOptions.Write = true
   114  	sasuriOptions.Delete = true
   115  	sasuriOptions.List = true
   116  
   117  	sasuriString1, err := cnt1.GetSASURI(sasuriOptions)
   118  	c.Assert(err, chk.IsNil)
   119  	sasuri1, err := url.Parse(sasuriString1)
   120  	c.Assert(err, chk.IsNil)
   121  	cntServiceSAS1, err := GetContainerReferenceFromSASURI(*sasuri1)
   122  	c.Assert(err, chk.IsNil)
   123  	cntServiceSAS1.Client().HTTPClient = cli.client.HTTPClient
   124  
   125  	ok, err = cntServiceSAS1.Exists()
   126  	c.Assert(err, chk.NotNil)
   127  	c.Assert(ok, chk.Equals, false)
   128  
   129  	sasuriString2, err := cnt2.GetSASURI(sasuriOptions)
   130  	c.Assert(err, chk.IsNil)
   131  	sasuri2, err := url.Parse(sasuriString2)
   132  	c.Assert(err, chk.IsNil)
   133  	cntServiceSAS2, err := GetContainerReferenceFromSASURI(*sasuri2)
   134  	c.Assert(err, chk.IsNil)
   135  	cntServiceSAS2.Client().HTTPClient = cli.client.HTTPClient
   136  
   137  	ok, err = cntServiceSAS2.Exists()
   138  	c.Assert(err, chk.NotNil)
   139  	c.Assert(ok, chk.Equals, false)
   140  
   141  	// Account SASURI test
   142  	token, err := cli.client.GetAccountSASToken(accountSASOptions)
   143  	c.Assert(err, chk.IsNil)
   144  	SAScli := NewAccountSASClient(cli.client.accountName, token, azure.PublicCloud).GetBlobService()
   145  
   146  	cntAccountSAS1 := SAScli.GetContainerReference(cnt1.Name)
   147  	cntAccountSAS1.Client().HTTPClient = cli.client.HTTPClient
   148  	ok, err = cntAccountSAS1.Exists()
   149  	c.Assert(err, chk.IsNil)
   150  	c.Assert(ok, chk.Equals, false)
   151  
   152  	cntAccountSAS2 := SAScli.GetContainerReference(cnt2.Name)
   153  	cntAccountSAS2.Client().HTTPClient = cli.client.HTTPClient
   154  	ok, err = cntAccountSAS2.Exists()
   155  	c.Assert(err, chk.IsNil)
   156  	c.Assert(ok, chk.Equals, true)
   157  }
   158  
   159  func (s *ContainerSuite) TestCreateContainerDeleteContainer(c *chk.C) {
   160  	cli := getBlobClient(c)
   161  	rec := cli.client.appendRecorder(c)
   162  	defer rec.Stop()
   163  	cnt := cli.GetContainerReference(containerName(c))
   164  	c.Assert(cnt.Create(nil), chk.IsNil)
   165  	c.Assert(cnt.Delete(nil), chk.IsNil)
   166  }
   167  
   168  func (s *ContainerSuite) TestCreateContainerIfNotExists(c *chk.C) {
   169  	cli := getBlobClient(c)
   170  	rec := cli.client.appendRecorder(c)
   171  	defer rec.Stop()
   172  
   173  	// Create non exisiting container
   174  	cnt := cli.GetContainerReference(containerName(c))
   175  	ok, err := cnt.CreateIfNotExists(nil)
   176  	defer cnt.Delete(nil)
   177  	c.Assert(err, chk.IsNil)
   178  	c.Assert(ok, chk.Equals, true)
   179  
   180  }
   181  
   182  func (s *ContainerSuite) TestCreateContainerIfExists(c *chk.C) {
   183  	cli := getBlobClient(c)
   184  	rec := cli.client.appendRecorder(c)
   185  	defer rec.Stop()
   186  
   187  	cnt := cli.GetContainerReference(containerName(c))
   188  	cnt.Create(nil)
   189  	defer cnt.Delete(nil)
   190  
   191  	// Try to create already exisiting container
   192  	ok, err := cnt.CreateIfNotExists(nil)
   193  	c.Assert(err, chk.IsNil)
   194  	c.Assert(ok, chk.Equals, false)
   195  }
   196  
   197  func (s *ContainerSuite) TestDeleteContainerIfExists(c *chk.C) {
   198  	cli := getBlobClient(c)
   199  	rec := cli.client.appendRecorder(c)
   200  	defer rec.Stop()
   201  
   202  	// Nonexisting container
   203  	cnt1 := cli.GetContainerReference(containerName(c, "1"))
   204  	ok, err := cnt1.Exists()
   205  	c.Assert(err, chk.IsNil)
   206  	c.Assert(ok, chk.Equals, false)
   207  	ok, err = cnt1.DeleteIfExists(nil)
   208  	c.Assert(err, chk.IsNil)
   209  	c.Assert(ok, chk.Equals, false)
   210  
   211  	// Existing container
   212  	cnt2 := cli.GetContainerReference(containerName(c, "2"))
   213  	c.Assert(cnt2.Create(nil), chk.IsNil)
   214  	ok, err = cnt2.DeleteIfExists(nil)
   215  	c.Assert(err, chk.IsNil)
   216  	c.Assert(ok, chk.Equals, true)
   217  }
   218  
   219  func (s *ContainerSuite) TestListBlobsPagination(c *chk.C) {
   220  	cli := getBlobClient(c)
   221  	rec := cli.client.appendRecorder(c)
   222  	defer rec.Stop()
   223  	cnt := cli.GetContainerReference(containerName(c))
   224  
   225  	err := cnt.Create(nil)
   226  	defer cnt.Delete(nil)
   227  	c.Assert(err, chk.IsNil)
   228  
   229  	blobs := []string{}
   230  	types := []BlobType{}
   231  	const n = 5
   232  	const pageSize = 2
   233  	for i := 0; i < n; i++ {
   234  		name := blobName(c, strconv.Itoa(i))
   235  		b := cnt.GetBlobReference(name)
   236  		c.Assert(b.putSingleBlockBlob([]byte("Hello, world!")), chk.IsNil)
   237  		blobs = append(blobs, name)
   238  		types = append(types, b.Properties.BlobType)
   239  	}
   240  	sort.Strings(blobs)
   241  
   242  	listBlobsPagination(c, cnt, pageSize, blobs, types)
   243  
   244  	// Service SAS test
   245  	sasuriOptions := ContainerSASOptions{}
   246  	sasuriOptions.Expiry = fixedTime
   247  	sasuriOptions.Read = true
   248  	sasuriOptions.Add = true
   249  	sasuriOptions.Create = true
   250  	sasuriOptions.Write = true
   251  	sasuriOptions.Delete = true
   252  	sasuriOptions.List = true
   253  
   254  	sasuriString, err := cnt.GetSASURI(sasuriOptions)
   255  	c.Assert(err, chk.IsNil)
   256  	sasuri, err := url.Parse(sasuriString)
   257  	c.Assert(err, chk.IsNil)
   258  	cntServiceSAS, err := GetContainerReferenceFromSASURI(*sasuri)
   259  	c.Assert(err, chk.IsNil)
   260  	cntServiceSAS.Client().HTTPClient = cli.client.HTTPClient
   261  
   262  	listBlobsPagination(c, cntServiceSAS, pageSize, blobs, types)
   263  
   264  	// Account SAS test
   265  	token, err := cli.client.GetAccountSASToken(accountSASOptions)
   266  	c.Assert(err, chk.IsNil)
   267  	SAScli := NewAccountSASClient(cli.client.accountName, token, azure.PublicCloud).GetBlobService()
   268  
   269  	cntAccountSAS := SAScli.GetContainerReference(cnt.Name)
   270  	cntAccountSAS.Client().HTTPClient = cli.client.HTTPClient
   271  
   272  	listBlobsPagination(c, cntAccountSAS, pageSize, blobs, types)
   273  }
   274  
   275  func listBlobsPagination(c *chk.C, cnt *Container, pageSize uint, blobs []string, types []BlobType) {
   276  	// Paginate
   277  	seen := []string{}
   278  	seenTypes := []BlobType{}
   279  	marker := ""
   280  	for {
   281  		resp, err := cnt.ListBlobs(ListBlobsParameters{
   282  			MaxResults: pageSize,
   283  			Marker:     marker})
   284  		c.Assert(err, chk.IsNil)
   285  
   286  		for _, b := range resp.Blobs {
   287  			seen = append(seen, b.Name)
   288  			seenTypes = append(seenTypes, b.Properties.BlobType)
   289  			c.Assert(b.Container, chk.Equals, cnt)
   290  		}
   291  
   292  		marker = resp.NextMarker
   293  		if marker == "" || len(resp.Blobs) == 0 {
   294  			break
   295  		}
   296  	}
   297  
   298  	// Compare
   299  	c.Assert(seen, chk.DeepEquals, blobs)
   300  	c.Assert(seenTypes, chk.DeepEquals, types)
   301  }
   302  
   303  // listBlobsAsFiles is a helper function to list blobs as "folders" and "files".
   304  func listBlobsAsFiles(cli BlobStorageClient, cnt *Container, parentDir string) (folders []string, files []string, err error) {
   305  	var blobParams ListBlobsParameters
   306  	var blobListResponse BlobListResponse
   307  
   308  	// Top level "folders"
   309  	blobParams = ListBlobsParameters{
   310  		Delimiter: "/",
   311  		Prefix:    parentDir,
   312  	}
   313  
   314  	blobListResponse, err = cnt.ListBlobs(blobParams)
   315  	if err != nil {
   316  		return nil, nil, err
   317  	}
   318  
   319  	// These are treated as "folders" under the parentDir.
   320  	folders = blobListResponse.BlobPrefixes
   321  
   322  	// "Files"" are blobs which are under the parentDir.
   323  	files = make([]string, len(blobListResponse.Blobs))
   324  	for i := range blobListResponse.Blobs {
   325  		files[i] = blobListResponse.Blobs[i].Name
   326  	}
   327  
   328  	return folders, files, nil
   329  }
   330  
   331  // TestListBlobsTraversal tests that we can correctly traverse
   332  // blobs in blob storage as if it were a file system by using
   333  // a combination of Prefix, Delimiter, and BlobPrefixes.
   334  //
   335  // Blob storage is flat, but we can *simulate* the file
   336  // system with folders and files using conventions in naming.
   337  // With the blob namedd "/usr/bin/ls", when we use delimiter '/',
   338  // the "ls" would be a "file"; with "/", /usr" and "/usr/bin" being
   339  // the "folders"
   340  //
   341  // NOTE: The use of delimiter (eg forward slash) is extremely fiddly
   342  // and difficult to get right so some discipline in naming and rules
   343  // when using the API is required to get everything to work as expected.
   344  //
   345  // Assuming our delimiter is a forward slash, the rules are:
   346  //
   347  //  - Do use a leading forward slash in blob names to make things
   348  //    consistent and simpler (see further).
   349  //    Note that doing so will show "<no name>" as the only top-level
   350  //    folder in the container in Azure portal, which may look strange.
   351  //
   352  //  - The "folder names" are returned *with trailing forward slash* as per MSDN.
   353  //
   354  //  - The "folder names" will be "absolute paths", e.g. listing things under "/usr/"
   355  //    will return folder names "/usr/bin/".
   356  //
   357  //  - The "file names" are returned as full blob names, e.g. when listing
   358  //    things under "/usr/bin/", the file names will be "/usr/bin/ls" and
   359  //    "/usr/bin/cat".
   360  //
   361  //  - Everything is returned with case-sensitive order as expected in real file system
   362  //    as per MSDN.
   363  //
   364  //  - To list things under a "folder" always use trailing forward slash.
   365  //
   366  //    Example: to list top level folders we use root folder named "" with
   367  //    trailing forward slash, so we use "/".
   368  //
   369  //    Example: to list folders under "/usr", we again append forward slash and
   370  //    so we use "/usr/".
   371  //
   372  //    Because we use leading forward slash we don't need to have different
   373  //    treatment of "get top-level folders" and "get non-top-level folders"
   374  //    scenarios.
   375  func (s *ContainerSuite) TestListBlobsTraversal(c *chk.C) {
   376  	cli := getBlobClient(c)
   377  	rec := cli.client.appendRecorder(c)
   378  	defer rec.Stop()
   379  
   380  	cnt := cli.GetContainerReference(containerName(c))
   381  	c.Assert(cnt.Create(nil), chk.IsNil)
   382  	defer cnt.Delete(nil)
   383  
   384  	// Note use of leading forward slash as per naming rules.
   385  	blobsToCreate := []string{
   386  		"/usr/bin/ls",
   387  		"/usr/bin/cat",
   388  		"/usr/lib64/libc.so",
   389  		"/etc/hosts",
   390  		"/etc/init.d/iptables",
   391  	}
   392  
   393  	// Create the above blobs
   394  	for _, blobName := range blobsToCreate {
   395  		b := cnt.GetBlobReference(blobName)
   396  		err := b.CreateBlockBlob(nil)
   397  		c.Assert(err, chk.IsNil)
   398  	}
   399  
   400  	var folders []string
   401  	var files []string
   402  	var err error
   403  
   404  	// Top level folders and files.
   405  	folders, files, err = listBlobsAsFiles(cli, cnt, "/")
   406  	c.Assert(err, chk.IsNil)
   407  	c.Assert(folders, chk.DeepEquals, []string{"/etc/", "/usr/"})
   408  	c.Assert(files, chk.DeepEquals, []string{})
   409  
   410  	// Things under /etc/. Note use of trailing forward slash here as per rules.
   411  	folders, files, err = listBlobsAsFiles(cli, cnt, "/etc/")
   412  	c.Assert(err, chk.IsNil)
   413  	c.Assert(folders, chk.DeepEquals, []string{"/etc/init.d/"})
   414  	c.Assert(files, chk.DeepEquals, []string{"/etc/hosts"})
   415  
   416  	// Things under /etc/init.d/
   417  	folders, files, err = listBlobsAsFiles(cli, cnt, "/etc/init.d/")
   418  	c.Assert(err, chk.IsNil)
   419  	c.Assert(folders, chk.DeepEquals, []string(nil))
   420  	c.Assert(files, chk.DeepEquals, []string{"/etc/init.d/iptables"})
   421  
   422  	// Things under /usr/
   423  	folders, files, err = listBlobsAsFiles(cli, cnt, "/usr/")
   424  	c.Assert(err, chk.IsNil)
   425  	c.Assert(folders, chk.DeepEquals, []string{"/usr/bin/", "/usr/lib64/"})
   426  	c.Assert(files, chk.DeepEquals, []string{})
   427  
   428  	// Things under /usr/bin/
   429  	folders, files, err = listBlobsAsFiles(cli, cnt, "/usr/bin/")
   430  	c.Assert(err, chk.IsNil)
   431  	c.Assert(folders, chk.DeepEquals, []string(nil))
   432  	c.Assert(files, chk.DeepEquals, []string{"/usr/bin/cat", "/usr/bin/ls"})
   433  }
   434  
   435  func (s *ContainerSuite) TestListBlobsWithMetadata(c *chk.C) {
   436  	cli := getBlobClient(c)
   437  	rec := cli.client.appendRecorder(c)
   438  	defer rec.Stop()
   439  
   440  	cnt := cli.GetContainerReference(containerName(c))
   441  	c.Assert(cnt.Create(nil), chk.IsNil)
   442  	defer cnt.Delete(nil)
   443  
   444  	expectMeta := make(map[string]BlobMetadata)
   445  
   446  	// Put 4 blobs with metadata
   447  	for i := 0; i < 4; i++ {
   448  		name := blobName(c, strconv.Itoa(i))
   449  		b := cnt.GetBlobReference(name)
   450  		c.Assert(b.putSingleBlockBlob([]byte("Hello, world!")), chk.IsNil)
   451  		b.Metadata = BlobMetadata{
   452  			"Lol":      name,
   453  			"Rofl_BAZ": "Waz Qux",
   454  		}
   455  		c.Assert(b.SetMetadata(nil), chk.IsNil)
   456  		expectMeta[name] = BlobMetadata{
   457  			"lol":      name,
   458  			"rofl_baz": "Waz Qux",
   459  		}
   460  		_, err := b.CreateSnapshot(nil)
   461  		c.Assert(err, chk.IsNil)
   462  	}
   463  
   464  	// Put one more blob with no metadata
   465  	b := cnt.GetBlobReference(blobName(c, "nometa"))
   466  	c.Assert(b.putSingleBlockBlob([]byte("Hello, world!")), chk.IsNil)
   467  	expectMeta[b.Name] = nil
   468  
   469  	// Get ListBlobs with include: metadata and snapshots
   470  	resp, err := cnt.ListBlobs(ListBlobsParameters{
   471  		Include: &IncludeBlobDataset{
   472  			Metadata:  true,
   473  			Snapshots: true,
   474  		},
   475  	})
   476  	c.Assert(err, chk.IsNil)
   477  
   478  	originalBlobs := make(map[string]Blob)
   479  	snapshotBlobs := make(map[string]Blob)
   480  	for _, v := range resp.Blobs {
   481  		if v.Snapshot == (time.Time{}) {
   482  			originalBlobs[v.Name] = v
   483  		} else {
   484  			snapshotBlobs[v.Name] = v
   485  
   486  		}
   487  	}
   488  	c.Assert(originalBlobs, chk.HasLen, 5)
   489  	c.Assert(snapshotBlobs, chk.HasLen, 4)
   490  
   491  	// Verify the metadata is as expected
   492  	for name := range expectMeta {
   493  		c.Check(originalBlobs[name].Metadata, chk.DeepEquals, expectMeta[name])
   494  		c.Check(snapshotBlobs[name].Metadata, chk.DeepEquals, expectMeta[name])
   495  	}
   496  }
   497  
   498  func appendContainerPermission(perms ContainerPermissions, accessType ContainerAccessType,
   499  	ID string, start time.Time, expiry time.Time,
   500  	canRead bool, canWrite bool, canDelete bool) ContainerPermissions {
   501  
   502  	perms.AccessType = accessType
   503  
   504  	if ID != "" {
   505  		capd := ContainerAccessPolicy{
   506  			ID:         ID,
   507  			StartTime:  start,
   508  			ExpiryTime: expiry,
   509  			CanRead:    canRead,
   510  			CanWrite:   canWrite,
   511  			CanDelete:  canDelete,
   512  		}
   513  		perms.AccessPolicies = append(perms.AccessPolicies, capd)
   514  	}
   515  	return perms
   516  }
   517  
   518  func (s *ContainerSuite) TestSetContainerPermissionsWithTimeoutSuccessfully(c *chk.C) {
   519  	cli := getBlobClient(c)
   520  	rec := cli.client.appendRecorder(c)
   521  	defer rec.Stop()
   522  
   523  	cnt := cli.GetContainerReference(containerName(c))
   524  	c.Assert(cnt.Create(nil), chk.IsNil)
   525  	defer cnt.Delete(nil)
   526  
   527  	perms := ContainerPermissions{}
   528  	perms = appendContainerPermission(perms, ContainerAccessTypeBlob, "GolangRocksOnAzure", fixedTime, fixedTime.Add(10*time.Hour), true, true, true)
   529  
   530  	options := SetContainerPermissionOptions{
   531  		Timeout: 30,
   532  	}
   533  	err := cnt.SetPermissions(perms, &options)
   534  	c.Assert(err, chk.IsNil)
   535  }
   536  
   537  func (s *ContainerSuite) TestSetContainerPermissionsSuccessfully(c *chk.C) {
   538  	cli := getBlobClient(c)
   539  	rec := cli.client.appendRecorder(c)
   540  	defer rec.Stop()
   541  
   542  	cnt := cli.GetContainerReference(containerName(c))
   543  	c.Assert(cnt.Create(nil), chk.IsNil)
   544  	defer cnt.Delete(nil)
   545  
   546  	perms := ContainerPermissions{}
   547  	perms = appendContainerPermission(perms, ContainerAccessTypeBlob, "GolangRocksOnAzure", fixedTime, fixedTime.Add(10*time.Hour), true, true, true)
   548  
   549  	err := cnt.SetPermissions(perms, nil)
   550  	c.Assert(err, chk.IsNil)
   551  }
   552  
   553  func (s *ContainerSuite) TestSetThenGetContainerPermissionsSuccessfully(c *chk.C) {
   554  	cli := getBlobClient(c)
   555  	rec := cli.client.appendRecorder(c)
   556  	defer rec.Stop()
   557  
   558  	cnt := cli.GetContainerReference(containerName(c))
   559  	c.Assert(cnt.Create(nil), chk.IsNil)
   560  	defer cnt.delete(nil)
   561  
   562  	perms := ContainerPermissions{}
   563  	perms = appendContainerPermission(perms, ContainerAccessTypeBlob, "AutoRestIsSuperCool", fixedTime, fixedTime.Add(10*time.Hour), true, true, true)
   564  	perms = appendContainerPermission(perms, ContainerAccessTypeBlob, "GolangRocksOnAzure", fixedTime.Add(20*time.Hour), fixedTime.Add(30*time.Hour), true, false, false)
   565  	c.Assert(perms.AccessPolicies, chk.HasLen, 2)
   566  
   567  	err := cnt.SetPermissions(perms, nil)
   568  	c.Assert(err, chk.IsNil)
   569  
   570  	newPerms, err := cnt.GetPermissions(nil)
   571  	c.Assert(err, chk.IsNil)
   572  
   573  	// check container permissions itself.
   574  	c.Assert(newPerms.AccessType, chk.Equals, perms.AccessType)
   575  
   576  	// fixedTime check policy set.
   577  	c.Assert(newPerms.AccessPolicies, chk.HasLen, 2)
   578  
   579  	for i := range perms.AccessPolicies {
   580  		c.Assert(newPerms.AccessPolicies[i].ID, chk.Equals, perms.AccessPolicies[i].ID)
   581  
   582  		// test timestamps down the second
   583  		// rounding start/expiry time original perms since the returned perms would have been rounded.
   584  		// so need rounded vs rounded.
   585  		c.Assert(newPerms.AccessPolicies[i].StartTime.UTC().Round(time.Second).Format(time.RFC1123),
   586  			chk.Equals, perms.AccessPolicies[i].StartTime.UTC().Round(time.Second).Format(time.RFC1123))
   587  
   588  		c.Assert(newPerms.AccessPolicies[i].ExpiryTime.UTC().Round(time.Second).Format(time.RFC1123),
   589  			chk.Equals, perms.AccessPolicies[i].ExpiryTime.UTC().Round(time.Second).Format(time.RFC1123))
   590  
   591  		c.Assert(newPerms.AccessPolicies[i].CanRead, chk.Equals, perms.AccessPolicies[i].CanRead)
   592  		c.Assert(newPerms.AccessPolicies[i].CanWrite, chk.Equals, perms.AccessPolicies[i].CanWrite)
   593  		c.Assert(newPerms.AccessPolicies[i].CanDelete, chk.Equals, perms.AccessPolicies[i].CanDelete)
   594  	}
   595  }
   596  
   597  func (s *ContainerSuite) TestSetContainerPermissionsOnlySuccessfully(c *chk.C) {
   598  	cli := getBlobClient(c)
   599  	rec := cli.client.appendRecorder(c)
   600  	defer rec.Stop()
   601  
   602  	cnt := cli.GetContainerReference(containerName(c))
   603  	c.Assert(cnt.Create(nil), chk.IsNil)
   604  	defer cnt.Delete(nil)
   605  
   606  	perms := ContainerPermissions{}
   607  	perms = appendContainerPermission(perms, ContainerAccessTypeBlob, "GolangRocksOnAzure", fixedTime, fixedTime.Add(10*time.Hour), true, true, true)
   608  
   609  	err := cnt.SetPermissions(perms, nil)
   610  	c.Assert(err, chk.IsNil)
   611  }
   612  
   613  func (s *ContainerSuite) TestSetThenGetContainerPermissionsOnlySuccessfully(c *chk.C) {
   614  	cli := getBlobClient(c)
   615  	rec := cli.client.appendRecorder(c)
   616  	defer rec.Stop()
   617  
   618  	cnt := cli.GetContainerReference(containerName(c))
   619  	c.Assert(cnt.Create(nil), chk.IsNil)
   620  	defer cnt.Delete(nil)
   621  
   622  	perms := ContainerPermissions{}
   623  	perms = appendContainerPermission(perms, ContainerAccessTypeBlob, "", fixedTime, fixedTime.Add(10*time.Hour), true, true, true)
   624  
   625  	err := cnt.SetPermissions(perms, nil)
   626  	c.Assert(err, chk.IsNil)
   627  
   628  	newPerms, err := cnt.GetPermissions(nil)
   629  	c.Assert(err, chk.IsNil)
   630  
   631  	// check container permissions itself.
   632  	c.Assert(newPerms.AccessType, chk.Equals, perms.AccessType)
   633  
   634  	// fixedTime check there are NO policies set
   635  	c.Assert(newPerms.AccessPolicies, chk.HasLen, 0)
   636  }
   637  
   638  func (s *ContainerSuite) TestGetAndSetContainerMetadata(c *chk.C) {
   639  	cli := getBlobClient(c)
   640  	rec := cli.client.appendRecorder(c)
   641  	defer rec.Stop()
   642  
   643  	// Get empty metadata
   644  	cnt1 := cli.GetContainerReference(containerName(c, "1"))
   645  	c.Assert(cnt1.Create(nil), chk.IsNil)
   646  	defer cnt1.Delete(nil)
   647  
   648  	err := cnt1.GetMetadata(nil)
   649  	c.Assert(err, chk.IsNil)
   650  	c.Assert(cnt1.Metadata, chk.HasLen, 0)
   651  
   652  	// Get and set the metadata
   653  	cnt2 := cli.GetContainerReference(containerName(c, "2"))
   654  	c.Assert(cnt2.Create(nil), chk.IsNil)
   655  	defer cnt2.Delete(nil)
   656  
   657  	metaPut := map[string]string{
   658  		"lol":      "rofl",
   659  		"rofl_baz": "waz qux",
   660  	}
   661  	cnt2.Metadata = metaPut
   662  
   663  	err = cnt2.SetMetadata(nil)
   664  	c.Assert(err, chk.IsNil)
   665  
   666  	err = cnt2.GetMetadata(nil)
   667  	c.Assert(err, chk.IsNil)
   668  	c.Check(cnt2.Metadata, chk.DeepEquals, metaPut)
   669  }
   670  
   671  func (s *ContainerSuite) TestGetContainerProperties(c *chk.C) {
   672  	cli := getBlobClient(c)
   673  	rec := cli.client.appendRecorder(c)
   674  	defer rec.Stop()
   675  
   676  	// Get empty metadata
   677  	cnt1 := cli.GetContainerReference(containerName(c, "1"))
   678  	c.Assert(cnt1.Create(nil), chk.IsNil)
   679  	defer cnt1.Delete(nil)
   680  
   681  	// should be empty until we get properties
   682  	c.Assert(cnt1.Properties.Etag, chk.HasLen, 0)
   683  
   684  	err := cnt1.GetProperties()
   685  	c.Assert(err, chk.IsNil)
   686  	c.Assert(cnt1.Properties.Etag, chk.Equals, `"0x8D9001BBA6C4080"`)
   687  	c.Assert(cnt1.Properties.PublicAccess, chk.Equals, ContainerAccessType(""))
   688  }
   689  
   690  func (cli *BlobStorageClient) deleteTestContainers(c *chk.C) error {
   691  	for {
   692  		resp, err := cli.ListContainers(ListContainersParameters{})
   693  		if err != nil {
   694  			return err
   695  		}
   696  		if len(resp.Containers) == 0 {
   697  			break
   698  		}
   699  		for _, c := range resp.Containers {
   700  			err = c.Delete(nil)
   701  			if err != nil {
   702  				return err
   703  			}
   704  		}
   705  	}
   706  	return nil
   707  }
   708  
   709  func containerName(c *chk.C, extras ...string) string {
   710  	return nameGenerator(32, "", alphanum, c, extras)
   711  }
   712  

View as plain text