Skip to content

Commit

Permalink
Added an interface for the reporter
Browse files Browse the repository at this point in the history
  • Loading branch information
@come-maiz
come-maiz committed Jan 29, 2016
1 parent efb631f commit 0406dac
Show file tree
Hide file tree
Showing 4 changed files with 169 additions and 88 deletions.
20 changes: 10 additions & 10 deletions check.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -520,7 +520,7 @@ type suiteRunner struct {
tempDir *tempDir
keepDir bool
logOutput io.Writer
output *outputWriter
reporter testReporter
reportedProblemLast bool
benchTime time.Duration
benchMem bool
Expand Down Expand Up @@ -565,7 +565,7 @@ func newSuiteRunner(suite interface{}, runConf *RunConf) *suiteRunner {
runner := &suiteRunner{
suite: suite,
logOutput: conf.Output,
output: newOutputWriter(conf.Output, verbosity),
reporter: newOutputWriter(conf.Output, verbosity),
tracker: newResultTracker(),
benchTime: conf.BenchmarkTime,
benchMem: conf.BenchmarkMem,
Expand Down Expand Up @@ -853,31 +853,31 @@ func (runner *suiteRunner) checkFixtureArgs() bool {
}

func (runner *suiteRunner) reportCallStarted(c *C) {
runner.output.WriteCallStarted("START", c)
runner.reporter.StartTest(c)
}

func (runner *suiteRunner) reportCallDone(c *C) {
runner.tracker.callDone(c)
switch c.status() {
case succeededSt:
if c.mustFail {
runner.output.WriteCallSuccess("FAIL EXPECTED", c)
runner.reporter.AddExpectedFailure(c)
} else {
runner.output.WriteCallSuccess("PASS", c)
runner.reporter.AddSuccess(c)
}
case skippedSt:
runner.output.WriteCallSuccess("SKIP", c)
runner.reporter.AddSkip(c)
case failedSt:
runner.output.WriteCallProblem("FAIL", c)
runner.reporter.AddFailure(c)
case panickedSt:
runner.output.WriteCallProblem("PANIC", c)
runner.reporter.AddError(c)
case fixturePanickedSt:
// That's a testKd call reporting that its fixture
// has panicked. The fixture call which caused the
// panic itself was tracked above. We'll report to
// aid debugging.
runner.output.WriteCallProblem("PANIC", c)
runner.reporter.AddError(c)
case missedSt:
runner.output.WriteCallSuccess("MISS", c)
runner.reporter.AddMissed(c)
}
}
4 changes: 4 additions & 0 deletions export_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,10 @@ package check

import "io"

type TestReporter interface {
testReporter
}

func PrintLine(filename string, line int) (string, error) {
return printLine(filename, line)
}
Expand Down
50 changes: 46 additions & 4 deletions reporter.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,18 @@ import (
"sync"
)

type testReporter interface {
StartTest(*C)
StopTest(*C)
AddFailure(*C)
AddError(*C)
AddUnexpectedSuccess(*C)
AddSuccess(*C)
AddExpectedFailure(*C)
AddSkip(*C)
AddMissed(*C)
}

// -----------------------------------------------------------------------
// Output writer manages atomic output writing according to settings.

Expand All @@ -20,16 +32,27 @@ func newOutputWriter(writer io.Writer, verbosity uint8) *outputWriter {
return &outputWriter{writer: writer, verbosity: verbosity}
}

func (ow *outputWriter) WriteCallStarted(label string, c *C) {
func (ow *outputWriter) StartTest(c *C) {
if ow.verbosity > 1 {
header := renderCallHeader(label, c, "", "\n")
header := renderCallHeader("START", c, "", "\n")
ow.m.Lock()
ow.writer.Write([]byte(header))
ow.m.Unlock()
}
}

func (ow *outputWriter) WriteCallProblem(label string, c *C) {
func (ow *outputWriter) StopTest(c *C) {
}

func (ow *outputWriter) AddFailure(c *C) {
ow.writeProblem("FAIL", c)
}

func (ow *outputWriter) AddError(c *C) {
ow.writeProblem("PANIC", c)
}

func (ow *outputWriter) writeProblem(label string, c *C) {
var prefix string
if ow.verbosity < 2 {
prefix = "\n-----------------------------------" +
Expand All @@ -45,7 +68,26 @@ func (ow *outputWriter) WriteCallProblem(label string, c *C) {
ow.m.Unlock()
}

func (ow *outputWriter) WriteCallSuccess(label string, c *C) {
func (ow *outputWriter) AddUnexpectedSuccess(c *C) {
}

func (ow *outputWriter) AddSuccess(c *C) {
ow.writeSuccess("PASS", c)
}

func (ow *outputWriter) AddExpectedFailure(c *C) {
ow.writeSuccess("FAIL EXPECTED", c)
}

func (ow *outputWriter) AddSkip(c *C) {
ow.writeSuccess("SKIP", c)
}

func (ow *outputWriter) AddMissed(c *C) {
ow.writeSuccess("MISS", c)
}

func (ow *outputWriter) writeSuccess(label string, c *C) {
if ow.verbosity > 1 || (ow.verbosity == 1 && c.kind == testKd) {
// TODO Use a buffer here.
var suffix string
Expand Down
183 changes: 109 additions & 74 deletions reporter_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,119 +20,154 @@ func (s *reporterS) SetUpSuite(c *C) {
s.testFile = filepath.Base(fileName)
}

func (s *reporterS) TestWriteCallStartedWithStreamFlag(c *C) {
testLabel := "test started label"
func (s *reporterS) TestStartTestWithHighVerbosity(c *C) {
var verbosity uint8 = 2
output := String{}

o := NewOutputWriter(&output, verbosity)

o.WriteCallStarted(testLabel, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s\n", testLabel, s.testFile, c.TestName())
o.StartTest(c)
expected := fmt.Sprintf("START: %s:\\d+: %s\n", s.testFile, c.TestName())
c.Assert(output.value, Matches, expected)
}

func (s *reporterS) TestWriteCallStartedWithoutStreamFlag(c *C) {
func (s *reporterS) TestStartTestLowVerbosity(c *C) {
var verbosity uint8 = 1
output := String{}

dummyLabel := "dummy"
o := NewOutputWriter(&output, verbosity)

o.WriteCallStarted(dummyLabel, c)
o.StartTest(c)
c.Assert(output.value, Equals, "")
}

func (s *reporterS) TestWriteCallProblemWithStreamFlag(c *C) {
testLabel := "test problem label"
var verbosity uint8 = 2
output := String{}
var problemTests = []string{"FAIL", "PANIC"}

o := NewOutputWriter(&output, verbosity)
func addProblem(label string, r TestReporter, c *C) {
if label == "FAIL" {
r.AddFailure(c)
} else if label == "PANIC" {
r.AddError(c)
} else {
panic("Unknown problem: " + label)
}
}

o.WriteCallProblem(testLabel, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s\n\n", testLabel, s.testFile, c.TestName())
c.Assert(output.value, Matches, expected)
func (s *reporterS) TestAddProblemWitHighVerbosity(c *C) {
for _, testLabel := range problemTests {
var verbosity uint8 = 2
output := String{}

o := NewOutputWriter(&output, verbosity)

addProblem(testLabel, o, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s\n\n", testLabel, s.testFile, c.TestName())
c.Check(output.value, Matches, expected)
}
}

func (s *reporterS) TestWriteCallProblemWithoutStreamFlag(c *C) {
testLabel := "test problem label"
var verbosity uint8 = 1
output := String{}
func (s *reporterS) TestAddProblemWithLowVerbosity(c *C) {
for _, testLabel := range problemTests {
var verbosity uint8 = 1
output := String{}

o := NewOutputWriter(&output, verbosity)

addProblem(testLabel, o, c)
expected := fmt.Sprintf(""+
"\n"+
"----------------------------------------------------------------------\n"+
"%s: %s:\\d+: %s\n\n", testLabel, s.testFile, c.TestName())
c.Check(output.value, Matches, expected)
}
}

o := NewOutputWriter(&output, verbosity)
func (s *reporterS) TestAddProblemWithLowVerbosityWithLog(c *C) {
for _, testLabel := range problemTests {
testLog := "test log"
var verbosity uint8 = 1
output := String{}

o.WriteCallProblem(testLabel, c)
expected := fmt.Sprintf(""+
"\n"+
"----------------------------------------------------------------------\n"+
"%s: %s:\\d+: %s\n\n", testLabel, s.testFile, c.TestName())
c.Assert(output.value, Matches, expected)
}
o := NewOutputWriter(&output, verbosity)

func (s *reporterS) TestWriteCallProblemWithoutStreamFlagWithLog(c *C) {
testLabel := "test problem label"
testLog := "test log"
var verbosity uint8 = 1
output := String{}
c.Log(testLog)
addProblem(testLabel, o, c)

o := NewOutputWriter(&output, verbosity)
expected := fmt.Sprintf(""+
"\n"+
"----------------------------------------------------------------------\n"+
"%s: %s:\\d+: %s\n\n%s\n", testLabel, s.testFile, c.TestName(), testLog)
c.Check(output.value, Matches, expected)
}
}

c.Log(testLog)
o.WriteCallProblem(testLabel, c)
expected := fmt.Sprintf(""+
"\n"+
"----------------------------------------------------------------------\n"+
"%s: %s:\\d+: %s\n\n%s\n", testLabel, s.testFile, c.TestName(), testLog)
c.Assert(output.value, Matches, expected)
var successTests = []string{"PASS", "SKIP", "FAIL EXPECTED", "MISS"}

func addSuccess(label string, r TestReporter, c *C) {
if label == "PASS" {
r.AddSuccess(c)
} else if label == "SKIP" {
r.AddSkip(c)
} else if label == "FAIL EXPECTED" {
r.AddExpectedFailure(c)
} else if label == "MISS" {
r.AddMissed(c)
} else {
panic("Unknown success: " + label)
}
}

func (s *reporterS) TestWriteCallSuccessWithStreamFlag(c *C) {
testLabel := "test success label"
var verbosity uint8 = 2
output := String{}
func (s *reporterS) TestAddSuccessWithHighVerbosity(c *C) {
for _, testLabel := range successTests {
var verbosity uint8 = 2
output := String{}

o := NewOutputWriter(&output, verbosity)
o := NewOutputWriter(&output, verbosity)

o.WriteCallSuccess(testLabel, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s\t\\d\\.\\d+s\n\n", testLabel, s.testFile, c.TestName())
c.Assert(output.value, Matches, expected)
addSuccess(testLabel, o, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s\t\\d\\.\\d+s\n\n", testLabel, s.testFile, c.TestName())
c.Check(output.value, Matches, expected)
}
}

func (s *reporterS) TestWriteCallSuccessWithStreamFlagAndReason(c *C) {
testLabel := "test success label"
testReason := "test skip reason"
var verbosity uint8 = 2
output := String{}
func (s *reporterS) TestAddSuccessWithHighVerbosityAndReason(c *C) {
for _, testLabel := range successTests {
testReason := "test skip reason"
var verbosity uint8 = 2
output := String{}

o := NewOutputWriter(&output, verbosity)
c.FakeSkip(testReason)
o := NewOutputWriter(&output, verbosity)
c.FakeSkip(testReason)

o.WriteCallSuccess(testLabel, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s \\(%s\\)\t\\d\\.\\d+s\n\n",
testLabel, s.testFile, c.TestName(), testReason)
c.Assert(output.value, Matches, expected)
addSuccess(testLabel, o, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s \\(%s\\)\t\\d\\.\\d+s\n\n",
testLabel, s.testFile, c.TestName(), testReason)
c.Check(output.value, Matches, expected)
}
}

func (s *reporterS) TestWriteCallSuccessWithoutStreamFlagWithVerboseFlag(c *C) {
testLabel := "test success label"
var verbosity uint8 = 1
output := String{}
func (s *reporterS) TestAddSuccessWithLowVerbosity(c *C) {
for _, testLabel := range successTests {
var verbosity uint8 = 1
output := String{}

o := NewOutputWriter(&output, verbosity)
o := NewOutputWriter(&output, verbosity)

o.WriteCallSuccess(testLabel, c)
expected := fmt.Sprintf("%s: %s:\\d+: %s\t\\d\\.\\d+s\n", testLabel, s.testFile, c.TestName())
c.Assert(output.value, Matches, expected)
addSuccess(testLabel, o, c)

expected := fmt.Sprintf("%s: %s:\\d+: %s\t\\d\\.\\d+s\n", testLabel, s.testFile, c.TestName())
c.Check(output.value, Matches, expected)
}
}

func (s *reporterS) TestWriteCallSuccessWithoutStreamFlagWithoutVerboseFlag(c *C) {
testLabel := "test success label"
var verbosity uint8 = 0
output := String{}
func (s *reporterS) TestAddSuccessWithoutVerbosity(c *C) {
for _, testLabel := range successTests {
var verbosity uint8 = 0
output := String{}

o := NewOutputWriter(&output, verbosity)
o := NewOutputWriter(&output, verbosity)

o.WriteCallSuccess(testLabel, c)
c.Assert(output.value, Equals, "")
addSuccess(testLabel, o, c)
c.Check(output.value, Equals, "")
}
}

0 comments on commit 0406dac

Please sign in to comment.