github.com/PentoHQ/moq@v0.0.0-20190507125140-c45c141f300b/pkg/moq/moq_test.go (about) 1 package moq 2 3 import ( 4 "bytes" 5 "io" 6 "os" 7 "os/exec" 8 "strings" 9 "testing" 10 ) 11 12 func TestMoq(t *testing.T) { 13 m, err := New("testpackages/example", "") 14 if err != nil { 15 t.Fatalf("moq.New: %s", err) 16 } 17 var buf bytes.Buffer 18 err = m.Mock(&buf, "PersonStore") 19 if err != nil { 20 t.Errorf("m.Mock: %s", err) 21 } 22 s := buf.String() 23 // assertions of things that should be mentioned 24 var strs = []string{ 25 "package example", 26 "type PersonStoreMock struct", 27 "CreateFunc func(ctx context.Context, person *Person, confirm bool) error", 28 "GetFunc func(ctx context.Context, id string) (*Person, error)", 29 "func (mock *PersonStoreMock) Create(ctx context.Context, person *Person, confirm bool) error", 30 "func (mock *PersonStoreMock) Get(ctx context.Context, id string) (*Person, error)", 31 "panic(\"PersonStoreMock.CreateFunc: method is nil but PersonStore.Create was just called\")", 32 "panic(\"PersonStoreMock.GetFunc: method is nil but PersonStore.Get was just called\")", 33 "lockPersonStoreMockGet.Lock()", 34 "mock.calls.Get = append(mock.calls.Get, callInfo)", 35 "lockPersonStoreMockGet.Unlock()", 36 "// ID is the id argument value", 37 } 38 for _, str := range strs { 39 if !strings.Contains(s, str) { 40 t.Errorf("expected but missing: \"%s\"", str) 41 } 42 } 43 } 44 45 func TestMoqWithStaticCheck(t *testing.T) { 46 m, err := New("testpackages/example", "") 47 if err != nil { 48 t.Fatalf("moq.New: %s", err) 49 } 50 var buf bytes.Buffer 51 err = m.Mock(&buf, "PersonStore") 52 if err != nil { 53 t.Errorf("m.Mock: %s", err) 54 } 55 s := buf.String() 56 // assertions of things that should be mentioned 57 var strs = []string{ 58 "package example", 59 "var _ PersonStore = &PersonStoreMock{}", 60 "type PersonStoreMock struct", 61 "CreateFunc func(ctx context.Context, person *Person, confirm bool) error", 62 "GetFunc func(ctx context.Context, id string) (*Person, error)", 63 "func (mock *PersonStoreMock) Create(ctx context.Context, person *Person, confirm bool) error", 64 "func (mock *PersonStoreMock) Get(ctx context.Context, id string) (*Person, error)", 65 "panic(\"PersonStoreMock.CreateFunc: method is nil but PersonStore.Create was just called\")", 66 "panic(\"PersonStoreMock.GetFunc: method is nil but PersonStore.Get was just called\")", 67 "lockPersonStoreMockGet.Lock()", 68 "mock.calls.Get = append(mock.calls.Get, callInfo)", 69 "lockPersonStoreMockGet.Unlock()", 70 "// ID is the id argument value", 71 } 72 for _, str := range strs { 73 if !strings.Contains(s, str) { 74 t.Errorf("expected but missing: \"%s\"", str) 75 } 76 } 77 } 78 79 func TestMoqExplicitPackage(t *testing.T) { 80 m, err := New("testpackages/example", "different") 81 if err != nil { 82 t.Fatalf("moq.New: %s", err) 83 } 84 var buf bytes.Buffer 85 err = m.Mock(&buf, "PersonStore") 86 if err != nil { 87 t.Errorf("m.Mock: %s", err) 88 } 89 s := buf.String() 90 // assertions of things that should be mentioned 91 var strs = []string{ 92 "package different", 93 "type PersonStoreMock struct", 94 "CreateFunc func(ctx context.Context, person *example.Person, confirm bool) error", 95 "GetFunc func(ctx context.Context, id string) (*example.Person, error)", 96 "func (mock *PersonStoreMock) Create(ctx context.Context, person *example.Person, confirm bool) error", 97 "func (mock *PersonStoreMock) Get(ctx context.Context, id string) (*example.Person, error)", 98 } 99 for _, str := range strs { 100 if !strings.Contains(s, str) { 101 t.Errorf("expected but missing: \"%s\"", str) 102 } 103 } 104 } 105 106 func TestMoqExplicitPackageWithStaticCheck(t *testing.T) { 107 m, err := New("testpackages/example", "different") 108 if err != nil { 109 t.Fatalf("moq.New: %s", err) 110 } 111 var buf bytes.Buffer 112 err = m.Mock(&buf, "PersonStore") 113 if err != nil { 114 t.Errorf("m.Mock: %s", err) 115 } 116 s := buf.String() 117 // assertions of things that should be mentioned 118 var strs = []string{ 119 "package different", 120 "var _ example.PersonStore = &PersonStoreMock{}", 121 "type PersonStoreMock struct", 122 "CreateFunc func(ctx context.Context, person *example.Person, confirm bool) error", 123 "GetFunc func(ctx context.Context, id string) (*example.Person, error)", 124 "func (mock *PersonStoreMock) Create(ctx context.Context, person *example.Person, confirm bool) error", 125 "func (mock *PersonStoreMock) Get(ctx context.Context, id string) (*example.Person, error)", 126 } 127 for _, str := range strs { 128 if !strings.Contains(s, str) { 129 t.Errorf("expected but missing: \"%s\"", str) 130 } 131 } 132 } 133 134 // TestVeradicArguments tests to ensure variadic work as 135 // expected. 136 // see https://github.com/matryer/moq/issues/5 137 func TestVariadicArguments(t *testing.T) { 138 m, err := New("testpackages/variadic", "") 139 if err != nil { 140 t.Fatalf("moq.New: %s", err) 141 } 142 var buf bytes.Buffer 143 err = m.Mock(&buf, "Greeter") 144 if err != nil { 145 t.Errorf("m.Mock: %s", err) 146 } 147 s := buf.String() 148 // assertions of things that should be mentioned 149 var strs = []string{ 150 "package variadic", 151 "type GreeterMock struct", 152 "GreetFunc func(ctx context.Context, names ...string) string", 153 "return mock.GreetFunc(ctx, names...)", 154 } 155 for _, str := range strs { 156 if !strings.Contains(s, str) { 157 t.Errorf("expected but missing: \"%s\"", str) 158 } 159 } 160 } 161 162 func TestNothingToReturn(t *testing.T) { 163 m, err := New("testpackages/example", "") 164 if err != nil { 165 t.Fatalf("moq.New: %s", err) 166 } 167 var buf bytes.Buffer 168 err = m.Mock(&buf, "PersonStore") 169 if err != nil { 170 t.Errorf("m.Mock: %s", err) 171 } 172 s := buf.String() 173 if strings.Contains(s, `return mock.ClearCacheFunc(id)`) { 174 t.Errorf("should not have return for items that have no return arguments") 175 } 176 // assertions of things that should be mentioned 177 var strs = []string{ 178 "mock.ClearCacheFunc(id)", 179 } 180 for _, str := range strs { 181 if !strings.Contains(s, str) { 182 t.Errorf("expected but missing: \"%s\"", str) 183 } 184 } 185 } 186 187 func TestChannelNames(t *testing.T) { 188 m, err := New("testpackages/channels", "") 189 if err != nil { 190 t.Fatalf("moq.New: %s", err) 191 } 192 var buf bytes.Buffer 193 err = m.Mock(&buf, "Queuer") 194 if err != nil { 195 t.Errorf("m.Mock: %s", err) 196 } 197 s := buf.String() 198 var strs = []string{ 199 "func (mock *QueuerMock) Sub(topic string) (<-chan Queue, error)", 200 } 201 for _, str := range strs { 202 if !strings.Contains(s, str) { 203 t.Errorf("expected but missing: \"%s\"", str) 204 } 205 } 206 } 207 208 func TestImports(t *testing.T) { 209 m, err := New("testpackages/imports/two", "") 210 if err != nil { 211 t.Fatalf("moq.New: %s", err) 212 } 213 var buf bytes.Buffer 214 err = m.Mock(&buf, "DoSomething") 215 if err != nil { 216 t.Errorf("m.Mock: %s", err) 217 } 218 s := buf.String() 219 var strs = []string{ 220 ` "sync"`, 221 ` "github.com/matryer/moq/pkg/moq/testpackages/imports/one"`, 222 } 223 for _, str := range strs { 224 if !strings.Contains(s, str) { 225 t.Errorf("expected but missing: \"%s\"", str) 226 } 227 if len(strings.Split(s, str)) > 2 { 228 t.Errorf("more than one: \"%s\"", str) 229 } 230 } 231 } 232 233 func TestTemplateFuncs(t *testing.T) { 234 fn := templateFuncs["Exported"].(func(string) string) 235 if fn("var") != "Var" { 236 t.Errorf("exported didn't work: %s", fn("var")) 237 } 238 } 239 240 func TestVendoredPackages(t *testing.T) { 241 m, err := New("testpackages/vendoring/user", "") 242 if err != nil { 243 t.Fatalf("moq.New: %s", err) 244 } 245 var buf bytes.Buffer 246 err = m.Mock(&buf, "Service") 247 if err != nil { 248 t.Errorf("mock error: %s", err) 249 } 250 s := buf.String() 251 // assertions of things that should be mentioned 252 var strs = []string{ 253 `"github.com/matryer/somerepo"`, 254 } 255 for _, str := range strs { 256 if !strings.Contains(s, str) { 257 t.Errorf("expected but missing: \"%s\"", str) 258 } 259 } 260 } 261 262 func TestVendoredBuildConstraints(t *testing.T) { 263 m, err := New("testpackages/buildconstraints/user", "") 264 if err != nil { 265 t.Fatalf("moq.New: %s", err) 266 } 267 var buf bytes.Buffer 268 err = m.Mock(&buf, "Service") 269 if err != nil { 270 t.Errorf("mock error: %s", err) 271 } 272 s := buf.String() 273 // assertions of things that should be mentioned 274 var strs = []string{ 275 `"github.com/matryer/buildconstraints"`, 276 } 277 for _, str := range strs { 278 if !strings.Contains(s, str) { 279 t.Errorf("expected but missing: \"%s\"", str) 280 } 281 } 282 } 283 284 // TestDotImports tests for https://github.com/matryer/moq/issues/21. 285 func TestDotImports(t *testing.T) { 286 preDir, err := os.Getwd() 287 if err != nil { 288 t.Errorf("Getwd: %s", err) 289 } 290 err = os.Chdir("testpackages/dotimport") 291 if err != nil { 292 t.Errorf("Chdir: %s", err) 293 } 294 defer func() { 295 err := os.Chdir(preDir) 296 if err != nil { 297 t.Errorf("Chdir back: %s", err) 298 } 299 }() 300 m, err := New(".", "moqtest_test") 301 if err != nil { 302 t.Fatalf("moq.New: %s", err) 303 } 304 var buf bytes.Buffer 305 err = m.Mock(&buf, "Service") 306 if err != nil { 307 t.Errorf("mock error: %s", err) 308 } 309 s := buf.String() 310 if strings.Contains(s, `"."`) { 311 t.Error("contains invalid dot import") 312 } 313 } 314 315 func TestEmptyInterface(t *testing.T) { 316 m, err := New("testpackages/emptyinterface", "") 317 if err != nil { 318 t.Fatalf("moq.New: %s", err) 319 } 320 var buf bytes.Buffer 321 err = m.Mock(&buf, "Empty") 322 if err != nil { 323 t.Errorf("mock error: %s", err) 324 } 325 s := buf.String() 326 if strings.Contains(s, `"sync"`) { 327 t.Error("contains sync import, although this package isn't used") 328 } 329 } 330 331 func TestGoGenerateVendoredPackages(t *testing.T) { 332 cmd := exec.Command("go", "generate", "./...") 333 cmd.Dir = "testpackages/gogenvendoring" 334 stdout, err := cmd.StdoutPipe() 335 if err != nil { 336 t.Errorf("StdoutPipe: %s", err) 337 } 338 defer stdout.Close() 339 err = cmd.Start() 340 if err != nil { 341 t.Errorf("Start: %s", err) 342 } 343 buf := bytes.NewBuffer(nil) 344 io.Copy(buf, stdout) 345 err = cmd.Wait() 346 if err != nil { 347 if exitErr, ok := err.(*exec.ExitError); ok { 348 t.Errorf("Wait: %s %s", exitErr, string(exitErr.Stderr)) 349 } else { 350 t.Errorf("Wait: %s", err) 351 } 352 } 353 s := buf.String() 354 if strings.Contains(s, `vendor/`) { 355 t.Error("contains vendor directory in import path") 356 } 357 } 358 359 func TestImportedPackageWithSameName(t *testing.T) { 360 m, err := New("testpackages/samenameimport", "") 361 if err != nil { 362 t.Fatalf("moq.New: %s", err) 363 } 364 var buf bytes.Buffer 365 err = m.Mock(&buf, "Example") 366 if err != nil { 367 t.Errorf("mock error: %s", err) 368 } 369 s := buf.String() 370 if !strings.Contains(s, `a samename.A`) { 371 t.Error("missing samename.A to address the struct A from the external package samename") 372 } 373 }