github.com/getgauge/gauge@v1.6.9/parser/stepParser_test.go (about)

     1  /*----------------------------------------------------------------
     2   *  Copyright (c) ThoughtWorks, Inc.
     3   *  Licensed under the Apache License, Version 2.0
     4   *  See LICENSE in the project root for license information.
     5   *----------------------------------------------------------------*/
     6  
     7  package parser
     8  
     9  import (
    10  	"github.com/getgauge/gauge/gauge"
    11  	. "gopkg.in/check.v1"
    12  )
    13  
    14  func (s *MySuite) TestParsingSimpleStep(c *C) {
    15  	parser := new(SpecParser)
    16  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("sample step").String()
    17  
    18  	tokens, err := parser.GenerateTokens(specText, "")
    19  
    20  	c.Assert(err, IsNil)
    21  	c.Assert(len(tokens), Equals, 3)
    22  
    23  	stepToken := tokens[2]
    24  	c.Assert(stepToken.Kind, Equals, gauge.StepKind)
    25  	c.Assert(stepToken.Value, Equals, "sample step")
    26  }
    27  
    28  func (s *MySuite) TestParsingEmptyStepTextShouldThrowError(c *C) {
    29  	parser := new(SpecParser)
    30  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("").String()
    31  
    32  	_, errs := parser.GenerateTokens(specText, "foo.spec")
    33  
    34  	c.Assert(len(errs) > 0, Equals, true)
    35  	c.Assert(errs[0].Error(), Equals, "foo.spec:3 Step should not be blank => ''")
    36  }
    37  
    38  func (s *MySuite) TestParsingStepWithParams(c *C) {
    39  	parser := new(SpecParser)
    40  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("enter user \"john\"").String()
    41  
    42  	tokens, err := parser.GenerateTokens(specText, "")
    43  
    44  	c.Assert(err, IsNil)
    45  	c.Assert(len(tokens), Equals, 3)
    46  
    47  	stepToken := tokens[2]
    48  	c.Assert(stepToken.Kind, Equals, gauge.StepKind)
    49  	c.Assert(stepToken.Value, Equals, "enter user {static}")
    50  	c.Assert(len(stepToken.Args), Equals, 1)
    51  	c.Assert(stepToken.Args[0], Equals, "john")
    52  }
    53  
    54  func (s *MySuite) TestParsingStepWithParametersWithQuotes(c *C) {
    55  	parser := new(SpecParser)
    56  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("\"param \\\"in quote\\\"\" step ").step("another * step with \"john 12 *-_{} \\\\ './;[]\" and \"second\"").String()
    57  
    58  	tokens, err := parser.GenerateTokens(specText, "")
    59  
    60  	c.Assert(err, IsNil)
    61  	c.Assert(len(tokens), Equals, 4)
    62  
    63  	firstStepToken := tokens[2]
    64  	c.Assert(firstStepToken.Kind, Equals, gauge.StepKind)
    65  	c.Assert(firstStepToken.Value, Equals, "{static} step")
    66  	c.Assert(len(firstStepToken.Args), Equals, 1)
    67  	c.Assert(firstStepToken.Args[0], Equals, "param \"in quote\"")
    68  
    69  	secondStepToken := tokens[3]
    70  	c.Assert(secondStepToken.Kind, Equals, gauge.StepKind)
    71  	c.Assert(secondStepToken.Value, Equals, "another * step with {static} and {static}")
    72  	c.Assert(len(secondStepToken.Args), Equals, 2)
    73  	c.Assert(secondStepToken.Args[0], Equals, "john 12 *-_{} \\ './;[]")
    74  	c.Assert(secondStepToken.Args[1], Equals, "second")
    75  
    76  }
    77  
    78  func (s *MySuite) TestParsingStepWithUnmatchedOpeningQuote(c *C) {
    79  	parser := new(SpecParser)
    80  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("sample step \"param").String()
    81  
    82  	_, errs := parser.GenerateTokens(specText, "foo.spec")
    83  
    84  	c.Assert(len(errs) > 0, Equals, true)
    85  	c.Assert(errs[0].Error(), Equals, "foo.spec:3 String not terminated => 'sample step \"param'")
    86  }
    87  
    88  func (s *MySuite) TestParsingStepWithEscaping(c *C) {
    89  	parser := new(SpecParser)
    90  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("step with \\").String()
    91  
    92  	tokens, err := parser.GenerateTokens(specText, "")
    93  
    94  	c.Assert(err, IsNil)
    95  	stepToken := tokens[2]
    96  	c.Assert(stepToken.Value, Equals, "step with")
    97  }
    98  
    99  func (s *MySuite) TestParsingExceptionIfStepContainsReservedChars(c *C) {
   100  	parser := new(SpecParser)
   101  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("step with {braces}").String()
   102  
   103  	_, errs := parser.GenerateTokens(specText, "foo.spec")
   104  
   105  	c.Assert(len(errs) > 0, Equals, true)
   106  	c.Assert(errs[0].Error(), Equals, "foo.spec:3 '{' is a reserved character and should be escaped => 'step with {braces}'")
   107  }
   108  
   109  func (s *MySuite) TestParsingStepContainsEscapedReservedChars(c *C) {
   110  	parser := new(SpecParser)
   111  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("step with \\{braces\\}").String()
   112  
   113  	tokens, err := parser.GenerateTokens(specText, "")
   114  
   115  	c.Assert(err, IsNil)
   116  	stepToken := tokens[2]
   117  	c.Assert(stepToken.Value, Equals, "step with {braces}")
   118  }
   119  
   120  func (s *MySuite) TestParsingSimpleStepWithDynamicParameter(c *C) {
   121  	parser := new(SpecParser)
   122  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("Step with \"static param\" and <name1>").String()
   123  
   124  	tokens, err := parser.GenerateTokens(specText, "")
   125  	c.Assert(err, IsNil)
   126  	c.Assert(len(tokens), Equals, 3)
   127  
   128  	stepToken := tokens[2]
   129  	c.Assert(stepToken.Value, Equals, "Step with {static} and {dynamic}")
   130  	c.Assert(stepToken.Args[0], Equals, "static param")
   131  	c.Assert(stepToken.Args[1], Equals, "name1")
   132  }
   133  
   134  func (s *MySuite) TestParsingStepWithUnmatchedDynamicParameterCharacter(c *C) {
   135  	parser := new(SpecParser)
   136  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("Step with \"static param\" and <name1").String()
   137  
   138  	_, errs := parser.GenerateTokens(specText, "foo.spec")
   139  
   140  	c.Assert(len(errs) > 0, Equals, true)
   141  	c.Assert(errs[0].Error(), Equals, "foo.spec:3 Dynamic parameter not terminated => 'Step with \"static param\" and <name1'")
   142  
   143  }
   144  
   145  func (s *MySuite) TestParsingContext(c *C) {
   146  	parser := new(SpecParser)
   147  	specText := newSpecBuilder().specHeading("Spec heading with hash ").step("Context with \"param\"").scenarioHeading("Scenario Heading").String()
   148  
   149  	tokens, err := parser.GenerateTokens(specText, "")
   150  
   151  	c.Assert(err, IsNil)
   152  	contextToken := tokens[1]
   153  	c.Assert(contextToken.Kind, Equals, gauge.StepKind)
   154  	c.Assert(contextToken.Value, Equals, "Context with {static}")
   155  	c.Assert(contextToken.Args[0], Equals, "param")
   156  }
   157  
   158  func (s *MySuite) TestParsingThrowsErrorWhenStepIsPresentWithoutStep(c *C) {
   159  	parser := new(SpecParser)
   160  	specText := newSpecBuilder().step("step without spec heading").String()
   161  
   162  	tokens, err := parser.GenerateTokens(specText, "")
   163  
   164  	c.Assert(err, IsNil)
   165  	c.Assert(tokens[0].Kind, Equals, gauge.StepKind)
   166  	c.Assert(tokens[0].Value, Equals, "step without spec heading")
   167  
   168  }
   169  
   170  func (s *MySuite) TestParsingStepWithSimpleSpecialParameter(c *C) {
   171  	parser := new(SpecParser)
   172  	specText := newSpecBuilder().specHeading("Spec heading with hash ").scenarioHeading("Scenario Heading").step("Step with special parameter <table:user.csv>").String()
   173  
   174  	tokens, err := parser.GenerateTokens(specText, "")
   175  
   176  	c.Assert(err, IsNil)
   177  	c.Assert(len(tokens), Equals, 3)
   178  
   179  	c.Assert(tokens[2].Kind, Equals, gauge.StepKind)
   180  	c.Assert(tokens[2].Value, Equals, "Step with special parameter {special}")
   181  	c.Assert(len(tokens[2].Args), Equals, 1)
   182  	c.Assert(tokens[2].Args[0], Equals, "table:user.csv")
   183  }
   184  
   185  func (s *MySuite) TestParsingStepWithSpecialParametersWithWhiteSpaces(c *C) {
   186  	parser := new(SpecParser)
   187  	specText := newSpecBuilder().specHeading("Spec heading with hash ").step("Step with \"first\" and special parameter <table : user.csv>").step("Another with <name> and <file  :something.txt>").String()
   188  
   189  	tokens, err := parser.GenerateTokens(specText, "")
   190  
   191  	c.Assert(err, IsNil)
   192  	c.Assert(len(tokens), Equals, 3)
   193  
   194  	c.Assert(tokens[1].Kind, Equals, gauge.StepKind)
   195  	c.Assert(tokens[1].Value, Equals, "Step with {static} and special parameter {special}")
   196  	c.Assert(len(tokens[1].Args), Equals, 2)
   197  	c.Assert(tokens[1].Args[0], Equals, "first")
   198  	c.Assert(tokens[1].Args[1], Equals, "table : user.csv")
   199  
   200  	c.Assert(tokens[2].Kind, Equals, gauge.StepKind)
   201  	c.Assert(tokens[2].Value, Equals, "Another with {dynamic} and {special}")
   202  	c.Assert(len(tokens[2].Args), Equals, 2)
   203  	c.Assert(tokens[2].Args[0], Equals, "name")
   204  	c.Assert(tokens[2].Args[1], Equals, "file  :something.txt")
   205  }
   206  
   207  func (s *MySuite) TestParsingStepWithStaticParamHavingEscapeChar(c *C) {
   208  	tokenValue, args, err := processStepText(`step "a\nb" only`)
   209  	c.Assert(err, IsNil)
   210  	c.Assert(args[0], Equals, "a\nb")
   211  	c.Assert(tokenValue, Equals, "step {static} only")
   212  }
   213  
   214  func (s *MySuite) TestParsingStepWithStaticParamHavingDifferentEscapeChar(c *C) {
   215  	tokenValue, args, err := processStepText(`step "foo bar \"hello\" all \"he\n\n\tyy \"foo\"hjhj\"" only`)
   216  	c.Assert(err, IsNil)
   217  	c.Assert(args[0], Equals, "foo bar \"hello\" all \"he\n\n\tyy \"foo\"hjhj\"")
   218  	c.Assert(tokenValue, Equals, "step {static} only")
   219  }
   220  
   221  func (s *MySuite) TestParsingStepWithStaticParamHavingNestedEscapeSequences(c *C) {
   222  	tokenValue, args, err := processStepText(`step "foo \t tab \n \"a\"dd r \\n" only`)
   223  	c.Assert(err, IsNil)
   224  	c.Assert(args[0], Equals, "foo \t tab \n \"a\"dd r \\n")
   225  	c.Assert(tokenValue, Equals, "step {static} only")
   226  }
   227  
   228  func (s *MySuite) TestParsingStepWithSlash(c *C) {
   229  	tokenValue, args, err := processStepText(`step foo \ only`)
   230  	c.Assert(err, IsNil)
   231  	c.Assert(len(args), Equals, 0)
   232  	c.Assert(tokenValue, Equals, "step foo \\ only")
   233  }
   234  
   235  func (s *MySuite) TestParsingStepWithTab(c *C) {
   236  	tokenValue, args, err := processStepText("step foo \t only")
   237  	c.Assert(err, IsNil)
   238  	c.Assert(len(args), Equals, 0)
   239  	c.Assert(tokenValue, Equals, "step foo \t only")
   240  }