github.com/instantlabs/godog@v0.7.14/builder_test.go (about) 1 package godog 2 3 import ( 4 "bytes" 5 "go/build" 6 "io/ioutil" 7 "os" 8 "os/exec" 9 "path/filepath" 10 "strings" 11 "testing" 12 ) 13 14 var builderFeatureFile = `Feature: eat godogs 15 In order to be happy 16 As a hungry gopher 17 I need to be able to eat godogs 18 19 Scenario: Eat 5 out of 12 20 Given there are 12 godogs 21 When I eat 5 22 Then there should be 7 remaining 23 ` 24 25 var builderTestFile = `package godogs 26 27 import ( 28 "fmt" 29 30 "github.com/instantlabs/godog" 31 ) 32 33 func thereAreGodogs(available int) error { 34 Godogs = available 35 return nil 36 } 37 38 func iEat(num int) error { 39 if Godogs < num { 40 return fmt.Errorf("you cannot eat %d godogs, there are %d available", num, Godogs) 41 } 42 Godogs -= num 43 return nil 44 } 45 46 func thereShouldBeRemaining(remaining int) error { 47 if Godogs != remaining { 48 return fmt.Errorf("expected %d godogs to be remaining, but there is %d", remaining, Godogs) 49 } 50 return nil 51 } 52 53 func FeatureContext(s *godog.Suite) { 54 s.Step("^there are (\\d+) godogs$", thereAreGodogs) 55 s.Step("^I eat (\\d+)$", iEat) 56 s.Step("^there should be (\\d+) remaining$", thereShouldBeRemaining) 57 58 s.BeforeScenario(func(interface{}) { 59 Godogs = 0 // clean the state before every scenario 60 }) 61 } 62 ` 63 64 var builderXTestFile = `package godogs_test 65 66 import ( 67 "fmt" 68 69 "github.com/instantlabs/godog" 70 "godogs" 71 ) 72 73 func thereAreGodogs(available int) error { 74 godogs.Godogs = available 75 return nil 76 } 77 78 func iEat(num int) error { 79 if godogs.Godogs < num { 80 return fmt.Errorf("you cannot eat %d godogs, there are %d available", num, godogs.Godogs) 81 } 82 godogs.Godogs -= num 83 return nil 84 } 85 86 func thereShouldBeRemaining(remaining int) error { 87 if godogs.Godogs != remaining { 88 return fmt.Errorf("expected %d godogs to be remaining, but there is %d", remaining, godogs.Godogs) 89 } 90 return nil 91 } 92 93 func FeatureContext(s *godog.Suite) { 94 s.Step("^there are (\\d+) godogs$", thereAreGodogs) 95 s.Step("^I eat (\\d+)$", iEat) 96 s.Step("^there should be (\\d+) remaining$", thereShouldBeRemaining) 97 98 s.BeforeScenario(func(interface{}) { 99 godogs.Godogs = 0 // clean the state before every scenario 100 }) 101 } 102 ` 103 104 var builderMainCodeFile = `package godogs 105 106 // Godogs available to eat 107 var Godogs int 108 109 func main() { 110 } 111 ` 112 113 var builderModFile = `module godogs` 114 115 func buildTestPackage(dir string, files map[string]string) error { 116 if err := os.MkdirAll(dir, 0755); err != nil { 117 return err 118 } 119 120 for name, content := range files { 121 if err := ioutil.WriteFile(filepath.Join(dir, name), []byte(content), 0644); err != nil { 122 return err 123 } 124 } 125 126 return nil 127 } 128 129 func buildTestCommand(t *testing.T, args ...string) *exec.Cmd { 130 bin, err := filepath.Abs("godog.test") 131 if err != nil { 132 t.Fatal(err) 133 } 134 if build.Default.GOOS == "windows" { 135 bin += ".exe" 136 } 137 if err = Build(bin); err != nil { 138 t.Fatal(err) 139 } 140 141 return exec.Command(bin, args...) 142 } 143 144 func envVarsWithoutGopath() []string { 145 var env []string 146 for _, def := range os.Environ() { 147 if strings.Index(def, "GOPATH=") == 0 { 148 continue 149 } 150 env = append(env, def) 151 } 152 return env 153 } 154 155 func TestGodogBuildWithSourceNotInGoPath(t *testing.T) { 156 dir := filepath.Join(os.TempDir(), "godogs") 157 err := buildTestPackage(dir, map[string]string{ 158 "godogs.feature": builderFeatureFile, 159 "godogs.go": builderMainCodeFile, 160 "godogs_test.go": builderTestFile, 161 "go.mod": builderModFile, 162 }) 163 if err != nil { 164 os.RemoveAll(dir) 165 t.Fatal(err) 166 } 167 defer os.RemoveAll(dir) 168 169 prevDir, err := os.Getwd() 170 if err != nil { 171 t.Fatal(err) 172 } 173 174 if err := os.Chdir(dir); err != nil { 175 t.Fatal(err) 176 } 177 defer os.Chdir(prevDir) 178 179 cmd := buildTestCommand(t, "godogs.feature") 180 181 var stdout, stderr bytes.Buffer 182 cmd.Stdout = &stdout 183 cmd.Stderr = &stderr 184 185 if err := cmd.Run(); err != nil { 186 t.Log(stdout.String()) 187 t.Log(stderr.String()) 188 t.Fatal(err) 189 } 190 } 191 192 func TestGodogBuildWithoutSourceNotInGoPath(t *testing.T) { 193 dir := filepath.Join(os.TempDir(), "godogs") 194 err := buildTestPackage(dir, map[string]string{ 195 "godogs.feature": builderFeatureFile, 196 "go.mod": builderModFile, 197 }) 198 if err != nil { 199 os.RemoveAll(dir) 200 t.Fatal(err) 201 } 202 defer os.RemoveAll(dir) 203 204 prevDir, err := os.Getwd() 205 if err != nil { 206 t.Fatal(err) 207 } 208 209 if err := os.Chdir(dir); err != nil { 210 t.Fatal(err) 211 } 212 defer os.Chdir(prevDir) 213 214 cmd := buildTestCommand(t, "godogs.feature") 215 216 var stdout, stderr bytes.Buffer 217 cmd.Stdout = &stdout 218 cmd.Stderr = &stderr 219 220 if err := cmd.Run(); err != nil { 221 t.Log(stdout.String()) 222 t.Log(stderr.String()) 223 t.Fatal(err) 224 } 225 } 226 227 func TestGodogBuildWithoutTestSourceNotInGoPath(t *testing.T) { 228 dir := filepath.Join(os.TempDir(), "godogs") 229 err := buildTestPackage(dir, map[string]string{ 230 "godogs.feature": builderFeatureFile, 231 "godogs.go": builderMainCodeFile, 232 "go.mod": builderModFile, 233 }) 234 if err != nil { 235 os.RemoveAll(dir) 236 t.Fatal(err) 237 } 238 defer os.RemoveAll(dir) 239 240 prevDir, err := os.Getwd() 241 if err != nil { 242 t.Fatal(err) 243 } 244 245 if err := os.Chdir(dir); err != nil { 246 t.Fatal(err) 247 } 248 defer os.Chdir(prevDir) 249 250 cmd := buildTestCommand(t, "godogs.feature") 251 252 var stdout, stderr bytes.Buffer 253 cmd.Stdout = &stdout 254 cmd.Stderr = &stderr 255 256 if err := cmd.Run(); err != nil { 257 t.Log(stdout.String()) 258 t.Log(stderr.String()) 259 t.Fatal(err) 260 } 261 } 262 263 func TestGodogBuildWithinGopath(t *testing.T) { 264 gopath := filepath.Join(os.TempDir(), "_gp") 265 dir := filepath.Join(gopath, "src", "godogs") 266 err := buildTestPackage(dir, map[string]string{ 267 "godogs.feature": builderFeatureFile, 268 "godogs.go": builderMainCodeFile, 269 "godogs_test.go": builderTestFile, 270 "go.mod": builderModFile, 271 }) 272 if err != nil { 273 os.RemoveAll(gopath) 274 t.Fatal(err) 275 } 276 defer os.RemoveAll(gopath) 277 278 pkg := filepath.Join(gopath, "src", "github.com", "instantlabs") 279 if err := os.MkdirAll(pkg, 0755); err != nil { 280 t.Fatal(err) 281 } 282 283 prevDir, err := os.Getwd() 284 if err != nil { 285 t.Fatal(err) 286 } 287 288 // symlink godog package 289 if err := os.Symlink(prevDir, filepath.Join(pkg, "godog")); err != nil { 290 t.Fatal(err) 291 } 292 293 if err := os.Chdir(dir); err != nil { 294 t.Fatal(err) 295 } 296 defer os.Chdir(prevDir) 297 298 cmd := buildTestCommand(t, "godogs.feature") 299 300 var stdout, stderr bytes.Buffer 301 cmd.Stdout = &stdout 302 cmd.Stderr = &stderr 303 cmd.Env = os.Environ() 304 cmd.Env = append(cmd.Env, "GOPATH="+gopath) 305 306 if err := cmd.Run(); err != nil { 307 t.Log(stdout.String()) 308 t.Log(stderr.String()) 309 t.Fatal(err) 310 } 311 } 312 313 func TestGodogBuildWithVendoredGodogAndMod(t *testing.T) { 314 gopath := filepath.Join(os.TempDir(), "_gpc") 315 dir := filepath.Join(gopath, "src", "godogs") 316 err := buildTestPackage(dir, map[string]string{ 317 "godogs.feature": builderFeatureFile, 318 "godogs.go": builderMainCodeFile, 319 "godogs_test.go": builderTestFile, 320 "go.mod": builderModFile, 321 }) 322 if err != nil { 323 os.RemoveAll(gopath) 324 t.Fatal(err) 325 } 326 defer os.RemoveAll(gopath) 327 328 pkg := filepath.Join(dir, "vendor", "github.com", "instantlabs") 329 if err := os.MkdirAll(pkg, 0755); err != nil { 330 t.Fatal(err) 331 } 332 333 prevDir, err := os.Getwd() 334 if err != nil { 335 t.Fatal(err) 336 } 337 338 // symlink godog package 339 if err := os.Symlink(prevDir, filepath.Join(pkg, "godog")); err != nil { 340 t.Fatal(err) 341 } 342 343 if err := os.Chdir(dir); err != nil { 344 t.Fatal(err) 345 } 346 defer os.Chdir(prevDir) 347 348 cmd := buildTestCommand(t, "godogs.feature") 349 350 var stdout, stderr bytes.Buffer 351 cmd.Stdout = &stdout 352 cmd.Stderr = &stderr 353 cmd.Env = append(envVarsWithoutGopath(), "GOPATH="+gopath) 354 355 if err := cmd.Run(); err != nil { 356 t.Log(stdout.String()) 357 t.Log(stderr.String()) 358 t.Fatal(err) 359 } 360 } 361 362 func TestGodogBuildWithVendoredGodogWithoutModule(t *testing.T) { 363 gopath := filepath.Join(os.TempDir(), "_gp") 364 dir := filepath.Join(gopath, "src", "godogs") 365 err := buildTestPackage(dir, map[string]string{ 366 "godogs.feature": builderFeatureFile, 367 }) 368 if err != nil { 369 os.RemoveAll(gopath) 370 t.Fatal(err) 371 } 372 defer os.RemoveAll(gopath) 373 374 pkg := filepath.Join(dir, "vendor", "github.com", "instantlabs") 375 if err := os.MkdirAll(pkg, 0755); err != nil { 376 t.Fatal(err) 377 } 378 379 prevDir, err := os.Getwd() 380 if err != nil { 381 t.Fatal(err) 382 } 383 384 // symlink godog package 385 if err := os.Symlink(prevDir, filepath.Join(pkg, "godog")); err != nil { 386 t.Fatal(err) 387 } 388 389 if err := os.Chdir(dir); err != nil { 390 t.Fatal(err) 391 } 392 defer os.Chdir(prevDir) 393 394 cmd := buildTestCommand(t, "godogs.feature") 395 396 var stdout, stderr bytes.Buffer 397 cmd.Stdout = &stdout 398 cmd.Stderr = &stderr 399 cmd.Env = append(envVarsWithoutGopath(), "GOPATH="+gopath) 400 401 if err := cmd.Run(); err != nil { 402 t.Log(stdout.String()) 403 t.Log(stderr.String()) 404 t.Fatal(err) 405 } 406 }