github.com/getgauge/gauge@v1.6.9/gauge/arg_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 gauge
     8  
     9  import . "gopkg.in/check.v1"
    10  
    11  func (s *MySuite) TestLookupaddArg(c *C) {
    12  	lookup := new(ArgLookup)
    13  	lookup.AddArgName("param1")
    14  	lookup.AddArgName("param2")
    15  
    16  	c.Assert(lookup.ParamIndexMap["param1"], Equals, 0)
    17  	c.Assert(lookup.ParamIndexMap["param2"], Equals, 1)
    18  	c.Assert(len(lookup.paramValue), Equals, 2)
    19  	c.Assert(lookup.paramValue[0].name, Equals, "param1")
    20  	c.Assert(lookup.paramValue[1].name, Equals, "param2")
    21  
    22  }
    23  
    24  func (s *MySuite) TestLookupContainsArg(c *C) {
    25  	lookup := new(ArgLookup)
    26  	lookup.AddArgName("param1")
    27  	lookup.AddArgName("param2")
    28  
    29  	c.Assert(lookup.ContainsArg("param1"), Equals, true)
    30  	c.Assert(lookup.ContainsArg("param2"), Equals, true)
    31  	c.Assert(lookup.ContainsArg("param3"), Equals, false)
    32  }
    33  
    34  func (s *MySuite) TestAddArgValue(c *C) {
    35  	lookup := new(ArgLookup)
    36  	lookup.AddArgName("param1")
    37  	err := lookup.AddArgValue("param1", &StepArg{Value: "value1", ArgType: Static})
    38  	c.Assert(err, IsNil)
    39  	lookup.AddArgName("param2")
    40  	err = lookup.AddArgValue("param2", &StepArg{Value: "value2", ArgType: Dynamic})
    41  	c.Assert(err, IsNil)
    42  	stepArg, err := lookup.GetArg("param1")
    43  	c.Assert(err, IsNil)
    44  	c.Assert(stepArg.Value, Equals, "value1")
    45  	stepArg, err = lookup.GetArg("param2")
    46  	c.Assert(err, IsNil)
    47  	c.Assert(stepArg.Value, Equals, "value2")
    48  	c.Assert(stepArg.Name, Equals, "param2")
    49  }
    50  
    51  func (s *MySuite) TestErrorForInvalidArg(c *C) {
    52  	lookup := new(ArgLookup)
    53  	err := lookup.AddArgValue("param1", &StepArg{Value: "value1", ArgType: Static})
    54  	c.Assert(err.Error(), Equals, "Accessing an invalid parameter (param1)")
    55  	_, err = lookup.GetArg("param1")
    56  	c.Assert(err.Error(), Equals, "Accessing an invalid parameter (param1)")
    57  }
    58  
    59  func (s *MySuite) TestGetLookupCopy(c *C) {
    60  	originalLookup := new(ArgLookup)
    61  	originalLookup.AddArgName("param1")
    62  	err := originalLookup.AddArgValue("param1", &StepArg{Value: "oldValue", ArgType: Dynamic})
    63  	c.Assert(err, IsNil)
    64  
    65  	copiedLookup, _ := originalLookup.GetCopy()
    66  	err = copiedLookup.AddArgValue("param1", &StepArg{Value: "new value", ArgType: Static})
    67  	c.Assert(err, IsNil)
    68  
    69  	stepArg, err := copiedLookup.GetArg("param1")
    70  	c.Assert(err, IsNil)
    71  	c.Assert(stepArg.Value, Equals, "new value")
    72  	c.Assert(stepArg.Name, Equals, "param1")
    73  	stepArg, err = originalLookup.GetArg("param1")
    74  	c.Assert(err, IsNil)
    75  	c.Assert(stepArg.Value, Equals, "oldValue")
    76  }
    77  
    78  func (s *MySuite) TestGetLookupFromTableRow(c *C) {
    79  	dataTable := new(Table)
    80  	dataTable.AddHeaders([]string{"id", "name"})
    81  	dataTable.AddRowValues(dataTable.CreateTableCells([]string{"1", "admin"}))
    82  	dataTable.AddRowValues(dataTable.CreateTableCells([]string{"2", "root"}))
    83  
    84  	emptyLookup := new(ArgLookup)
    85  	err := emptyLookup.ReadDataTableRow(new(Table), 0)
    86  	c.Assert(err, IsNil)
    87  	c.Assert(emptyLookup.ParamIndexMap, IsNil)
    88  
    89  	lookup1 := new(ArgLookup)
    90  	err = lookup1.ReadDataTableRow(dataTable, 0)
    91  	c.Assert(err, IsNil)
    92  	idArg1, err := lookup1.GetArg("id")
    93  	c.Assert(err, IsNil)
    94  	nameArg1, err := lookup1.GetArg("name")
    95  	c.Assert(err, IsNil)
    96  	c.Assert(idArg1.Value, Equals, "1")
    97  	c.Assert(idArg1.ArgType, Equals, Static)
    98  	c.Assert(nameArg1.Value, Equals, "admin")
    99  	c.Assert(nameArg1.ArgType, Equals, Static)
   100  
   101  	lookup2 := new(ArgLookup)
   102  	err = lookup2.ReadDataTableRow(dataTable, 1)
   103  	c.Assert(err, IsNil)
   104  	idArg2, err := lookup2.GetArg("id")
   105  	c.Assert(err, IsNil)
   106  	nameArg2, err := lookup2.GetArg("name")
   107  	c.Assert(err, IsNil)
   108  	c.Assert(idArg2.Value, Equals, "2")
   109  	c.Assert(idArg2.ArgType, Equals, Static)
   110  	c.Assert(nameArg2.Value, Equals, "root")
   111  	c.Assert(nameArg2.ArgType, Equals, Static)
   112  }
   113  
   114  func (s *MySuite) TestGetLookupFromTables(c *C) {
   115  	t1 := new(Table)
   116  	t1.AddHeaders([]string{"id1", "name1"})
   117  	t1.AddRowValues(t1.CreateTableCells([]string{"1", "admin"}))
   118  	t1.AddRowValues(t1.CreateTableCells([]string{"2", "root"}))
   119  
   120  	t2 := new(Table)
   121  	t2.AddHeaders([]string{"id2", "name2"})
   122  	t2.AddRowValues(t2.CreateTableCells([]string{"1", "admin"}))
   123  	t2.AddRowValues(t2.CreateTableCells([]string{"2", "root"}))
   124  
   125  	l := new(ArgLookup).FromDataTables(t1, t2)
   126  
   127  	c.Assert(l.ContainsArg("id1"), Equals, true)
   128  	c.Assert(l.ContainsArg("name1"), Equals, true)
   129  	c.Assert(l.ContainsArg("id2"), Equals, true)
   130  	c.Assert(l.ContainsArg("name2"), Equals, true)
   131  }