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 }