← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/state/backups/metadata_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/state/backups/metadata_test.go
 
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
        "os"
 
9
        "path/filepath"
 
10
        "time"
 
11
 
 
12
        jc "github.com/juju/testing/checkers"
 
13
        "github.com/juju/version"
 
14
        gc "gopkg.in/check.v1"
 
15
 
 
16
        "github.com/juju/juju/state/backups"
 
17
        "github.com/juju/juju/testing"
 
18
)
 
19
 
 
20
type metadataSuite struct {
 
21
        testing.BaseSuite
 
22
}
 
23
 
 
24
var _ = gc.Suite(&metadataSuite{}) // Register the suite.
 
25
 
 
26
func (s *metadataSuite) TestAsJSONBuffer(c *gc.C) {
 
27
        meta := backups.NewMetadata()
 
28
        meta.Origin = backups.Origin{
 
29
                Model:    "asdf-zxcv-qwe",
 
30
                Machine:  "0",
 
31
                Hostname: "myhost",
 
32
                Version:  version.MustParse("1.21-alpha3"),
 
33
                Series:   "trusty",
 
34
        }
 
35
        meta.Started = time.Date(2014, time.Month(9), 9, 11, 59, 34, 0, time.UTC)
 
36
 
 
37
        meta.SetID("20140909-115934.asdf-zxcv-qwe")
 
38
        err := meta.MarkComplete(10, "123af2cef")
 
39
        c.Assert(err, jc.ErrorIsNil)
 
40
 
 
41
        finished := meta.Started.Add(time.Minute)
 
42
        meta.Finished = &finished
 
43
 
 
44
        meta.CACert = "ca-cert"
 
45
        meta.CAPrivateKey = "ca-private-key"
 
46
 
 
47
        buf, err := meta.AsJSONBuffer()
 
48
        c.Assert(err, jc.ErrorIsNil)
 
49
 
 
50
        c.Check(buf.(*bytes.Buffer).String(), gc.Equals, `{`+
 
51
                `"ID":"20140909-115934.asdf-zxcv-qwe",`+
 
52
                `"Checksum":"123af2cef",`+
 
53
                `"ChecksumFormat":"SHA-1, base64 encoded",`+
 
54
                `"Size":10,`+
 
55
                `"Stored":"0001-01-01T00:00:00Z",`+
 
56
                `"Started":"2014-09-09T11:59:34Z",`+
 
57
                `"Finished":"2014-09-09T12:00:34Z",`+
 
58
                `"Notes":"",`+
 
59
                `"Environment":"asdf-zxcv-qwe",`+
 
60
                `"Machine":"0",`+
 
61
                `"Hostname":"myhost",`+
 
62
                `"Version":"1.21-alpha3",`+
 
63
                `"Series":"trusty",`+
 
64
                `"CACert":"ca-cert",`+
 
65
                `"CAPrivateKey":"ca-private-key"`+
 
66
                `}`+"\n")
 
67
}
 
68
 
 
69
func (s *metadataSuite) TestNewMetadataJSONReader(c *gc.C) {
 
70
        file := bytes.NewBufferString(`{` +
 
71
                `"ID":"20140909-115934.asdf-zxcv-qwe",` +
 
72
                `"Checksum":"123af2cef",` +
 
73
                `"ChecksumFormat":"SHA-1, base64 encoded",` +
 
74
                `"Size":10,` +
 
75
                `"Stored":"0001-01-01T00:00:00Z",` +
 
76
                `"Started":"2014-09-09T11:59:34Z",` +
 
77
                `"Finished":"2014-09-09T12:00:34Z",` +
 
78
                `"Notes":"",` +
 
79
                `"Environment":"asdf-zxcv-qwe",` +
 
80
                `"Machine":"0",` +
 
81
                `"Hostname":"myhost",` +
 
82
                `"Version":"1.21-alpha3"` +
 
83
                `}` + "\n")
 
84
        meta, err := backups.NewMetadataJSONReader(file)
 
85
        c.Assert(err, jc.ErrorIsNil)
 
86
 
 
87
        c.Check(meta.ID(), gc.Equals, "20140909-115934.asdf-zxcv-qwe")
 
88
        c.Check(meta.Checksum(), gc.Equals, "123af2cef")
 
89
        c.Check(meta.ChecksumFormat(), gc.Equals, "SHA-1, base64 encoded")
 
90
        c.Check(meta.Size(), gc.Equals, int64(10))
 
91
        c.Check(meta.Stored(), gc.IsNil)
 
92
        c.Check(meta.Started.Unix(), gc.Equals, int64(1410263974))
 
93
        c.Check(meta.Finished.Unix(), gc.Equals, int64(1410264034))
 
94
        c.Check(meta.Notes, gc.Equals, "")
 
95
        c.Check(meta.Origin.Model, gc.Equals, "asdf-zxcv-qwe")
 
96
        c.Check(meta.Origin.Machine, gc.Equals, "0")
 
97
        c.Check(meta.Origin.Hostname, gc.Equals, "myhost")
 
98
        c.Check(meta.Origin.Version.String(), gc.Equals, "1.21-alpha3")
 
99
}
 
100
 
 
101
func (s *metadataSuite) TestBuildMetadata(c *gc.C) {
 
102
        archive, err := os.Create(filepath.Join(c.MkDir(), "juju-backup.tgz"))
 
103
        c.Assert(err, jc.ErrorIsNil)
 
104
        _, err = archive.Write([]byte("<compressed data>"))
 
105
        c.Assert(err, jc.ErrorIsNil)
 
106
 
 
107
        fi, err := archive.Stat()
 
108
        c.Assert(err, jc.ErrorIsNil)
 
109
        finished := backups.FileTimestamp(fi).Unix()
 
110
 
 
111
        meta, err := backups.BuildMetadata(archive)
 
112
        c.Assert(err, jc.ErrorIsNil)
 
113
 
 
114
        c.Check(meta.ID(), gc.Equals, "")
 
115
        c.Check(meta.Checksum(), gc.Equals, "2jmj7l5rSw0yVb/vlWAYkK/YBwk=")
 
116
        c.Check(meta.ChecksumFormat(), gc.Equals, "SHA-1, base64 encoded")
 
117
        c.Check(meta.Size(), gc.Equals, int64(17))
 
118
        c.Check(meta.Stored(), gc.IsNil)
 
119
        c.Check(meta.Started.Unix(), gc.Equals, int64(time.Time{}.Unix()))
 
120
        c.Check(meta.Finished.Unix(), gc.Equals, finished)
 
121
        c.Check(meta.Notes, gc.Equals, "")
 
122
        c.Check(meta.Origin.Model, gc.Equals, backups.UnknownString)
 
123
        c.Check(meta.Origin.Machine, gc.Equals, backups.UnknownString)
 
124
        c.Check(meta.Origin.Hostname, gc.Equals, backups.UnknownString)
 
125
        c.Check(meta.Origin.Version.String(), gc.Equals, backups.UnknownVersion.String())
 
126
}