← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/gopkg.in/juju/charm.v6-unstable/resource/fingerprint_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/gopkg.in/juju/charm.v6-unstable/resource/fingerprint_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENCE file for details.
 
3
 
 
4
package resource_test
 
5
 
 
6
import (
 
7
        "crypto/sha512"
 
8
        "encoding/hex"
 
9
        "strings"
 
10
 
 
11
        "github.com/juju/errors"
 
12
        jc "github.com/juju/testing/checkers"
 
13
        gc "gopkg.in/check.v1"
 
14
 
 
15
        "gopkg.in/juju/charm.v6-unstable/resource"
 
16
)
 
17
 
 
18
func newFingerprint(c *gc.C, data string) ([]byte, string) {
 
19
        hash := sha512.New384()
 
20
        _, err := hash.Write([]byte(data))
 
21
        c.Assert(err, jc.ErrorIsNil)
 
22
        raw := hash.Sum(nil)
 
23
 
 
24
        hexStr := hex.EncodeToString(raw)
 
25
        return raw, hexStr
 
26
}
 
27
 
 
28
var _ = gc.Suite(&FingerprintSuite{})
 
29
 
 
30
type FingerprintSuite struct{}
 
31
 
 
32
func (s *FingerprintSuite) TestNewFingerprintOkay(c *gc.C) {
 
33
        expected, _ := newFingerprint(c, "spamspamspam")
 
34
 
 
35
        fp, err := resource.NewFingerprint(expected)
 
36
        c.Assert(err, jc.ErrorIsNil)
 
37
        raw := fp.Bytes()
 
38
 
 
39
        c.Check(raw, jc.DeepEquals, expected)
 
40
}
 
41
 
 
42
func (s *FingerprintSuite) TestNewFingerprintTooSmall(c *gc.C) {
 
43
        expected, _ := newFingerprint(c, "spamspamspam")
 
44
 
 
45
        _, err := resource.NewFingerprint(expected[:10])
 
46
 
 
47
        c.Check(err, jc.Satisfies, errors.IsNotValid)
 
48
        c.Check(err, gc.ErrorMatches, `.*too small.*`)
 
49
}
 
50
 
 
51
func (s *FingerprintSuite) TestNewFingerprintTooBig(c *gc.C) {
 
52
        expected, _ := newFingerprint(c, "spamspamspam")
 
53
 
 
54
        _, err := resource.NewFingerprint(append(expected, 1, 2, 3))
 
55
 
 
56
        c.Check(err, jc.Satisfies, errors.IsNotValid)
 
57
        c.Check(err, gc.ErrorMatches, `.*too big.*`)
 
58
}
 
59
 
 
60
func (s *FingerprintSuite) TestParseFingerprintOkay(c *gc.C) {
 
61
        _, expected := newFingerprint(c, "spamspamspam")
 
62
 
 
63
        fp, err := resource.ParseFingerprint(expected)
 
64
        c.Assert(err, jc.ErrorIsNil)
 
65
        hex := fp.String()
 
66
 
 
67
        c.Check(hex, jc.DeepEquals, expected)
 
68
}
 
69
 
 
70
func (s *FingerprintSuite) TestParseFingerprintNonHex(c *gc.C) {
 
71
        _, err := resource.ParseFingerprint("XYZ") // not hex
 
72
 
 
73
        c.Check(err, gc.ErrorMatches, `.*odd length hex string.*`)
 
74
}
 
75
 
 
76
func (s *FingerprintSuite) TestGenerateFingerprint(c *gc.C) {
 
77
        expected, _ := newFingerprint(c, "spamspamspam")
 
78
        data := strings.NewReader("spamspamspam")
 
79
 
 
80
        fp, err := resource.GenerateFingerprint(data)
 
81
        c.Assert(err, jc.ErrorIsNil)
 
82
        raw := fp.Bytes()
 
83
 
 
84
        c.Check(raw, jc.DeepEquals, expected)
 
85
}
 
86
 
 
87
func (s *FingerprintSuite) TestString(c *gc.C) {
 
88
        raw, expected := newFingerprint(c, "spamspamspam")
 
89
        fp, err := resource.NewFingerprint(raw)
 
90
        c.Assert(err, jc.ErrorIsNil)
 
91
 
 
92
        hex := fp.String()
 
93
 
 
94
        c.Check(hex, gc.Equals, expected)
 
95
}
 
96
 
 
97
func (s *FingerprintSuite) TestRoundtripString(c *gc.C) {
 
98
        _, expected := newFingerprint(c, "spamspamspam")
 
99
 
 
100
        fp, err := resource.ParseFingerprint(expected)
 
101
        c.Assert(err, jc.ErrorIsNil)
 
102
        hex := fp.String()
 
103
 
 
104
        c.Check(hex, gc.Equals, expected)
 
105
}
 
106
 
 
107
func (s *FingerprintSuite) TestBytes(c *gc.C) {
 
108
        expected, _ := newFingerprint(c, "spamspamspam")
 
109
        fp, err := resource.NewFingerprint(expected)
 
110
        c.Assert(err, jc.ErrorIsNil)
 
111
 
 
112
        raw := fp.Bytes()
 
113
 
 
114
        c.Check(raw, jc.DeepEquals, expected)
 
115
}
 
116
 
 
117
func (s *FingerprintSuite) TestRoundtripBytes(c *gc.C) {
 
118
        expected, _ := newFingerprint(c, "spamspamspam")
 
119
 
 
120
        fp, err := resource.NewFingerprint(expected)
 
121
        c.Assert(err, jc.ErrorIsNil)
 
122
        raw := fp.Bytes()
 
123
 
 
124
        c.Check(raw, jc.DeepEquals, expected)
 
125
}
 
126
 
 
127
func (s *FingerprintSuite) TestValidateOkay(c *gc.C) {
 
128
        raw, _ := newFingerprint(c, "spamspamspam")
 
129
        fp, err := resource.NewFingerprint(raw)
 
130
        c.Assert(err, jc.ErrorIsNil)
 
131
 
 
132
        err = fp.Validate()
 
133
 
 
134
        c.Check(err, jc.ErrorIsNil)
 
135
}
 
136
 
 
137
func (s *FingerprintSuite) TestValidateZero(c *gc.C) {
 
138
        var fp resource.Fingerprint
 
139
        err := fp.Validate()
 
140
 
 
141
        c.Check(err, jc.Satisfies, errors.IsNotValid)
 
142
        c.Check(err, gc.ErrorMatches, `zero-value fingerprint not valid`)
 
143
}