github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/state/backups/archive_data_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  	"bytes"
     8  	"compress/gzip"
     9  	"io"
    10  	"io/ioutil"
    11  
    12  	"github.com/juju/testing"
    13  	jc "github.com/juju/testing/checkers"
    14  	gc "gopkg.in/check.v1"
    15  
    16  	"github.com/juju/juju/state/backups"
    17  	bt "github.com/juju/juju/state/backups/testing"
    18  )
    19  
    20  type archiveDataSuite struct {
    21  	testing.IsolationSuite
    22  	archiveFile *bytes.Buffer
    23  	data        []byte
    24  	meta        *backups.Metadata
    25  }
    26  
    27  var _ = gc.Suite(&archiveDataSuite{})
    28  
    29  func (s *archiveDataSuite) SetUpTest(c *gc.C) {
    30  	s.IsolationSuite.SetUpTest(c)
    31  
    32  	meta, err := backups.NewMetadataJSONReader(bytes.NewBufferString(`{` +
    33  		`"ID":"20140909-115934.asdf-zxcv-qwe",` +
    34  		`"Checksum":"123af2cef",` +
    35  		`"ChecksumFormat":"SHA-1, base64 encoded",` +
    36  		`"Size":10,` +
    37  		`"Stored":"0001-01-01T00:00:00Z",` +
    38  		`"Started":"2014-09-09T11:59:34Z",` +
    39  		`"Finished":"2014-09-09T12:00:34Z",` +
    40  		`"Notes":"",` +
    41  		`"Environment":"asdf-zxcv-qwe",` +
    42  		`"Machine":"0",` +
    43  		`"Hostname":"myhost",` +
    44  		`"Version":"1.21-alpha3"` +
    45  		`}` + "\n"))
    46  	c.Assert(err, jc.ErrorIsNil)
    47  
    48  	archiveFile := s.newArchiveFile(c, meta)
    49  	compressed, err := ioutil.ReadAll(archiveFile)
    50  	c.Assert(err, jc.ErrorIsNil)
    51  	gzr, err := gzip.NewReader(bytes.NewBuffer(compressed))
    52  	c.Assert(err, jc.ErrorIsNil)
    53  	data, err := ioutil.ReadAll(gzr)
    54  	c.Assert(err, jc.ErrorIsNil)
    55  
    56  	s.archiveFile = bytes.NewBuffer(compressed)
    57  	s.data = data
    58  	s.meta = meta
    59  }
    60  
    61  func (s *archiveDataSuite) newArchiveFile(c *gc.C, meta *backups.Metadata) io.Reader {
    62  	files := []bt.File{
    63  		{
    64  			Name:    "var/lib/juju/tools/1.21-alpha2.1-trusty-amd64/jujud",
    65  			Content: "<some binary data goes here>",
    66  		},
    67  		{
    68  			Name:    "var/lib/juju/system-identity",
    69  			Content: "<an ssh key goes here>",
    70  		},
    71  	}
    72  	dump := []bt.File{
    73  		{
    74  			Name:  "juju",
    75  			IsDir: true,
    76  		},
    77  		{
    78  			Name:    "juju/machines.bson",
    79  			Content: "<BSON data goes here>",
    80  		},
    81  		{
    82  			Name:    "oplog.bson",
    83  			Content: "<BSON data goes here>",
    84  		},
    85  	}
    86  	archiveFile, err := bt.NewArchive(meta, files, dump)
    87  	c.Assert(err, jc.ErrorIsNil)
    88  	return archiveFile
    89  }
    90  
    91  func (s *archiveDataSuite) TestNewArchiveData(c *gc.C) {
    92  	ad := backups.NewArchiveData([]byte("<uncompressed>"))
    93  	data := ad.NewBuffer().String()
    94  
    95  	c.Check(ad.ContentDir, gc.Equals, "juju-backup")
    96  	c.Check(data, gc.Equals, "<uncompressed>")
    97  }
    98  
    99  func (s *archiveDataSuite) TestNewArchiveDataReader(c *gc.C) {
   100  	ad, err := backups.NewArchiveDataReader(s.archiveFile)
   101  	c.Assert(err, jc.ErrorIsNil)
   102  	data := ad.NewBuffer().Bytes()
   103  
   104  	c.Check(ad.ContentDir, gc.Equals, "juju-backup")
   105  	c.Check(data, jc.DeepEquals, s.data)
   106  }
   107  
   108  func (s *archiveDataSuite) TestNewBuffer(c *gc.C) {
   109  	ad, err := backups.NewArchiveDataReader(s.archiveFile)
   110  	c.Assert(err, jc.ErrorIsNil)
   111  	buf := ad.NewBuffer()
   112  
   113  	c.Check(buf.Bytes(), jc.DeepEquals, s.data)
   114  }
   115  
   116  func (s *archiveDataSuite) TestNewBufferMultiple(c *gc.C) {
   117  	ad, err := backups.NewArchiveDataReader(s.archiveFile)
   118  	c.Assert(err, jc.ErrorIsNil)
   119  
   120  	buf1 := ad.NewBuffer()
   121  	buf2 := ad.NewBuffer()
   122  
   123  	c.Check(buf2, gc.Not(gc.Equals), buf1)
   124  	c.Check(buf2.Bytes(), jc.DeepEquals, buf1.Bytes())
   125  }
   126  
   127  func (s *archiveDataSuite) TestMetadata(c *gc.C) {
   128  	ad, err := backups.NewArchiveDataReader(s.archiveFile)
   129  	c.Assert(err, jc.ErrorIsNil)
   130  
   131  	meta, err := ad.Metadata()
   132  	c.Assert(err, jc.ErrorIsNil)
   133  
   134  	c.Check(meta, jc.DeepEquals, s.meta)
   135  }
   136  
   137  func (s *archiveDataSuite) TestVersionFound(c *gc.C) {
   138  	ad, err := backups.NewArchiveDataReader(s.archiveFile)
   139  	c.Assert(err, jc.ErrorIsNil)
   140  
   141  	version, err := ad.Version()
   142  	c.Assert(err, jc.ErrorIsNil)
   143  
   144  	c.Check(version, jc.DeepEquals, &s.meta.Origin.Version)
   145  }
   146  
   147  func (s *archiveDataSuite) TestVersionNotFound(c *gc.C) {
   148  	archiveFile := s.newArchiveFile(c, nil)
   149  	ad, err := backups.NewArchiveDataReader(archiveFile)
   150  	c.Assert(err, jc.ErrorIsNil)
   151  
   152  	version, err := ad.Version()
   153  	c.Assert(err, jc.ErrorIsNil)
   154  
   155  	c.Check(version.String(), jc.DeepEquals, "1.20.0")
   156  }