FilesExpand file tree

master

/

mocks_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

211 lines (177 loc) · 6.48 KB

master

/

mocks_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

211 lines (177 loc) · 6.48 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

// Code generated by MockGen. DO NOT EDIT.

// Source: finalize.go

// Package finalize_test is a generated GoMock package.

package finalize_test

import (

gomock "github.com/golang/mock/gomock"

io "io"

reflect "reflect"

)

// MockManifest is a mock of Manifest interface

type MockManifest struct {

ctrl *gomock.Controller

recorder *MockManifestMockRecorder

}

// MockManifestMockRecorder is the mock recorder for MockManifest

type MockManifestMockRecorder struct {

mock *MockManifest

}

// NewMockManifest creates a new mock instance

func NewMockManifest(ctrl *gomock.Controller) *MockManifest {

mock := &MockManifest{ctrl: ctrl}

mock.recorder = &MockManifestMockRecorder{mock}

return mock

}

// EXPECT returns an object that allows the caller to indicate expected use

func (m *MockManifest) EXPECT() *MockManifestMockRecorder {

return m.recorder

}

// RootDir mocks base method

func (m *MockManifest) RootDir() string {

ret := m.ctrl.Call(m, "RootDir")

ret0, _ := ret[0].(string)

return ret0

}

// RootDir indicates an expected call of RootDir

func (mr *MockManifestMockRecorder) RootDir() *gomock.Call {

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RootDir", reflect.TypeOf((*MockManifest)(nil).RootDir))

}

// MockStager is a mock of Stager interface

type MockStager struct {

ctrl *gomock.Controller

recorder *MockStagerMockRecorder

}

// MockStagerMockRecorder is the mock recorder for MockStager

type MockStagerMockRecorder struct {

mock *MockStager

}

// NewMockStager creates a new mock instance

func NewMockStager(ctrl *gomock.Controller) *MockStager {

mock := &MockStager{ctrl: ctrl}

mock.recorder = &MockStagerMockRecorder{mock}

return mock

}

// EXPECT returns an object that allows the caller to indicate expected use

func (m *MockStager) EXPECT() *MockStagerMockRecorder {

return m.recorder

}

// BuildDir mocks base method

func (m *MockStager) BuildDir() string {

ret := m.ctrl.Call(m, "BuildDir")

ret0, _ := ret[0].(string)

return ret0

}

// BuildDir indicates an expected call of BuildDir

func (mr *MockStagerMockRecorder) BuildDir() *gomock.Call {

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildDir", reflect.TypeOf((*MockStager)(nil).BuildDir))

}

// DepDir mocks base method

func (m *MockStager) DepDir() string {

ret := m.ctrl.Call(m, "DepDir")

ret0, _ := ret[0].(string)

return ret0

}

// DepDir indicates an expected call of DepDir

func (mr *MockStagerMockRecorder) DepDir() *gomock.Call {

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DepDir", reflect.TypeOf((*MockStager)(nil).DepDir))

}

// DepsIdx mocks base method

func (m *MockStager) DepsIdx() string {

ret := m.ctrl.Call(m, "DepsIdx")

ret0, _ := ret[0].(string)

return ret0

}

// DepsIdx indicates an expected call of DepsIdx

func (mr *MockStagerMockRecorder) DepsIdx() *gomock.Call {

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DepsIdx", reflect.TypeOf((*MockStager)(nil).DepsIdx))

}

// WriteProfileD mocks base method

func (m *MockStager) WriteProfileD(arg0, arg1 string) error {

ret := m.ctrl.Call(m, "WriteProfileD", arg0, arg1)

ret0, _ := ret[0].(error)

return ret0

}

// WriteProfileD indicates an expected call of WriteProfileD

func (mr *MockStagerMockRecorder) WriteProfileD(arg0, arg1 interface{}) *gomock.Call {

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteProfileD", reflect.TypeOf((*MockStager)(nil).WriteProfileD), arg0, arg1)

}

// MockCommand is a mock of Command interface

type MockCommand struct {

ctrl *gomock.Controller

recorder *MockCommandMockRecorder

}

// MockCommandMockRecorder is the mock recorder for MockCommand

type MockCommandMockRecorder struct {

mock *MockCommand

}

// NewMockCommand creates a new mock instance

func NewMockCommand(ctrl *gomock.Controller) *MockCommand {

mock := &MockCommand{ctrl: ctrl}

mock.recorder = &MockCommandMockRecorder{mock}

return mock

}

// EXPECT returns an object that allows the caller to indicate expected use

func (m *MockCommand) EXPECT() *MockCommandMockRecorder {

return m.recorder

}

// Execute mocks base method

func (m *MockCommand) Execute(arg0 string, arg1, arg2 io.Writer, arg3 string, arg4 ...string) error {

varargs := []interface{}{arg0, arg1, arg2, arg3}

for _, a := range arg4 {

varargs = append(varargs, a)

}

ret := m.ctrl.Call(m, "Execute", varargs...)

ret0, _ := ret[0].(error)

return ret0

}

// Execute indicates an expected call of Execute

func (mr *MockCommandMockRecorder) Execute(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {

varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockCommand)(nil).Execute), varargs...)

}

// Output mocks base method

func (m *MockCommand) Output(dir, program string, args ...string) (string, error) {

varargs := []interface{}{dir, program}

for _, a := range args {

varargs = append(varargs, a)

}

ret := m.ctrl.Call(m, "Output", varargs...)

ret0, _ := ret[0].(string)

ret1, _ := ret[1].(error)

return ret0, ret1

}

// Output indicates an expected call of Output

func (mr *MockCommandMockRecorder) Output(dir, program interface{}, args ...interface{}) *gomock.Call {

varargs := append([]interface{}{dir, program}, args...)

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Output", reflect.TypeOf((*MockCommand)(nil).Output), varargs...)

}

// MockManagePyFinder is a mock of ManagePyFinder interface

type MockManagePyFinder struct {

ctrl *gomock.Controller

recorder *MockManagePyFinderMockRecorder

}

// MockManagePyFinderMockRecorder is the mock recorder for MockManagePyFinder

type MockManagePyFinderMockRecorder struct {

mock *MockManagePyFinder

}

// NewMockManagePyFinder creates a new mock instance

func NewMockManagePyFinder(ctrl *gomock.Controller) *MockManagePyFinder {

mock := &MockManagePyFinder{ctrl: ctrl}

mock.recorder = &MockManagePyFinderMockRecorder{mock}

return mock

}

// EXPECT returns an object that allows the caller to indicate expected use

func (m *MockManagePyFinder) EXPECT() *MockManagePyFinderMockRecorder {

return m.recorder

}

// FindManagePy mocks base method

func (m *MockManagePyFinder) FindManagePy(dir string) (string, error) {

ret := m.ctrl.Call(m, "FindManagePy", dir)

ret0, _ := ret[0].(string)

ret1, _ := ret[1].(error)

return ret0, ret1

}

// FindManagePy indicates an expected call of FindManagePy

func (mr *MockManagePyFinderMockRecorder) FindManagePy(dir interface{}) *gomock.Call {

return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindManagePy", reflect.TypeOf((*MockManagePyFinder)(nil).FindManagePy), dir)

}