gitee.com/mirrors/gauge@v1.0.6/reporter/reporter_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 reporter
    19  
    20  import (
    21  	"sync"
    22  
    23  	"github.com/getgauge/gauge/execution/event"
    24  	"github.com/getgauge/gauge/execution/result"
    25  	"github.com/getgauge/gauge/gauge"
    26  	"github.com/getgauge/gauge/gauge_messages"
    27  	. "gopkg.in/check.v1"
    28  )
    29  
    30  var dataTableEvent = event.Topic(100)
    31  
    32  func (s *MySuite) TestSubscribeSpecEnd(c *C) {
    33  	e := make(chan event.Topic)
    34  	currentReporter = &dummyConsole{event: e}
    35  	SimpleConsoleOutput = true
    36  	event.InitRegistry()
    37  
    38  	ListenExecutionEvents(&sync.WaitGroup{})
    39  
    40  	event.Notify(event.NewExecutionEvent(event.SpecEnd, &gauge.Specification{}, &DummyResult{}, 0, gauge_messages.ExecutionInfo{}))
    41  	c.Assert(<-e, Equals, event.SpecEnd)
    42  }
    43  
    44  func (s *MySuite) TestSubscribeSuiteStart(c *C) {
    45  	e := make(chan event.Topic)
    46  	currentReporter = &dummyConsole{event: e}
    47  	event.InitRegistry()
    48  
    49  	ListenExecutionEvents(&sync.WaitGroup{})
    50  
    51  	event.Notify(event.NewExecutionEvent(event.SuiteStart, nil, nil, 0, gauge_messages.ExecutionInfo{}))
    52  	c.Assert(<-e, Equals, event.SuiteStart)
    53  }
    54  
    55  func (s *MySuite) TestSubscribeSpecStart(c *C) {
    56  	e := make(chan event.Topic)
    57  	currentReporter = &dummyConsole{event: e}
    58  	event.InitRegistry()
    59  	spec := &gauge.Specification{Heading: &gauge.Heading{Value: "My Spec Heading"}}
    60  
    61  	ListenExecutionEvents(&sync.WaitGroup{})
    62  
    63  	event.Notify(event.NewExecutionEvent(event.SpecStart, spec, nil, 0, gauge_messages.ExecutionInfo{}))
    64  	c.Assert(<-e, Equals, event.SpecStart)
    65  }
    66  
    67  func (s *MySuite) TestSubscribeScenarioStart(c *C) {
    68  	e := make(chan event.Topic)
    69  	currentReporter = &dummyConsole{event: e}
    70  	event.InitRegistry()
    71  	sceHeading := "My scenario heading"
    72  	sce := &gauge.Scenario{Heading: &gauge.Heading{Value: sceHeading}}
    73  	sceRes := result.NewScenarioResult(&gauge_messages.ProtoScenario{ScenarioHeading: sceHeading})
    74  
    75  	ListenExecutionEvents(&sync.WaitGroup{})
    76  
    77  	event.Notify(event.NewExecutionEvent(event.ScenarioStart, sce, sceRes, 0, gauge_messages.ExecutionInfo{}))
    78  	c.Assert(<-e, Equals, event.ScenarioStart)
    79  }
    80  
    81  func (s *MySuite) TestSubscribeScenarioStartWithDataTable(c *C) {
    82  	e := make(chan event.Topic)
    83  	currentReporter = &dummyConsole{event: e}
    84  	event.InitRegistry()
    85  	dataTable := gauge.Table{}
    86  	dataTable.AddHeaders([]string{"foo", "bar"})
    87  	dataTable.AddRowValues(dataTable.CreateTableCells([]string{"one", "two"}))
    88  	sceHeading := "My scenario heading"
    89  	step := &gauge.Step{
    90  		Args: []*gauge.StepArg{&gauge.StepArg{Name: "foo",
    91  			Value:   "foo",
    92  			ArgType: gauge.Dynamic}},
    93  	}
    94  	sce := &gauge.Scenario{Heading: &gauge.Heading{Value: sceHeading}, SpecDataTableRow: dataTable, Steps: []*gauge.Step{step}}
    95  	sceRes := result.NewScenarioResult(&gauge_messages.ProtoScenario{ScenarioHeading: sceHeading})
    96  
    97  	ListenExecutionEvents(&sync.WaitGroup{})
    98  
    99  	event.Notify(event.NewExecutionEvent(event.ScenarioStart, sce, sceRes, 0, gauge_messages.ExecutionInfo{}))
   100  	c.Assert(<-e, Equals, dataTableEvent)
   101  	c.Assert(<-e, Equals, event.ScenarioStart)
   102  }
   103  
   104  func (s *MySuite) TestSubscribeScenarioEnd(c *C) {
   105  	e := make(chan event.Topic)
   106  	currentReporter = &dummyConsole{event: e}
   107  	event.InitRegistry()
   108  	sceRes := result.NewScenarioResult(&gauge_messages.ProtoScenario{ScenarioHeading: "My scenario heading"})
   109  
   110  	ListenExecutionEvents(&sync.WaitGroup{})
   111  
   112  	event.Notify(event.NewExecutionEvent(event.ScenarioEnd, &gauge.Scenario{}, sceRes, 0, gauge_messages.ExecutionInfo{}))
   113  	c.Assert(<-e, Equals, event.ScenarioEnd)
   114  }
   115  
   116  func (s *MySuite) TestSubscribeStepStart(c *C) {
   117  	e := make(chan event.Topic)
   118  	currentReporter = &dummyConsole{event: e}
   119  	event.InitRegistry()
   120  	stepText := "My first step"
   121  	step := &gauge.Step{Value: stepText}
   122  
   123  	ListenExecutionEvents(&sync.WaitGroup{})
   124  
   125  	event.Notify(event.NewExecutionEvent(event.StepStart, step, nil, 0, gauge_messages.ExecutionInfo{}))
   126  	c.Assert(<-e, Equals, event.StepStart)
   127  }
   128  
   129  func (s *MySuite) TestSubscribeStepEnd(c *C) {
   130  	e := make(chan event.Topic)
   131  	currentReporter = &dummyConsole{event: e}
   132  	event.InitRegistry()
   133  	stepExeRes := &gauge_messages.ProtoStepExecutionResult{ExecutionResult: &gauge_messages.ProtoExecutionResult{Failed: false}}
   134  	stepRes := result.NewStepResult(&gauge_messages.ProtoStep{StepExecutionResult: stepExeRes})
   135  
   136  	ListenExecutionEvents(&sync.WaitGroup{})
   137  
   138  	event.Notify(event.NewExecutionEvent(event.StepEnd, gauge.Step{}, stepRes, 0, gauge_messages.ExecutionInfo{}))
   139  	c.Assert(<-e, Equals, event.StepEnd)
   140  }
   141  
   142  func (s *MySuite) TestSubscribeConceptStart(c *C) {
   143  	e := make(chan event.Topic)
   144  	currentReporter = &dummyConsole{event: e}
   145  	SimpleConsoleOutput = true
   146  	event.InitRegistry()
   147  	Verbose = true
   148  	cptText := "My last concept"
   149  	concept := &gauge.Step{Value: cptText, IsConcept: true}
   150  
   151  	ListenExecutionEvents(&sync.WaitGroup{})
   152  
   153  	event.Notify(event.NewExecutionEvent(event.ConceptStart, concept, nil, 0, gauge_messages.ExecutionInfo{}))
   154  	c.Assert(<-e, Equals, event.ConceptStart)
   155  }
   156  
   157  func (s *MySuite) TestSubscribeConceptEnd(c *C) {
   158  	e := make(chan event.Topic)
   159  	currentReporter = &dummyConsole{event: e}
   160  	event.InitRegistry()
   161  	cptExeRes := &gauge_messages.ProtoStepExecutionResult{ExecutionResult: &gauge_messages.ProtoExecutionResult{Failed: true}}
   162  	cptRes := result.NewConceptResult(&gauge_messages.ProtoConcept{ConceptExecutionResult: cptExeRes})
   163  
   164  	ListenExecutionEvents(&sync.WaitGroup{})
   165  
   166  	event.Notify(event.NewExecutionEvent(event.ConceptEnd, nil, cptRes, 0, gauge_messages.ExecutionInfo{}))
   167  	c.Assert(<-e, Equals, event.ConceptEnd)
   168  }
   169  
   170  func (s *MySuite) TestSubscribeSuiteEnd(c *C) {
   171  	e := make(chan event.Topic)
   172  	currentReporter = &dummyConsole{event: e}
   173  	event.InitRegistry()
   174  	suiteRes := &result.SuiteResult{UnhandledErrors: []error{}}
   175  
   176  	ListenExecutionEvents(&sync.WaitGroup{})
   177  	event.Notify(event.NewExecutionEvent(event.SuiteEnd, nil, suiteRes, 0, gauge_messages.ExecutionInfo{}))
   178  
   179  	c.Assert(<-e, Equals, event.SuiteEnd)
   180  }
   181  
   182  type dummyConsole struct {
   183  	event chan event.Topic
   184  }
   185  
   186  func (dc *dummyConsole) SuiteStart() {
   187  	dc.event <- event.SuiteStart
   188  }
   189  
   190  func (dc *dummyConsole) SpecStart(spec *gauge.Specification, res result.Result) {
   191  	dc.event <- event.SpecStart
   192  }
   193  
   194  func (dc *dummyConsole) SpecEnd(spec *gauge.Specification, res result.Result) {
   195  	dc.event <- event.SpecEnd
   196  }
   197  
   198  func (dc *dummyConsole) ScenarioStart(scenario *gauge.Scenario, i gauge_messages.ExecutionInfo, res result.Result) {
   199  	dc.event <- event.ScenarioStart
   200  }
   201  
   202  func (dc *dummyConsole) ScenarioEnd(s *gauge.Scenario, res result.Result, i gauge_messages.ExecutionInfo) {
   203  	dc.event <- event.ScenarioEnd
   204  }
   205  
   206  func (dc *dummyConsole) StepStart(stepText string) {
   207  	dc.event <- event.StepStart
   208  }
   209  
   210  func (dc *dummyConsole) StepEnd(step gauge.Step, res result.Result, execInfo gauge_messages.ExecutionInfo) {
   211  	dc.event <- event.StepEnd
   212  }
   213  
   214  func (dc *dummyConsole) ConceptStart(conceptHeading string) {
   215  	dc.event <- event.ConceptStart
   216  }
   217  
   218  func (dc *dummyConsole) ConceptEnd(res result.Result) {
   219  	dc.event <- event.ConceptEnd
   220  }
   221  
   222  func (dc *dummyConsole) SuiteEnd(res result.Result) {
   223  	dc.event <- event.SuiteEnd
   224  }
   225  
   226  func (dc *dummyConsole) DataTable(table string) {
   227  	dc.event <- dataTableEvent
   228  }
   229  
   230  func (dc *dummyConsole) Errorf(err string, args ...interface{}) {
   231  }
   232  
   233  func (dc *dummyConsole) Write(b []byte) (int, error) {
   234  	return len(b), nil
   235  }