forked from hashicorp/otto
/
mock.go
93 lines (76 loc) · 1.77 KB
/
mock.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package app
import (
"github.com/hashicorp/otto/appfile"
)
// Mock is a mock implementation of the App interface.
type Mock struct {
CloseCalled bool
MetaCalled bool
MetaResult *Meta
MetaErr error
ImplicitCalled bool
ImplicitContext *Context
ImplicitResult *appfile.File
ImplicitErr error
CompileCalled bool
CompileContext *Context
CompileResult *CompileResult
CompileErr error
CompileFunc func(ctx *Context) (*CompileResult, error)
BuildCalled bool
BuildContext *Context
BuildErr error
DeployCalled bool
DeployContext *Context
DeployErr error
DevCalled bool
DevContext *Context
DevErr error
DevDepCalled bool
DevDepContextDst *Context
DevDepContextSrc *Context
DevDepResult *DevDep
DevDepErr error
}
func (m *Mock) Meta() (*Meta, error) {
m.MetaCalled = true
return m.MetaResult, m.MetaErr
}
func (m *Mock) Close() error {
m.CloseCalled = true
return nil
}
func (m *Mock) Implicit(ctx *Context) (*appfile.File, error) {
m.ImplicitCalled = true
m.ImplicitContext = ctx
return m.ImplicitResult, m.ImplicitErr
}
func (m *Mock) Compile(ctx *Context) (*CompileResult, error) {
m.CompileCalled = true
m.CompileContext = ctx
if m.CompileFunc != nil {
return m.CompileFunc(ctx)
}
return m.CompileResult, m.CompileErr
}
func (m *Mock) Build(ctx *Context) error {
m.BuildCalled = true
m.BuildContext = ctx
return m.BuildErr
}
func (m *Mock) Deploy(ctx *Context) error {
m.DeployCalled = true
m.DeployContext = ctx
return m.DeployErr
}
func (m *Mock) Dev(ctx *Context) error {
m.DevCalled = true
m.DevContext = ctx
return m.DevErr
}
func (m *Mock) DevDep(dst, src *Context) (*DevDep, error) {
m.DevDepCalled = true
m.DevDepContextDst = dst
m.DevDepContextSrc = src
return m.DevDepResult, m.DevDepErr
}