← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/resource/context/utils_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/resource/context/utils_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package context_test
 
5
 
 
6
import (
 
7
        "bytes"
 
8
        "io"
 
9
        "os"
 
10
        "strings"
 
11
 
 
12
        "github.com/juju/errors"
 
13
        "github.com/juju/testing"
 
14
        jc "github.com/juju/testing/checkers"
 
15
        "github.com/juju/testing/filetesting"
 
16
        gc "gopkg.in/check.v1"
 
17
        charmresource "gopkg.in/juju/charm.v6-unstable/resource"
 
18
 
 
19
        "github.com/juju/juju/resource/context"
 
20
)
 
21
 
 
22
var _ = gc.Suite(&UtilsSuite{})
 
23
 
 
24
type UtilsSuite struct {
 
25
        testing.IsolationSuite
 
26
 
 
27
        stub    *testing.Stub
 
28
        matcher *stubMatcher
 
29
}
 
30
 
 
31
func (s *UtilsSuite) SetUpTest(c *gc.C) {
 
32
        s.IsolationSuite.SetUpTest(c)
 
33
 
 
34
        s.stub = &testing.Stub{}
 
35
        s.matcher = &stubMatcher{stub: s.stub}
 
36
}
 
37
 
 
38
func (s *UtilsSuite) newReader(c *gc.C, content string) (io.ReadCloser, charmresource.Fingerprint) {
 
39
        r := filetesting.NewStubFile(s.stub, bytes.NewBufferString(content))
 
40
 
 
41
        tmpReader := strings.NewReader(content)
 
42
        fp, err := charmresource.GenerateFingerprint(tmpReader)
 
43
        c.Assert(err, jc.ErrorIsNil)
 
44
 
 
45
        return r, fp
 
46
}
 
47
 
 
48
func (s *UtilsSuite) TestFingerprintMatchesOkay(c *gc.C) {
 
49
        r, expected := s.newReader(c, "spam")
 
50
        s.matcher.ReturnOpen = r
 
51
        s.matcher.ReturnGenerateFingerprint = expected
 
52
        matcher := context.FingerprintMatcher{
 
53
                Open:                s.matcher.Open,
 
54
                GenerateFingerprint: s.matcher.GenerateFingerprint,
 
55
        }
 
56
 
 
57
        matches, err := matcher.FingerprintMatches("some/filename.txt", expected)
 
58
        c.Assert(err, jc.ErrorIsNil)
 
59
 
 
60
        c.Check(matches, jc.IsTrue)
 
61
}
 
62
 
 
63
func (s *UtilsSuite) TestFingerprintMatchesDepCalls(c *gc.C) {
 
64
        r, expected := s.newReader(c, "spam")
 
65
        s.matcher.ReturnOpen = r
 
66
        s.matcher.ReturnGenerateFingerprint = expected
 
67
        matcher := context.FingerprintMatcher{
 
68
                Open:                s.matcher.Open,
 
69
                GenerateFingerprint: s.matcher.GenerateFingerprint,
 
70
        }
 
71
 
 
72
        matches, err := matcher.FingerprintMatches("some/filename.txt", expected)
 
73
        c.Assert(matches, jc.IsTrue)
 
74
        c.Assert(err, jc.ErrorIsNil)
 
75
 
 
76
        s.stub.CheckCallNames(c, "Open", "GenerateFingerprint", "Close")
 
77
        s.stub.CheckCall(c, 0, "Open", "some/filename.txt")
 
78
        s.stub.CheckCall(c, 1, "GenerateFingerprint", r)
 
79
}
 
80
 
 
81
func (s *UtilsSuite) TestFingerprintMatchesNotFound(c *gc.C) {
 
82
        _, expected := s.newReader(c, "spam")
 
83
        matcher := context.FingerprintMatcher{
 
84
                Open: s.matcher.Open,
 
85
        }
 
86
        s.stub.SetErrors(os.ErrNotExist)
 
87
 
 
88
        matches, err := matcher.FingerprintMatches("some/filename.txt", expected)
 
89
        c.Assert(err, jc.ErrorIsNil)
 
90
 
 
91
        c.Check(matches, jc.IsFalse)
 
92
        s.stub.CheckCallNames(c, "Open")
 
93
}
 
94
 
 
95
func (s *UtilsSuite) TestFingerprintMatchesOpenFailed(c *gc.C) {
 
96
        _, expected := s.newReader(c, "spam")
 
97
        matcher := context.FingerprintMatcher{
 
98
                Open: s.matcher.Open,
 
99
        }
 
100
        failure := errors.New("<failed>")
 
101
        s.stub.SetErrors(failure)
 
102
 
 
103
        _, err := matcher.FingerprintMatches("some/filename.txt", expected)
 
104
 
 
105
        c.Check(errors.Cause(err), gc.Equals, failure)
 
106
        s.stub.CheckCallNames(c, "Open")
 
107
}
 
108
 
 
109
func (s *UtilsSuite) TestFingerprintMatchesGenerateFingerprintFailed(c *gc.C) {
 
110
        r, expected := s.newReader(c, "spam")
 
111
        s.matcher.ReturnOpen = r
 
112
        matcher := context.FingerprintMatcher{
 
113
                Open:                s.matcher.Open,
 
114
                GenerateFingerprint: s.matcher.GenerateFingerprint,
 
115
        }
 
116
        failure := errors.New("<failed>")
 
117
        s.stub.SetErrors(nil, failure)
 
118
 
 
119
        _, err := matcher.FingerprintMatches("some/filename.txt", expected)
 
120
 
 
121
        c.Check(errors.Cause(err), gc.Equals, failure)
 
122
        s.stub.CheckCallNames(c, "Open", "GenerateFingerprint", "Close")
 
123
}
 
124
 
 
125
type stubMatcher struct {
 
126
        stub *testing.Stub
 
127
 
 
128
        ReturnOpen                io.ReadCloser
 
129
        ReturnGenerateFingerprint charmresource.Fingerprint
 
130
}
 
131
 
 
132
func (s *stubMatcher) Open(filename string) (io.ReadCloser, error) {
 
133
        s.stub.AddCall("Open", filename)
 
134
        if err := s.stub.NextErr(); err != nil {
 
135
                return nil, errors.Trace(err)
 
136
        }
 
137
 
 
138
        return s.ReturnOpen, nil
 
139
}
 
140
 
 
141
func (s *stubMatcher) GenerateFingerprint(r io.Reader) (charmresource.Fingerprint, error) {
 
142
        s.stub.AddCall("GenerateFingerprint", r)
 
143
        if err := s.stub.NextErr(); err != nil {
 
144
                return charmresource.Fingerprint{}, errors.Trace(err)
 
145
        }
 
146
 
 
147
        return s.ReturnGenerateFingerprint, nil
 
148
}