github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/state/backups/storage_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package backups_test
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/juju/errors"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/state/backups"
    14  	statetesting "github.com/juju/juju/state/testing"
    15  )
    16  
    17  type storageSuite struct {
    18  	statetesting.StateSuite
    19  }
    20  
    21  var _ = gc.Suite(&storageSuite{})
    22  
    23  func (s *storageSuite) metadata(c *gc.C) *backups.Metadata {
    24  	meta := backups.NewMetadata()
    25  	meta.Origin.Model = s.State.ModelUUID()
    26  	meta.Origin.Machine = "0"
    27  	meta.Origin.Hostname = "localhost"
    28  	err := meta.MarkComplete(int64(42), "some hash")
    29  	c.Assert(err, jc.ErrorIsNil)
    30  	return meta
    31  }
    32  
    33  func (s *storageSuite) checkMeta(c *gc.C, meta, expected *backups.Metadata, id string,
    34  ) {
    35  	if id != "" {
    36  		c.Check(meta.ID(), gc.Equals, id)
    37  	}
    38  	c.Check(meta.Notes, gc.Equals, expected.Notes)
    39  	c.Check(meta.Started.Unix(), gc.Equals, expected.Started.Unix())
    40  	c.Check(meta.Checksum(), gc.Equals, expected.Checksum())
    41  	c.Check(meta.ChecksumFormat(), gc.Equals, expected.ChecksumFormat())
    42  	c.Check(meta.Size(), gc.Equals, expected.Size())
    43  	c.Check(meta.Origin.Model, gc.Equals, expected.Origin.Model)
    44  	c.Check(meta.Origin.Machine, gc.Equals, expected.Origin.Machine)
    45  	c.Check(meta.Origin.Hostname, gc.Equals, expected.Origin.Hostname)
    46  	c.Check(meta.Origin.Version, gc.Equals, expected.Origin.Version)
    47  	if meta.Stored() != nil && expected.Stored() != nil {
    48  		c.Check(meta.Stored().Unix(), gc.Equals, expected.Stored().Unix())
    49  	} else {
    50  		c.Check(meta.Stored(), gc.Equals, expected.Stored())
    51  	}
    52  }
    53  
    54  func (s *storageSuite) TestNewStorageID(c *gc.C) {
    55  	meta := s.metadata(c)
    56  	meta.Origin.Model = "spam"
    57  	meta.Started = time.Date(2014, time.Month(9), 12, 13, 19, 27, 0, time.UTC)
    58  	id := backups.NewBackupID(meta)
    59  
    60  	c.Check(id, gc.Equals, "20140912-131927.spam")
    61  }
    62  
    63  func (s *storageSuite) TestGetBackupMetadataFound(c *gc.C) {
    64  	original := s.metadata(c)
    65  	id, err := backups.AddBackupMetadata(s.State, original)
    66  	c.Assert(err, jc.ErrorIsNil)
    67  
    68  	meta, err := backups.GetBackupMetadata(s.State, id)
    69  	c.Assert(err, jc.ErrorIsNil)
    70  
    71  	s.checkMeta(c, meta, original, id)
    72  }
    73  
    74  func (s *storageSuite) TestGetBackupMetadataNotFound(c *gc.C) {
    75  	_, err := backups.GetBackupMetadata(s.State, "spam")
    76  
    77  	c.Check(err, jc.Satisfies, errors.IsNotFound)
    78  }
    79  
    80  func (s *storageSuite) TestAddBackupMetadataSuccess(c *gc.C) {
    81  	original := s.metadata(c)
    82  	id, err := backups.AddBackupMetadata(s.State, original)
    83  	c.Assert(err, jc.ErrorIsNil)
    84  
    85  	meta, err := backups.GetBackupMetadata(s.State, id)
    86  	c.Assert(err, jc.ErrorIsNil)
    87  
    88  	s.checkMeta(c, meta, original, id)
    89  }
    90  
    91  func (s *storageSuite) TestAddBackupMetadataGeneratedID(c *gc.C) {
    92  	original := s.metadata(c)
    93  	original.SetID("spam")
    94  	id, err := backups.AddBackupMetadata(s.State, original)
    95  	c.Assert(err, jc.ErrorIsNil)
    96  
    97  	c.Check(id, gc.Not(gc.Equals), "spam")
    98  }
    99  
   100  func (s *storageSuite) TestAddBackupMetadataEmpty(c *gc.C) {
   101  	original := backups.NewMetadata()
   102  	_, err := backups.AddBackupMetadata(s.State, original)
   103  
   104  	c.Check(err, gc.NotNil)
   105  }
   106  
   107  func (s *storageSuite) TestAddBackupMetadataAlreadyExists(c *gc.C) {
   108  	original := s.metadata(c)
   109  	id, err := backups.AddBackupMetadata(s.State, original)
   110  	c.Assert(err, jc.ErrorIsNil)
   111  	err = backups.AddBackupMetadataID(s.State, original, id)
   112  
   113  	c.Check(err, jc.Satisfies, errors.IsAlreadyExists)
   114  }
   115  
   116  func (s *storageSuite) TestSetBackupStoredTimeSuccess(c *gc.C) {
   117  	stored := time.Now()
   118  	original := s.metadata(c)
   119  	id, err := backups.AddBackupMetadata(s.State, original)
   120  	c.Assert(err, jc.ErrorIsNil)
   121  	meta, err := backups.GetBackupMetadata(s.State, id)
   122  	c.Assert(err, jc.ErrorIsNil)
   123  	c.Assert(meta.Stored(), gc.IsNil)
   124  
   125  	err = backups.SetBackupStoredTime(s.State, id, stored)
   126  	c.Assert(err, jc.ErrorIsNil)
   127  
   128  	meta, err = backups.GetBackupMetadata(s.State, id)
   129  	c.Assert(err, jc.ErrorIsNil)
   130  	c.Check(meta.Stored().Unix(), gc.Equals, stored.UTC().Unix())
   131  }
   132  
   133  func (s *storageSuite) TestSetBackupStoredTimeNotFound(c *gc.C) {
   134  	stored := time.Now()
   135  	err := backups.SetBackupStoredTime(s.State, "spam", stored)
   136  
   137  	c.Check(err, jc.Satisfies, errors.IsNotFound)
   138  }