github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/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  	gitjujutesting "github.com/juju/testing"
    11  	jc "github.com/juju/testing/checkers"
    12  	gc "gopkg.in/check.v1"
    13  
    14  	"github.com/juju/juju/state"
    15  	"github.com/juju/juju/state/backups"
    16  	statetesting "github.com/juju/juju/state/testing"
    17  	"github.com/juju/juju/testing"
    18  )
    19  
    20  type storageSuite struct {
    21  	gitjujutesting.MgoSuite
    22  	testing.BaseSuite
    23  	State *state.State
    24  }
    25  
    26  var _ = gc.Suite(&storageSuite{})
    27  
    28  func (s *storageSuite) SetUpSuite(c *gc.C) {
    29  	s.BaseSuite.SetUpSuite(c)
    30  	s.MgoSuite.SetUpSuite(c)
    31  }
    32  
    33  func (s *storageSuite) TearDownSuite(c *gc.C) {
    34  	s.MgoSuite.TearDownSuite(c)
    35  	s.BaseSuite.TearDownSuite(c)
    36  }
    37  
    38  func (s *storageSuite) SetUpTest(c *gc.C) {
    39  	s.BaseSuite.SetUpTest(c)
    40  	s.MgoSuite.SetUpTest(c)
    41  	s.State = statetesting.NewState(c)
    42  }
    43  
    44  func (s *storageSuite) TearDownTest(c *gc.C) {
    45  	if s.State != nil {
    46  		// If setup fails, we don't have a State yet
    47  		s.State.Close()
    48  	}
    49  	s.MgoSuite.TearDownTest(c)
    50  	s.BaseSuite.TearDownTest(c)
    51  }
    52  
    53  func (s *storageSuite) metadata(c *gc.C) *backups.Metadata {
    54  	meta := backups.NewMetadata()
    55  	meta.Origin.Model = s.State.ModelUUID()
    56  	meta.Origin.Machine = "0"
    57  	meta.Origin.Hostname = "localhost"
    58  	err := meta.MarkComplete(int64(42), "some hash")
    59  	c.Assert(err, jc.ErrorIsNil)
    60  	return meta
    61  }
    62  
    63  func (s *storageSuite) checkMeta(c *gc.C, meta, expected *backups.Metadata, id string,
    64  ) {
    65  	if id != "" {
    66  		c.Check(meta.ID(), gc.Equals, id)
    67  	}
    68  	c.Check(meta.Notes, gc.Equals, expected.Notes)
    69  	c.Check(meta.Started.Unix(), gc.Equals, expected.Started.Unix())
    70  	c.Check(meta.Checksum(), gc.Equals, expected.Checksum())
    71  	c.Check(meta.ChecksumFormat(), gc.Equals, expected.ChecksumFormat())
    72  	c.Check(meta.Size(), gc.Equals, expected.Size())
    73  	c.Check(meta.Origin.Model, gc.Equals, expected.Origin.Model)
    74  	c.Check(meta.Origin.Machine, gc.Equals, expected.Origin.Machine)
    75  	c.Check(meta.Origin.Hostname, gc.Equals, expected.Origin.Hostname)
    76  	c.Check(meta.Origin.Version, gc.Equals, expected.Origin.Version)
    77  	if meta.Stored() != nil && expected.Stored() != nil {
    78  		c.Check(meta.Stored().Unix(), gc.Equals, expected.Stored().Unix())
    79  	} else {
    80  		c.Check(meta.Stored(), gc.Equals, expected.Stored())
    81  	}
    82  }
    83  
    84  func (s *storageSuite) TestNewStorageID(c *gc.C) {
    85  	meta := s.metadata(c)
    86  	meta.Origin.Model = "spam"
    87  	meta.Started = time.Date(2014, time.Month(9), 12, 13, 19, 27, 0, time.UTC)
    88  	id := backups.NewBackupID(meta)
    89  
    90  	c.Check(id, gc.Equals, "20140912-131927.spam")
    91  }
    92  
    93  func (s *storageSuite) TestGetBackupMetadataFound(c *gc.C) {
    94  	original := s.metadata(c)
    95  	id, err := backups.AddBackupMetadata(s.State, original)
    96  	c.Assert(err, jc.ErrorIsNil)
    97  
    98  	meta, err := backups.GetBackupMetadata(s.State, id)
    99  	c.Assert(err, jc.ErrorIsNil)
   100  
   101  	s.checkMeta(c, meta, original, id)
   102  }
   103  
   104  func (s *storageSuite) TestGetBackupMetadataNotFound(c *gc.C) {
   105  	_, err := backups.GetBackupMetadata(s.State, "spam")
   106  
   107  	c.Check(err, jc.Satisfies, errors.IsNotFound)
   108  }
   109  
   110  func (s *storageSuite) TestAddBackupMetadataSuccess(c *gc.C) {
   111  	original := s.metadata(c)
   112  	id, err := backups.AddBackupMetadata(s.State, original)
   113  	c.Assert(err, jc.ErrorIsNil)
   114  
   115  	meta, err := backups.GetBackupMetadata(s.State, id)
   116  	c.Assert(err, jc.ErrorIsNil)
   117  
   118  	s.checkMeta(c, meta, original, id)
   119  }
   120  
   121  func (s *storageSuite) TestAddBackupMetadataGeneratedID(c *gc.C) {
   122  	original := s.metadata(c)
   123  	original.SetID("spam")
   124  	id, err := backups.AddBackupMetadata(s.State, original)
   125  	c.Assert(err, jc.ErrorIsNil)
   126  
   127  	c.Check(id, gc.Not(gc.Equals), "spam")
   128  }
   129  
   130  func (s *storageSuite) TestAddBackupMetadataEmpty(c *gc.C) {
   131  	original := backups.NewMetadata()
   132  	_, err := backups.AddBackupMetadata(s.State, original)
   133  
   134  	c.Check(err, gc.NotNil)
   135  }
   136  
   137  func (s *storageSuite) TestAddBackupMetadataAlreadyExists(c *gc.C) {
   138  	original := s.metadata(c)
   139  	id, err := backups.AddBackupMetadata(s.State, original)
   140  	c.Assert(err, jc.ErrorIsNil)
   141  	err = backups.AddBackupMetadataID(s.State, original, id)
   142  
   143  	c.Check(err, jc.Satisfies, errors.IsAlreadyExists)
   144  }
   145  
   146  func (s *storageSuite) TestSetBackupStoredTimeSuccess(c *gc.C) {
   147  	stored := time.Now()
   148  	original := s.metadata(c)
   149  	id, err := backups.AddBackupMetadata(s.State, original)
   150  	c.Assert(err, jc.ErrorIsNil)
   151  	meta, err := backups.GetBackupMetadata(s.State, id)
   152  	c.Assert(err, jc.ErrorIsNil)
   153  	c.Assert(meta.Stored(), gc.IsNil)
   154  
   155  	err = backups.SetBackupStoredTime(s.State, id, stored)
   156  	c.Assert(err, jc.ErrorIsNil)
   157  
   158  	meta, err = backups.GetBackupMetadata(s.State, id)
   159  	c.Assert(err, jc.ErrorIsNil)
   160  	c.Check(meta.Stored().Unix(), gc.Equals, stored.UTC().Unix())
   161  }
   162  
   163  func (s *storageSuite) TestSetBackupStoredTimeNotFound(c *gc.C) {
   164  	stored := time.Now()
   165  	err := backups.SetBackupStoredTime(s.State, "spam", stored)
   166  
   167  	c.Check(err, jc.Satisfies, errors.IsNotFound)
   168  }