← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/payload/api/private/helpers_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/payload/api/private/helpers_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package private_test
 
5
 
 
6
import (
 
7
        "github.com/juju/errors"
 
8
        "github.com/juju/testing"
 
9
        jc "github.com/juju/testing/checkers"
 
10
        gc "gopkg.in/check.v1"
 
11
        "gopkg.in/juju/charm.v6-unstable"
 
12
        "gopkg.in/juju/names.v2"
 
13
 
 
14
        "github.com/juju/juju/apiserver/common"
 
15
        "github.com/juju/juju/apiserver/params"
 
16
        "github.com/juju/juju/payload"
 
17
        "github.com/juju/juju/payload/api"
 
18
        "github.com/juju/juju/payload/api/private"
 
19
)
 
20
 
 
21
type internalHelpersSuite struct {
 
22
        testing.IsolationSuite
 
23
}
 
24
 
 
25
var _ = gc.Suite(&internalHelpersSuite{})
 
26
 
 
27
func (internalHelpersSuite) TestNewPayloadResultOkay(c *gc.C) {
 
28
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
29
        result := private.NewPayloadResult(id, nil)
 
30
 
 
31
        c.Check(result, jc.DeepEquals, private.PayloadResult{
 
32
                Entity: params.Entity{
 
33
                        Tag: names.NewPayloadTag(id).String(),
 
34
                },
 
35
                Payload:  nil,
 
36
                NotFound: false,
 
37
                Error:    nil,
 
38
        })
 
39
}
 
40
 
 
41
func (internalHelpersSuite) TestNewPayloadResultError(c *gc.C) {
 
42
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
43
        err := errors.New("<failure>")
 
44
        result := private.NewPayloadResult(id, err)
 
45
 
 
46
        c.Check(result, jc.DeepEquals, private.PayloadResult{
 
47
                Entity: params.Entity{
 
48
                        Tag: names.NewPayloadTag(id).String(),
 
49
                },
 
50
                Payload:  nil,
 
51
                NotFound: false,
 
52
                Error:    common.ServerError(err),
 
53
        })
 
54
}
 
55
 
 
56
func (internalHelpersSuite) TestNewPayloadResultNotFound(c *gc.C) {
 
57
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
58
        err := errors.NotFoundf("payload %q", id)
 
59
        result := private.NewPayloadResult(id, err)
 
60
 
 
61
        c.Check(result, jc.DeepEquals, private.PayloadResult{
 
62
                Entity: params.Entity{
 
63
                        Tag: names.NewPayloadTag(id).String(),
 
64
                },
 
65
                Payload:  nil,
 
66
                NotFound: true,
 
67
                Error:    common.ServerError(err),
 
68
        })
 
69
}
 
70
 
 
71
func (internalHelpersSuite) TestAPI2ResultOkay(c *gc.C) {
 
72
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
73
        result, err := private.API2Result(private.PayloadResult{
 
74
                Entity: params.Entity{
 
75
                        Tag: names.NewPayloadTag(id).String(),
 
76
                },
 
77
                Payload:  nil,
 
78
                NotFound: false,
 
79
                Error:    nil,
 
80
        })
 
81
        c.Assert(err, jc.ErrorIsNil)
 
82
 
 
83
        c.Check(result, jc.DeepEquals, payload.Result{
 
84
                ID:       id,
 
85
                Payload:  nil,
 
86
                NotFound: false,
 
87
                Error:    nil,
 
88
        })
 
89
}
 
90
 
 
91
func (internalHelpersSuite) TestAPI2ResultInfo(c *gc.C) {
 
92
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
93
        result, err := private.API2Result(private.PayloadResult{
 
94
                Entity: params.Entity{
 
95
                        Tag: names.NewPayloadTag(id).String(),
 
96
                },
 
97
                NotFound: false,
 
98
                Error:    nil,
 
99
                Payload: &api.Payload{
 
100
                        Class:   "foobar",
 
101
                        Type:    "type",
 
102
                        ID:      "idfoo",
 
103
                        Status:  payload.StateRunning,
 
104
                        Unit:    "unit-a-application-0",
 
105
                        Machine: "machine-1",
 
106
                },
 
107
        })
 
108
        c.Assert(err, jc.ErrorIsNil)
 
109
 
 
110
        c.Check(result, jc.DeepEquals, payload.Result{
 
111
                ID:       id,
 
112
                NotFound: false,
 
113
                Error:    nil,
 
114
                Payload: &payload.FullPayloadInfo{
 
115
                        Payload: payload.Payload{
 
116
                                PayloadClass: charm.PayloadClass{
 
117
                                        Name: "foobar",
 
118
                                        Type: "type",
 
119
                                },
 
120
                                ID:     "idfoo",
 
121
                                Status: payload.StateRunning,
 
122
                                Unit:   "a-application/0",
 
123
                        },
 
124
                        Machine: "1",
 
125
                },
 
126
        })
 
127
}
 
