gitee.com/mirrors/gauge@v1.0.6/parser/lex_test.go (about) 1 package parser 2 3 import ( 4 "github.com/getgauge/gauge/env" 5 "github.com/getgauge/gauge/gauge" 6 . "gopkg.in/check.v1" 7 ) 8 9 func (s *MySuite) TestParsingSpecHeading(c *C) { 10 parser := new(SpecParser) 11 12 specText := newSpecBuilder().specHeading("Spec Heading").String() 13 tokens, err := parser.GenerateTokens(specText, "") 14 15 c.Assert(err, IsNil) 16 c.Assert(len(tokens), Equals, 1) 17 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 18 c.Assert(tokens[0].Value, Equals, "Spec Heading") 19 } 20 21 func (s *MySuite) TestParsingASingleStep(c *C) { 22 parser := new(SpecParser) 23 tokens, err := parser.GenerateTokens("* test step \"arg\" ", "") 24 25 c.Assert(err, IsNil) 26 c.Assert(len(tokens), Equals, 1) 27 c.Assert(tokens[0].Kind, Equals, gauge.StepKind) 28 } 29 30 func (s *MySuite) TestParsingMultipleSpecHeading(c *C) { 31 parser := new(SpecParser) 32 specText := newSpecBuilder().specHeading("Spec Heading").specHeading("Another Spec Heading").String() 33 34 tokens, err := parser.GenerateTokens(specText, "") 35 36 c.Assert(err, IsNil) 37 c.Assert(len(tokens), Equals, 2) 38 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 39 c.Assert(tokens[0].Value, Equals, "Spec Heading") 40 c.Assert(tokens[1].Kind, Equals, gauge.SpecKind) 41 c.Assert(tokens[1].Value, Equals, "Another Spec Heading") 42 } 43 44 func (s *MySuite) TestParsingThrowErrorForEmptySpecHeading(c *C) { 45 parser := new(SpecParser) 46 specText := newSpecBuilder().specHeading("").text("dsfdsf").String() 47 48 _, res, err := parser.Parse(specText, gauge.NewConceptDictionary(), "foo.spec") 49 c.Assert(err, IsNil) 50 c.Assert(len(res.ParseErrors) > 0, Equals, true) 51 c.Assert(res.ParseErrors[0].Error(), Equals, "foo.spec:1 Spec heading should have at least one character => ''") 52 } 53 54 func (s *MySuite) TestParsingScenarioHeading(c *C) { 55 parser := new(SpecParser) 56 specText := newSpecBuilder().specHeading("Spec Heading").scenarioHeading("First scenario").String() 57 58 tokens, err := parser.GenerateTokens(specText, "") 59 60 c.Assert(err, IsNil) 61 c.Assert(len(tokens), Equals, 2) 62 c.Assert(tokens[1].Kind, Equals, gauge.ScenarioKind) 63 c.Assert(tokens[1].Value, Equals, "First scenario") 64 } 65 66 func (s *MySuite) TestParsingThrowErrorForEmptyScenarioHeading(c *C) { 67 parser := new(SpecParser) 68 specText := newSpecBuilder().specHeading("Spec Heading").scenarioHeading("").String() 69 70 _, errs := parser.GenerateTokens(specText, "foo.spec") 71 72 c.Assert(len(errs) > 0, Equals, true) 73 c.Assert(errs[0].Error(), Equals, "foo.spec:2 Scenario heading should have at least one character => ''") 74 } 75 76 func (s *MySuite) TestParsingScenarioWithoutSpecHeading(c *C) { 77 parser := new(SpecParser) 78 specText := newSpecBuilder().scenarioHeading("Scenario Heading").String() 79 80 tokens, err := parser.GenerateTokens(specText, "") 81 82 c.Assert(err, IsNil) 83 c.Assert(len(tokens), Equals, 1) 84 c.Assert(tokens[0].Kind, Equals, gauge.ScenarioKind) 85 } 86 87 func (s *MySuite) TestParsingComments(c *C) { 88 parser := new(SpecParser) 89 specText := newSpecBuilder().specHeading("Spec Heading").text("Hello i am a comment ").text("### A h3 comment").String() 90 91 tokens, err := parser.GenerateTokens(specText, "") 92 93 c.Assert(err, IsNil) 94 c.Assert(len(tokens), Equals, 3) 95 96 c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) 97 c.Assert(tokens[1].Value, Equals, "Hello i am a comment") 98 99 c.Assert(tokens[2].Kind, Equals, gauge.CommentKind) 100 c.Assert(tokens[2].Value, Equals, "### A h3 comment") 101 } 102 103 func (s *MySuite) TestParsingSpecHeadingWithUnderlineOneChar(c *C) { 104 parser := new(SpecParser) 105 specText := newSpecBuilder().text("Spec heading with underline ").text("=").String() 106 107 tokens, err := parser.GenerateTokens(specText, "") 108 109 c.Assert(err, IsNil) 110 c.Assert(len(tokens), Equals, 1) 111 112 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 113 c.Assert(tokens[0].Value, Equals, "Spec heading with underline") 114 115 } 116 117 func (s *MySuite) TestParsingSpecHeadingWithUnderlineMultipleChar(c *C) { 118 parser := new(SpecParser) 119 specText := newSpecBuilder().text("Spec heading with underline ").text("=====").String() 120 121 tokens, err := parser.GenerateTokens(specText, "") 122 123 c.Assert(err, IsNil) 124 c.Assert(len(tokens), Equals, 1) 125 126 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 127 c.Assert(tokens[0].Value, Equals, "Spec heading with underline") 128 129 } 130 131 func (s *MySuite) TestParsingCommentWithUnderlineAndInvalidCharacters(c *C) { 132 parser := new(SpecParser) 133 specText := newSpecBuilder().text("A comment that will be with invalid underline").text("===89s").String() 134 135 tokens, err := parser.GenerateTokens(specText, "") 136 137 c.Assert(err, IsNil) 138 c.Assert(len(tokens), Equals, 2) 139 140 c.Assert(tokens[0].Kind, Equals, gauge.CommentKind) 141 c.Assert(tokens[0].Value, Equals, "A comment that will be with invalid underline") 142 143 c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) 144 c.Assert(tokens[1].Value, Equals, "===89s") 145 } 146 147 func (s *MySuite) TestParsingScenarioHeadingWithUnderline(c *C) { 148 parser := new(SpecParser) 149 specText := newSpecBuilder().text("Spec heading with underline ").text("=").text("Scenario heading with underline").text("-").String() 150 151 tokens, err := parser.GenerateTokens(specText, "") 152 153 c.Assert(err, IsNil) 154 c.Assert(len(tokens), Equals, 2) 155 156 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 157 c.Assert(tokens[0].Value, Equals, "Spec heading with underline") 158 159 c.Assert(tokens[1].Kind, Equals, gauge.ScenarioKind) 160 c.Assert(tokens[1].Value, Equals, "Scenario heading with underline") 161 162 } 163 164 func (s *MySuite) TestParsingScenarioHeadingWithUnderlineMultipleChar(c *C) { 165 parser := new(SpecParser) 166 specText := newSpecBuilder().text("Spec heading with underline ").text("=").text("Scenario heading with underline").text("----").String() 167 168 tokens, err := parser.GenerateTokens(specText, "") 169 170 c.Assert(err, IsNil) 171 c.Assert(len(tokens), Equals, 2) 172 173 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 174 c.Assert(tokens[0].Value, Equals, "Spec heading with underline") 175 176 c.Assert(tokens[1].Kind, Equals, gauge.ScenarioKind) 177 c.Assert(tokens[1].Value, Equals, "Scenario heading with underline") 178 179 } 180 181 func (s *MySuite) TestParsingHeadingWithUnderlineAndHash(c *C) { 182 parser := new(SpecParser) 183 specText := newSpecBuilder().specHeading("Spec heading with hash ").text("=====").scenarioHeading("Scenario heading with hash").text("----").String() 184 185 tokens, err := parser.GenerateTokens(specText, "") 186 187 c.Assert(err, IsNil) 188 c.Assert(len(tokens), Equals, 4) 189 190 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 191 c.Assert(tokens[0].Value, Equals, "Spec heading with hash") 192 193 c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) 194 c.Assert(tokens[1].Value, Equals, "=====") 195 196 c.Assert(tokens[2].Kind, Equals, gauge.ScenarioKind) 197 c.Assert(tokens[2].Value, Equals, "Scenario heading with hash") 198 199 c.Assert(tokens[3].Kind, Equals, gauge.CommentKind) 200 c.Assert(tokens[3].Value, Equals, "----") 201 202 } 203 204 func (s *MySuite) TestParseSpecTags(c *C) { 205 parser := new(SpecParser) 206 specText := newSpecBuilder().specHeading("Spec heading with hash ").tags("tag1", "tag2").scenarioHeading("Scenario Heading").String() 207 208 tokens, err := parser.GenerateTokens(specText, "") 209 210 c.Assert(err, IsNil) 211 c.Assert(len(tokens), Equals, 3) 212 213 c.Assert(tokens[1].Kind, Equals, gauge.TagKind) 214 c.Assert(len(tokens[1].Args), Equals, 2) 215 c.Assert(tokens[1].Args[0], Equals, "tag1") 216 c.Assert(tokens[1].Args[1], Equals, "tag2") 217 c.Assert(tokens[1].LineText, Equals, "tags: tag1,tag2") 218 c.Assert(tokens[1].Value, Equals, "tag1,tag2") 219 } 220 221 func (s *MySuite) TestParseSpecTagsWithSpace(c *C) { 222 parser := new(SpecParser) 223 specText := newSpecBuilder().specHeading("Spec heading with hash ").text(" tags :tag1,tag2").scenarioHeading("Scenario Heading").String() 224 225 tokens, err := parser.GenerateTokens(specText, "") 226 227 c.Assert(err, IsNil) 228 c.Assert(len(tokens), Equals, 3) 229 230 c.Assert(tokens[1].Kind, Equals, gauge.TagKind) 231 c.Assert(len(tokens[1].Args), Equals, 2) 232 c.Assert(tokens[1].Args[0], Equals, "tag1") 233 c.Assert(tokens[1].Args[1], Equals, "tag2") 234 c.Assert(tokens[1].LineText, Equals, " tags :tag1,tag2") 235 c.Assert(tokens[1].Value, Equals, "tag1,tag2") 236 } 237 238 func (s *MySuite) TestParseEmptyTags(c *C) { 239 parser := new(SpecParser) 240 specText := newSpecBuilder().specHeading("Spec heading with hash ").tags("tag1", "", "tag2", "").scenarioHeading("Scenario Heading").String() 241 tokens, err := parser.GenerateTokens(specText, "") 242 243 c.Assert(err, IsNil) 244 c.Assert(len(tokens), Equals, 3) 245 246 c.Assert(tokens[1].Kind, Equals, gauge.TagKind) 247 c.Assert(len(tokens[1].Args), Equals, 2) 248 c.Assert(tokens[1].Args[0], Equals, "tag1") 249 c.Assert(tokens[1].Args[1], Equals, "tag2") 250 c.Assert(tokens[1].LineText, Equals, "tags: tag1,,tag2,") 251 c.Assert(tokens[1].Value, Equals, "tag1,,tag2,") 252 } 253 254 func (s *MySuite) TestParseScenarioTags(c *C) { 255 parser := new(SpecParser) 256 specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").tags("tag1", "tag2").String() 257 258 tokens, err := parser.GenerateTokens(specText, "") 259 260 c.Assert(err, IsNil) 261 c.Assert(len(tokens), Equals, 3) 262 263 c.Assert(tokens[2].Kind, Equals, gauge.TagKind) 264 c.Assert(len(tokens[2].Args), Equals, 2) 265 c.Assert(tokens[2].Args[0], Equals, "tag1") 266 c.Assert(tokens[2].Args[1], Equals, "tag2") 267 c.Assert(tokens[2].LineText, Equals, "tags: tag1,tag2") 268 c.Assert(tokens[2].Value, Equals, "tag1,tag2") 269 } 270 271 func (s *MySuite) TestParseScenarioWithTagsInMultipleLines(c *C) { 272 parser := new(SpecParser) 273 specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").tags("tag1", "\ntag2").String() 274 275 tokens, err := parser.GenerateTokens(specText, "") 276 277 c.Assert(err, IsNil) 278 c.Assert(len(tokens), Equals, 4) 279 280 c.Assert(tokens[2].Kind, Equals, gauge.TagKind) 281 c.Assert(len(tokens[2].Args), Equals, 1) 282 c.Assert(tokens[2].Args[0], Equals, "tag1") 283 c.Assert(tokens[2].LineText, Equals, "tags: tag1,") 284 c.Assert(tokens[2].Value, Equals, "tag1,") 285 c.Assert(tokens[3].Args[0], Equals, "tag2") 286 c.Assert(tokens[3].LineText, Equals, "tag2") 287 c.Assert(tokens[3].Value, Equals, "tag2") 288 } 289 290 func (s *MySuite) TestParseSpecTagsBeforeSpecHeading(c *C) { 291 parser := new(SpecParser) 292 specText := newSpecBuilder().tags("tag1 ").specHeading("Spec heading with hash ").String() 293 294 tokens, err := parser.GenerateTokens(specText, "") 295 296 c.Assert(err, IsNil) 297 c.Assert(len(tokens), Equals, 2) 298 299 c.Assert(tokens[0].Kind, Equals, gauge.TagKind) 300 c.Assert(len(tokens[0].Args), Equals, 1) 301 c.Assert(tokens[0].Args[0], Equals, "tag1") 302 c.Assert(tokens[0].LineText, Equals, "tags: tag1 ") 303 c.Assert(tokens[0].Value, Equals, "tag1") 304 } 305 306 func (s *MySuite) TestParsingSimpleDataTable(c *C) { 307 parser := new(SpecParser) 308 specText := newSpecBuilder().specHeading("Spec heading").text("|name|id|").text("|---|---|").text("|john|123|").text("|james|007|").String() 309 310 tokens, err := parser.GenerateTokens(specText, "") 311 c.Assert(err, IsNil) 312 c.Assert(len(tokens), Equals, 5) 313 314 c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) 315 c.Assert(len(tokens[1].Args), Equals, 2) 316 c.Assert(tokens[1].Args[0], Equals, "name") 317 c.Assert(tokens[1].Args[1], Equals, "id") 318 319 c.Assert(tokens[2].Kind, Equals, gauge.TableRow) 320 c.Assert(len(tokens[2].Args), Equals, 2) 321 c.Assert(tokens[2].Args[0], Equals, "---") 322 c.Assert(tokens[2].Args[1], Equals, "---") 323 324 c.Assert(tokens[3].Kind, Equals, gauge.TableRow) 325 c.Assert(len(tokens[3].Args), Equals, 2) 326 c.Assert(tokens[3].Args[0], Equals, "john") 327 c.Assert(tokens[3].Args[1], Equals, "123") 328 329 c.Assert(tokens[4].Kind, Equals, gauge.TableRow) 330 c.Assert(len(tokens[4].Args), Equals, 2) 331 c.Assert(tokens[4].Args[0], Equals, "james") 332 c.Assert(tokens[4].Args[1], Equals, "007") 333 334 } 335 func (s *MySuite) TestParsingMultipleDataTable(c *C) { 336 parser := new(SpecParser) 337 specText := newSpecBuilder().specHeading("Spec heading").text("|name|id|").text("|john|123|").text("|james|007|").step("Example step").text("|user|role|").text("|root | admin|").String() 338 339 tokens, err := parser.GenerateTokens(specText, "") 340 c.Assert(err, IsNil) 341 c.Assert(len(tokens), Equals, 7) 342 343 c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) 344 c.Assert(len(tokens[1].Args), Equals, 2) 345 c.Assert(tokens[1].Args[0], Equals, "name") 346 c.Assert(tokens[1].Args[1], Equals, "id") 347 348 c.Assert(tokens[2].Kind, Equals, gauge.TableRow) 349 c.Assert(len(tokens[2].Args), Equals, 2) 350 c.Assert(tokens[2].Args[0], Equals, "john") 351 c.Assert(tokens[2].Args[1], Equals, "123") 352 353 c.Assert(tokens[3].Kind, Equals, gauge.TableRow) 354 c.Assert(len(tokens[3].Args), Equals, 2) 355 c.Assert(tokens[3].Args[0], Equals, "james") 356 c.Assert(tokens[3].Args[1], Equals, "007") 357 358 c.Assert(tokens[5].Kind, Equals, gauge.TableHeader) 359 c.Assert(len(tokens[5].Args), Equals, 2) 360 c.Assert(tokens[5].Args[0], Equals, "user") 361 c.Assert(tokens[5].Args[1], Equals, "role") 362 363 c.Assert(tokens[6].Kind, Equals, gauge.TableRow) 364 c.Assert(len(tokens[6].Args), Equals, 2) 365 c.Assert(tokens[6].Args[0], Equals, "root") 366 c.Assert(tokens[6].Args[1], Equals, "admin") 367 } 368 369 func (s *MySuite) TestParsingDataTableWithEmptyHeaderSeparatorRow(c *C) { 370 parser := new(SpecParser) 371 specText := newSpecBuilder().specHeading("Spec heading").text("|name|id|").text("|||").text("|john|123|").String() 372 373 tokens, err := parser.GenerateTokens(specText, "") 374 c.Assert(err, IsNil) 375 c.Assert(len(tokens), Equals, 4) 376 377 c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) 378 c.Assert(len(tokens[1].Args), Equals, 2) 379 c.Assert(tokens[1].Args[0], Equals, "name") 380 c.Assert(tokens[1].Args[1], Equals, "id") 381 382 c.Assert(tokens[2].Kind, Equals, gauge.TableRow) 383 c.Assert(len(tokens[2].Args), Equals, 2) 384 c.Assert(tokens[2].Args[0], Equals, "") 385 c.Assert(tokens[2].Args[1], Equals, "") 386 387 c.Assert(tokens[3].Kind, Equals, gauge.TableRow) 388 c.Assert(len(tokens[3].Args), Equals, 2) 389 c.Assert(tokens[3].Args[0], Equals, "john") 390 c.Assert(tokens[3].Args[1], Equals, "123") 391 392 } 393 394 func (s *MySuite) TestParsingDataTableRowEscapingPipe(c *C) { 395 parser := new(SpecParser) 396 specText := newSpecBuilder().specHeading("Spec heading").text("| name|id | address| phone|").text("| escape \\| pipe |second|third|").String() 397 398 tokens, err := parser.GenerateTokens(specText, "") 399 c.Assert(err, IsNil) 400 c.Assert(len(tokens), Equals, 3) 401 402 c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) 403 c.Assert(len(tokens[1].Args), Equals, 4) 404 c.Assert(tokens[1].Args[0], Equals, "name") 405 c.Assert(tokens[1].Args[1], Equals, "id") 406 c.Assert(tokens[1].Args[2], Equals, "address") 407 c.Assert(tokens[1].Args[3], Equals, "phone") 408 409 c.Assert(tokens[2].Kind, Equals, gauge.TableRow) 410 c.Assert(len(tokens[2].Args), Equals, 3) 411 c.Assert(tokens[2].Args[0], Equals, "escape | pipe") 412 c.Assert(tokens[2].Args[1], Equals, "second") 413 c.Assert(tokens[2].Args[2], Equals, "third") 414 415 } 416 417 func (s *MySuite) TestParsingDataTableThrowsErrorWithEmptyHeader(c *C) { 418 parser := new(SpecParser) 419 specText := newSpecBuilder().specHeading("Spec heading").text("| name|id |||").text("| escape \\| pipe |second|third|second|").String() 420 421 _, errs := parser.GenerateTokens(specText, "foo.spec") 422 c.Assert(len(errs) > 0, Equals, true) 423 c.Assert(errs[0].Error(), Equals, "foo.spec:2 Table header should not be blank => '| name|id |||'") 424 } 425 426 func (s *MySuite) TestParsingDataTableThrowsErrorWithSameColumnHeader(c *C) { 427 parser := new(SpecParser) 428 specText := newSpecBuilder().specHeading("Spec heading").text("| name|id|name|").text("|1|2|3|").String() 429 430 _, errs := parser.GenerateTokens(specText, "foo.spec") 431 c.Assert(len(errs) > 0, Equals, true) 432 c.Assert(errs[0].Error(), Equals, "foo.spec:2 Table header cannot have repeated column values => '| name|id|name|'") 433 } 434 435 func (s *MySuite) TestParsingDataTableWithSeparatorAsHeader(c *C) { 436 parser := new(SpecParser) 437 specText := newSpecBuilder().specHeading("Spec heading").text("|---|--|-|").text("|---|--|-|").text("|---|--|-|").text("| escape \\| pipe |second|third|").String() 438 439 tokens, err := parser.GenerateTokens(specText, "") 440 c.Assert(err, IsNil) 441 c.Assert(len(tokens), Equals, 5) 442 443 c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) 444 c.Assert(len(tokens[1].Args), Equals, 3) 445 c.Assert(tokens[1].Args[0], Equals, "---") 446 c.Assert(tokens[1].Args[1], Equals, "--") 447 c.Assert(tokens[1].Args[2], Equals, "-") 448 449 c.Assert(tokens[2].Kind, Equals, gauge.TableRow) 450 c.Assert(len(tokens[2].Args), Equals, 3) 451 c.Assert(tokens[2].Args[0], Equals, "---") 452 c.Assert(tokens[2].Args[1], Equals, "--") 453 c.Assert(tokens[2].Args[2], Equals, "-") 454 455 } 456 457 func (s *MySuite) TestParsingSpecWithMultipleLines(c *C) { 458 parser := new(SpecParser) 459 specText := newSpecBuilder().specHeading("A spec heading"). 460 text("Hello, i am a comment"). 461 text(" "). 462 step("Context step with \"param\" and <file:foo>"). 463 text("|a|b|c|"). 464 text("|--||"). 465 text("|a1|a2|a3|"). 466 tags("one", "two"). 467 scenarioHeading("First flow"). 468 tags("tag1", "tag2"). 469 step("first with \"fpp\" and <bar>"). 470 text(""). 471 text("Comment in scenario"). 472 step("<table:file.csv> and <another> with \"foo\""). 473 scenarioHeading("First flow"). 474 step("another").String() 475 476 tokens, err := parser.GenerateTokens(specText, "") 477 c.Assert(err, IsNil) 478 c.Assert(len(tokens), Equals, 15) 479 480 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 481 c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) 482 c.Assert(tokens[2].Kind, Equals, gauge.CommentKind) 483 484 c.Assert(tokens[3].Kind, Equals, gauge.StepKind) 485 c.Assert(tokens[3].Value, Equals, "Context step with {static} and {special}") 486 487 c.Assert(tokens[4].Kind, Equals, gauge.TableHeader) 488 c.Assert(tokens[5].Kind, Equals, gauge.TableRow) 489 c.Assert(tokens[6].Kind, Equals, gauge.TableRow) 490 c.Assert(tokens[7].Kind, Equals, gauge.TagKind) 491 c.Assert(tokens[8].Kind, Equals, gauge.ScenarioKind) 492 c.Assert(tokens[9].Kind, Equals, gauge.TagKind) 493 494 c.Assert(tokens[10].Kind, Equals, gauge.StepKind) 495 c.Assert(tokens[10].Value, Equals, "first with {static} and {dynamic}") 496 497 c.Assert(tokens[11].Kind, Equals, gauge.CommentKind) 498 499 c.Assert(tokens[12].Kind, Equals, gauge.StepKind) 500 c.Assert(tokens[12].Value, Equals, "{special} and {dynamic} with {static}") 501 502 c.Assert(tokens[13].Kind, Equals, gauge.ScenarioKind) 503 504 c.Assert(tokens[14].Kind, Equals, gauge.StepKind) 505 c.Assert(tokens[14].Value, Equals, "another") 506 507 } 508 509 func (s *MySuite) TestParsingSimpleScenarioDataTable(c *C) { 510 parser := new(SpecParser) 511 specText := newSpecBuilder().specHeading("Spec heading"). 512 scenarioHeading("Scenario Heading"). 513 text("|name|id|"). 514 text("|---|---|"). 515 text("|john|123|"). 516 text("|james|007|").String() 517 518 tokens, err := parser.GenerateTokens(specText, "") 519 c.Assert(err, IsNil) 520 c.Assert(len(tokens), Equals, 6) 521 522 c.Assert(tokens[2].Kind, Equals, gauge.TableHeader) 523 c.Assert(len(tokens[2].Args), Equals, 2) 524 c.Assert(tokens[2].Args[0], Equals, "name") 525 c.Assert(tokens[2].Args[1], Equals, "id") 526 527 c.Assert(tokens[3].Kind, Equals, gauge.TableRow) 528 c.Assert(len(tokens[3].Args), Equals, 2) 529 c.Assert(tokens[3].Args[0], Equals, "---") 530 c.Assert(tokens[3].Args[1], Equals, "---") 531 532 c.Assert(tokens[4].Kind, Equals, gauge.TableRow) 533 c.Assert(len(tokens[4].Args), Equals, 2) 534 c.Assert(tokens[4].Args[0], Equals, "john") 535 c.Assert(tokens[4].Args[1], Equals, "123") 536 537 c.Assert(tokens[5].Kind, Equals, gauge.TableRow) 538 c.Assert(len(tokens[5].Args), Equals, 2) 539 c.Assert(tokens[5].Args[0], Equals, "james") 540 c.Assert(tokens[5].Args[1], Equals, "007") 541 542 } 543 544 func (s *MySuite) TestParsingStepWIthNewlineAndTableParam(c *C) { 545 parser := new(SpecParser) 546 specText := newSpecBuilder(). 547 step("step1"). 548 text(""). 549 tableHeader("foo|bar"). 550 tableRow("somerow|another").String() 551 552 tokens, err := parser.GenerateTokens(specText, "") 553 c.Assert(err, IsNil) 554 c.Assert(len(tokens), Equals, 3) 555 556 c.Assert(tokens[0].Kind, Equals, gauge.StepKind) 557 558 c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) 559 c.Assert(tokens[2].Kind, Equals, gauge.TableRow) 560 } 561 562 func (s *MySuite) TestParsingMultilineStep(c *C) { 563 env.AllowMultiLineStep = func() bool { return true } 564 parser := new(SpecParser) 565 specText := newSpecBuilder(). 566 step("step1"). 567 text("second line").String() 568 569 tokens, err := parser.GenerateTokens(specText, "") 570 c.Assert(err, IsNil) 571 c.Assert(len(tokens), Equals, 1) 572 573 c.Assert(tokens[0].Kind, Equals, gauge.StepKind) 574 c.Assert(tokens[0].Value, Equals, "step1 second line") 575 } 576 577 func (s *MySuite) TestParsingMultilineStepWithParams(c *C) { 578 env.AllowMultiLineStep = func() bool { return true } 579 parser := new(SpecParser) 580 specText := newSpecBuilder(). 581 step("step1"). 582 text("second line \"foo\""). 583 text("third line <bar>").String() 584 585 tokens, err := parser.GenerateTokens(specText, "") 586 c.Assert(err, IsNil) 587 c.Assert(len(tokens), Equals, 1) 588 589 c.Assert(tokens[0].Kind, Equals, gauge.StepKind) 590 c.Assert(tokens[0].Value, Equals, "step1 second line {static} third line {dynamic}") 591 c.Assert(len(tokens[0].Args), Equals, 2) 592 } 593 594 func (s *MySuite) TestParsingMultilineStepWithTableParam(c *C) { 595 env.AllowMultiLineStep = func() bool { return true } 596 parser := new(SpecParser) 597 specText := newSpecBuilder(). 598 step("step1"). 599 text("second line"). 600 text(""). 601 tableHeader("foo|bar"). 602 tableRow("somerow|another").String() 603 604 tokens, err := parser.GenerateTokens(specText, "") 605 c.Assert(err, IsNil) 606 c.Assert(len(tokens), Equals, 3) 607 608 c.Assert(tokens[0].Kind, Equals, gauge.StepKind) 609 c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) 610 c.Assert(tokens[2].Kind, Equals, gauge.TableRow) 611 } 612 613 func (s *MySuite) TestParsingMultilineStepScenarioNext(c *C) { 614 env.AllowMultiLineStep = func() bool { return true } 615 parser := new(SpecParser) 616 specText := newSpecBuilder(). 617 step("step1"). 618 text("Scenario1"). 619 text("---------").String() 620 621 tokens, err := parser.GenerateTokens(specText, "") 622 c.Assert(err, IsNil) 623 c.Assert(len(tokens), Equals, 2) 624 625 c.Assert(tokens[0].Kind, Equals, gauge.StepKind) 626 c.Assert(tokens[0].Value, Equals, "step1 Scenario1") 627 c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) 628 } 629 630 func (s *MySuite) TestParsingMultilineStepWithSpecNext(c *C) { 631 env.AllowMultiLineStep = func() bool { return true } 632 parser := new(SpecParser) 633 specText := newSpecBuilder(). 634 step("step1"). 635 text("Concept1"). 636 text("========").String() 637 638 tokens, err := parser.GenerateTokens(specText, "") 639 c.Assert(err, IsNil) 640 c.Assert(len(tokens), Equals, 2) 641 642 c.Assert(tokens[0].Kind, Equals, gauge.StepKind) 643 c.Assert(tokens[0].Value, Equals, "step1 Concept1") 644 c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) 645 646 } 647 648 func (s *MySuite) TestParsingSpecWithTearDownSteps(c *C) { 649 parser := new(SpecParser) 650 specText := newSpecBuilder().specHeading("A spec heading"). 651 text("Hello, i am a comment"). 652 scenarioHeading("First flow"). 653 step("another"). 654 text("_____"). 655 step("step1"). 656 step("step2").String() 657 658 tokens, err := parser.GenerateTokens(specText, "") 659 c.Assert(err, IsNil) 660 c.Assert(len(tokens), Equals, 7) 661 662 c.Assert(tokens[0].Kind, Equals, gauge.SpecKind) 663 c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) 664 665 c.Assert(tokens[2].Kind, Equals, gauge.ScenarioKind) 666 c.Assert(tokens[3].Kind, Equals, gauge.StepKind) 667 c.Assert(tokens[3].Value, Equals, "another") 668 c.Assert(tokens[4].Kind, Equals, gauge.TearDownKind) 669 670 c.Assert(tokens[5].Kind, Equals, gauge.StepKind) 671 c.Assert(tokens[5].Value, Equals, "step1") 672 c.Assert(tokens[6].Kind, Equals, gauge.StepKind) 673 c.Assert(tokens[6].Value, Equals, "step2") 674 }