change mind on panic recovery

Author: technoweenie

README.md

@@ -46,15 +46,20 @@ Write a `Use` callback around the code's original behavior, and a `Try` around t
 * Randomizes the order in which `Use` and `Try` callbacks are run,
 * Measures the durations of all behaviors,
 * Compares the result of `Try` to the result of `Use`,
-* Swallows (but records) any errors or panics in the `Try` callback, and
+* Swallows (but records) any errors in the `Try` callback, and
 * Publishes all this information.
 
 The `Use` callback is called the **control**. The `Try` callback is called the **candidate**.
 
-NOTE: mention helpers like scientist.Bool()
+TODO: mention helpers like scientist.Bool()
 
 If you don't declare any `Try` callbacks, none of the Scientist machinery is invoked and the control value is always returned.
 
+Experiments do not attempt to recover from any runtime panics, and are not
+goroutine safe. Any `*scientist.Experiment` objects should be Run and discarded
+immediately after being initialized. Ideally, your application should already
+handle any runtime panics somehow.
+
 ## Making science useful
 
 The examples above will run, but they're not really *doing* anything. The `Try` callbacks run every time and none of the results get published. Replace the default experiment implementation to control execution and reporting:

experiment.go

@@ -106,7 +106,7 @@ func (e *Experiment) RunBehavior(name string) (interface{}, error) {
 		return nil, behaviorNotFound(e, name)
 	}
 
-	return runBehavior(e, name, behavior)
+	return behavior()
 }
 
 func (e *Experiment) resultErr(name string, err error) ResultError {

experiment_test.go

@@ -1,7 +1,6 @@
 package scientist
 
 import (
-	"errors"
 	"fmt"
 	"testing"
 )
@@ -282,69 +281,3 @@ func TestExperimentRunIfError(t *testing.T) {
 		t.Errorf("result errors never reported!")
 	}
 }
-
-type testStringer struct {
-	output string
-}
-
-func (s testStringer) String() string {
-	return s.output
-}
-
-func TestRecoverCandidatePanic(t *testing.T) {
-	e := New("recover")
-	e.Use(func() (interface{}, error) {
-		return 1, nil
-	})
-
-	e.Try(func() (interface{}, error) {
-		panic("candidate")
-	})
-
-	e.Behavior("two", func() (interface{}, error) {
-		panic(errors.New("candidate"))
-	})
-
-	e.Behavior("three", func() (interface{}, error) {
-		panic(testStringer{"candidate"})
-	})
-
-	e.ReportErrors(func(errors ...ResultError) {
-		for _, e := range errors {
-			t.Errorf("unexpected experiment error: %v", e)
-		}
-	})
-
-	published := false
-	e.Publish(func(r Result) error {
-		published = true
-		for _, c := range r.Candidates {
-			if c.Value != nil {
-				t.Errorf("Unexpected candidate %q value: %v", c.Name, c.Value)
-			}
-
-			if c.Err == nil {
-				t.Errorf("expected candidate %q panic err!", c.Name)
-			}
-
-			if msg := c.Err.Error(); msg != "candidate" {
-				t.Errorf("bad candidate %q error: %v", c.Name, msg)
-			}
-		}
-
-		return nil
-	})
-
-	v, err := e.Run()
-	if v != 1 {
-		t.Errorf("Unexpected control value: %d", v)
-	}
-
-	if err != nil {
-		t.Errorf("Unexpected control error: %v", err)
-	}
-
-	if !published {
-		t.Errorf("results never published")
-	}
-}

scientist.go

@@ -1,7 +1,6 @@
 package scientist
 
 import (
-	"errors"
 	"fmt"
 	"time"
 )
@@ -160,7 +159,7 @@ func observe(e *Experiment, name string, b behaviorFunc) *Observation {
 		o.Runtime = time.Since(o.Started)
 		o.Err = behaviorNotFound(e, name)
 	} else {
-		v, err := runBehavior(e, name, b)
+		v, err := b()
 		o.Runtime = time.Since(o.Started)
 		o.Value = v
 		o.Err = err
@@ -169,24 +168,6 @@ func observe(e *Experiment, name string, b behaviorFunc) *Observation {
 	return o
 }
 
-func runBehavior(e *Experiment, name string, b behaviorFunc) (value interface{}, err error) {
-	defer func() {
-		if er := recover(); er != nil {
-			value = nil
-			switch t := er.(type) {
-			case string:
-				err = errors.New(t)
-			case error:
-				err = t
-			default:
-				err = fmt.Errorf("%v", t)
-			}
-		}
-	}()
-	value, err = b()
-	return
-}
-
 type ResultError struct {
 	Operation  string
 	Experiment string