128
 
 
129
func (internalHelpersSuite) TestAPI2ResultError(c *gc.C) {
 
130
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
131
        failure := errors.New("<failure>")
 
132
        result, err := private.API2Result(private.PayloadResult{
 
133
                Entity: params.Entity{
 
134
                        Tag: names.NewPayloadTag(id).String(),
 
135
                },
 
136
                Payload:  nil,
 
137
                NotFound: false,
 
138
                Error:    common.ServerError(failure),
 
139
        })
 
140
        c.Assert(err, jc.ErrorIsNil)
 
141
 
 
142
        c.Check(result.Error.Error(), gc.Equals, failure.Error())
 
143
        c.Check(result, jc.DeepEquals, payload.Result{
 
144
                ID:       id,
 
145
                Payload:  nil,
 
146
                NotFound: false,
 
147
                Error:    result.Error, // The actual error is checked above.
 
148
        })
 
149
}
 
150
 
 
151
func (internalHelpersSuite) TestAPI2ResultNotFound(c *gc.C) {
 
152
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
153
        notFound := errors.NotFoundf("payload %q", id)
 
154
        result, err := private.API2Result(private.PayloadResult{
 
155
                Entity: params.Entity{
 
156
                        Tag: names.NewPayloadTag(id).String(),
 
157
                },
 
158
                Payload:  nil,
 
159
                NotFound: false,
 
160
                Error:    common.ServerError(notFound),
 
161
        })
 
162
        c.Assert(err, jc.ErrorIsNil)
 
163
 
 
164
        c.Check(result.Error.Error(), gc.Equals, notFound.Error())
 
165
        c.Check(result.Error, jc.Satisfies, errors.IsNotFound)
 
166
        c.Check(result, jc.DeepEquals, payload.Result{
 
167
                ID:       id,
 
168
                Payload:  nil,
 
169
                NotFound: false,
 
170
                Error:    result.Error, // The actual error is checked above.
 
171
        })
 
172
}
 
173
 
 
174
func (internalHelpersSuite) TestResult2apiOkay(c *gc.C) {
 
175
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
176
        result := private.Result2api(payload.Result{
 
177
                ID:       id,
 
178
                Payload:  nil,
 
179
                NotFound: false,
 
180
                Error:    nil,
 
181
        })
 
182
 
 
183
        c.Check(result, jc.DeepEquals, private.PayloadResult{
 
184
                Entity: params.Entity{
 
185
                        Tag: names.NewPayloadTag(id).String(),
 
186
                },
 
187
                Payload:  nil,
 
188
                NotFound: false,
 
189
                Error:    nil,
 
190
        })
 
191
}
 
192
 
 
193
func (internalHelpersSuite) TestResult2apiInfo(c *gc.C) {
 
194
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
195
        result := private.Result2api(payload.Result{
 
196
                ID:       id,
 
197
                NotFound: false,
 
198
                Error:    nil,
 
199
                Payload: &payload.FullPayloadInfo{
 
200
                        Payload: payload.Payload{
 
201
                                PayloadClass: charm.PayloadClass{
 
202
                                        Name: "foobar",
 
203
                                        Type: "type",
 
204
                                },
 
205
                                ID:     "idfoo",
 
206
                                Status: payload.StateRunning,
 
207
                                Unit:   "a-application/0",
 
208
                        },
 
209
                        Machine: "1",
 
210
                },
 
211
        })
 
212
 
 
213
        c.Check(result, jc.DeepEquals, private.PayloadResult{
 
214
                Entity: params.Entity{
 
215
                        Tag: names.NewPayloadTag(id).String(),
 
216
                },
 
217
                NotFound: false,
 
218
                Error:    nil,
 
219
                Payload: &api.Payload{
 
220
                        Class:   "foobar",
 
221
                        Type:    "type",
 
222
                        ID:      "idfoo",
 
223
                        Status:  payload.StateRunning,
 
224
                        Unit:    "unit-a-application-0",
 
225
                        Machine: "machine-1",
 
226
                },
 
227
        })
 
228
}
 
229
 
 
230
func (internalHelpersSuite) TestResult2apiError(c *gc.C) {
 
231
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
232
        err := errors.New("<failure>")
 
233
        result := private.Result2api(payload.Result{
 
234
                ID:       id,
 
235
                Payload:  nil,
 
236
                NotFound: false,
 
237
                Error:    err,
 
238
        })
 
239
 
 
240
        c.Check(result, jc.DeepEquals, private.PayloadResult{
 
241
                Entity: params.Entity{
 
242
                        Tag: names.NewPayloadTag(id).String(),
 
243
                },
 
244
                Payload:  nil,
 
245
                NotFound: false,
 
246
                Error:    common.ServerError(err),
 
247
        })
 
248
}
 
249
 
 
250
func (internalHelpersSuite) TestResult2apiNotFound(c *gc.C) {
 
251
        id := "ce5bc2a7-65d8-4800-8199-a7c3356ab309"
 
252
        err := errors.NotFoundf("payload %q", id)
 
253
        result := private.Result2api(payload.Result{
 
254
                ID:       id,
 
255
                Payload:  nil,
 
256
                NotFound: false,
 
257
                Error:    err,
 
258
        })
 
259
 
 
260
        c.Check(result, jc.DeepEquals, private.PayloadResult{
 
261
                Entity: params.Entity{
 
262
                        Tag: names.NewPayloadTag(id).String(),
 
263
                },
 
264
                Payload:  nil,
 
265
                NotFound: false,
 
266
                Error:    common.ServerError(err),
 
267
        })
 
268
}