github.com/mattdotmatt/gauge@v0.3.2-0.20160421115137-425a4cdccb62/gauge/protoConverters_test.go (about)

     1  // Copyright 2015 ThoughtWorks, Inc.
     2  
     3  // This file is part of Gauge.
     4  
     5  // Gauge is free software: you can redistribute it and/or modify
     6  // it under the terms of the GNU General Public License as published by
     7  // the Free Software Foundation, either version 3 of the License, or
     8  // (at your option) any later version.
     9  
    10  // Gauge is distributed in the hope that it will be useful,
    11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13  // GNU General Public License for more details.
    14  
    15  // You should have received a copy of the GNU General Public License
    16  // along with Gauge.  If not, see <http://www.gnu.org/licenses/>.
    17  
    18  package gauge
    19  
    20  import (
    21  	"github.com/getgauge/gauge/gauge_messages"
    22  	"github.com/golang/protobuf/proto"
    23  	. "gopkg.in/check.v1"
    24  )
    25  
    26  func (s *MySuite) TestCopyingFragments(c *C) {
    27  	text1 := &gauge_messages.Fragment{FragmentType: gauge_messages.Fragment_Text.Enum(), Text: proto.String("step with")}
    28  	staticParam := &gauge_messages.Fragment{FragmentType: gauge_messages.Fragment_Parameter.Enum(), Parameter: &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Static.Enum(), Value: proto.String("param0")}}
    29  	text2 := &gauge_messages.Fragment{FragmentType: gauge_messages.Fragment_Text.Enum(), Text: proto.String("and")}
    30  	dynamicParam := &gauge_messages.Fragment{FragmentType: gauge_messages.Fragment_Parameter.Enum(), Parameter: &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Dynamic.Enum(), Value: proto.String("param1")}}
    31  	fragments := []*gauge_messages.Fragment{text1, staticParam, text2, dynamicParam}
    32  
    33  	copiedFragments := makeFragmentsCopy(fragments)
    34  
    35  	compareFragments(fragments, copiedFragments, c)
    36  
    37  	fragments[1].Parameter.Value = proto.String("changedParam")
    38  	fragments[2].Text = proto.String("changed text")
    39  
    40  	c.Assert(copiedFragments[1].Parameter.GetValue(), Equals, "param0")
    41  	c.Assert(copiedFragments[2].GetText(), Equals, "and")
    42  }
    43  
    44  func (s *MySuite) TestCopyingProtoTable(c *C) {
    45  	headers := &gauge_messages.ProtoTableRow{Cells: []string{"id", "name", "description"}}
    46  	row1 := &gauge_messages.ProtoTableRow{Cells: []string{"123", "abc", "first description"}}
    47  	row2 := &gauge_messages.ProtoTableRow{Cells: []string{"456", "def", "second description"}}
    48  
    49  	table := &gauge_messages.ProtoTable{Headers: headers, Rows: []*gauge_messages.ProtoTableRow{row1, row2}}
    50  	copiedTable := makeTableCopy(table)
    51  
    52  	compareTable(table, copiedTable, c)
    53  	table.Headers.Cells[0] = "new id"
    54  	table.Rows[0].Cells[0] = "789"
    55  	table.Rows[1].Cells[1] = "xyz"
    56  
    57  	c.Assert(copiedTable.Headers.Cells[0], Equals, "id")
    58  	c.Assert(copiedTable.Rows[0].Cells[0], Equals, "123")
    59  	c.Assert(copiedTable.Rows[1].Cells[1], Equals, "def")
    60  
    61  }
    62  
    63  func (s *MySuite) TestCopyingStepValue(c *C) {
    64  	stepValue := &StepValue{[]string{"param1"}, "foo with {}", "foo with <param>"}
    65  	protoStepValue := ConvertToProtoStepValue(stepValue)
    66  
    67  	c.Assert(protoStepValue.GetStepValue(), Equals, stepValue.StepValue)
    68  	c.Assert(protoStepValue.GetParameterizedStepValue(), Equals, stepValue.ParameterizedStepValue)
    69  	c.Assert(protoStepValue.GetParameters(), DeepEquals, stepValue.Args)
    70  }
    71  
    72  func compareFragments(fragmentList1 []*gauge_messages.Fragment, fragmentList2 []*gauge_messages.Fragment, c *C) {
    73  	c.Assert(len(fragmentList1), Equals, len(fragmentList2))
    74  	for i, _ := range fragmentList1 {
    75  		compareFragment(fragmentList1[i], fragmentList2[i], c)
    76  	}
    77  }
    78  
    79  func compareFragment(fragment1 *gauge_messages.Fragment, fragment2 *gauge_messages.Fragment, c *C) {
    80  	c.Assert(fragment1.GetFragmentType(), Equals, fragment2.GetFragmentType())
    81  	c.Assert(fragment1.GetText(), Equals, fragment2.GetText())
    82  	parameter1 := fragment1.GetParameter()
    83  	parameter2 := fragment2.GetParameter()
    84  	compareParameter(parameter1, parameter2, c)
    85  }
    86  
    87  func compareParameter(parameter1 *gauge_messages.Parameter, parameter2 *gauge_messages.Parameter, c *C) {
    88  	if parameter1 != nil && parameter2 != nil {
    89  		c.Assert(parameter1.GetParameterType(), Equals, parameter2.GetParameterType())
    90  		c.Assert(parameter1.GetName(), Equals, parameter2.GetName())
    91  		c.Assert(parameter1.GetValue(), Equals, parameter2.GetValue())
    92  		compareTable(parameter1.GetTable(), parameter2.GetTable(), c)
    93  
    94  	} else if (parameter1 == nil && parameter2 != nil) || (parameter1 != nil && parameter2 == nil) {
    95  		c.Log("One parameter was nil and the other wasn't")
    96  		c.Fail()
    97  	}
    98  }
    99  
   100  func compareTable(table1 *gauge_messages.ProtoTable, table2 *gauge_messages.ProtoTable, c *C) {
   101  	compareTableRow(table1.GetHeaders(), table2.GetHeaders(), c)
   102  	c.Assert(len(table1.GetRows()), Equals, len(table2.GetRows()))
   103  	for i, row := range table1.GetRows() {
   104  		compareTableRow(row, table2.GetRows()[i], c)
   105  	}
   106  }
   107  
   108  func compareTableRow(row1 *gauge_messages.ProtoTableRow, row2 *gauge_messages.ProtoTableRow, c *C) {
   109  	c.Assert(row1.GetCells(), DeepEquals, row2.GetCells())
   110  }