isolate test cases (#12)

* chore: go mod

* feat: add db truncator

* feat:
- truncate db after test case
- log response body

* feat: run setup funcs before test case

* feat:
- add Name to SetupTestCase
- add Setup to TestCase

* feat: add name to test case

* feat:
- remove Position field
- fix tests

* fix: catch unknown setups

* fix:
- add Truncator mock
- add NewVariableMap

* fix: inject idFn

* fix: add test cases to TestExecutor_ExecuteTestCase

* fix: report error with test case name

Author: danvixent

case.go

@@ -1,13 +1,13 @@
 package immune
 
 type SetupTestCase struct {
+	Name                   string `json:"name"`
 	StoreResponseVariables S      `json:"store_response_variables"`
 	RequestBody            M      `json:"request_body"`
 	ResponseBody           bool   `json:"response_body"`
 	Endpoint               string `json:"endpoint"`
 	HTTPMethod             Method `json:"http_method"`
 	StatusCode             int    `json:"status_code"`
-	Position               int    `json:"-"`
 	//Report                 *SetupTestCaseReport `json:"-"`
 }
 
@@ -17,7 +17,8 @@ type SetupTestCaseReport struct {
 }
 
 type TestCase struct {
-	Position     int      `json:"-"`
+	Name         string   `json:"name"`
+	Setup        []string `json:"setup"`
 	StatusCode   int      `json:"status_code"`
 	HTTPMethod   Method   `json:"http_method"`
 	Endpoint     string   `json:"endpoint"`

database.go

@@ -0,0 +1,6 @@
+package immune
+
+type Database struct {
+	Type string `json:"type"`
+	Dsn  string `json:"dsn"`
+}

database/mongo/truncate.go

@@ -0,0 +1,39 @@
+package mongo
+
+import (
+	"context"
+	"net/url"
+	"strings"
+	"time"
+
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type Truncator struct {
+	db *mongo.Database
+}
+
+func NewTruncator(dsn string) (*Truncator, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	client, err := mongo.Connect(ctx, options.Client().ApplyURI(dsn))
+	if err != nil {
+		return nil, err
+	}
+
+	u, err := url.Parse(dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	dbName := strings.TrimPrefix(u.Path, "/")
+	conn := client.Database(dbName, nil)
+
+	return &Truncator{db: conn}, err
+}
+
+func (t *Truncator) Truncate(ctx context.Context) error {
+	return t.db.Drop(ctx)
+}

database/noop/noop_truncator.go

@@ -0,0 +1,13 @@
+package noop
+
+import "context"
+
+type Truncator struct{}
+
+func NewTruncator() (*Truncator, error) {
+	return &Truncator{}, nil
+}
+
+func (t *Truncator) Truncate(ctx context.Context) error {
+	return nil
+}

database/truncator.go

@@ -0,0 +1,23 @@
+package database
+
+import (
+	"context"
+
+	"github.com/frain-dev/immune/database/noop"
+
+	"github.com/frain-dev/immune"
+	"github.com/frain-dev/immune/database/mongo"
+)
+
+type Truncator interface {
+	Truncate(ctx context.Context) error
+}
+
+func NewTruncator(db *immune.Database) (Truncator, error) {
+	switch db.Type {
+	case "mongo":
+		return mongo.NewTruncator(db.Dsn)
+	default:
+		return noop.NewTruncator()
+	}
+}

exec/net.go renamed to exec/executor.go

@@ -10,8 +10,8 @@ import (
 	"time"
 
 	"github.com/frain-dev/immune"
+	"github.com/frain-dev/immune/database"
 	"github.com/frain-dev/immune/url"
-	"github.com/google/uuid"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 )
@@ -21,17 +21,28 @@ type Executor struct {
 	callbackIDLocation     string
 	baseURL                string
 	maxCallbackWaitSeconds uint
-	s                      immune.CallbackServer
+	idFn                   func() string
 	client                 *http.Client
+	dbTruncator            database.Truncator
 	vm                     *immune.VariableMap
+	s                      immune.CallbackServer
 }
 
-func NewExecutor(s immune.CallbackServer, client *http.Client, vm *immune.VariableMap, maxCallbackWaitSeconds uint, baseURL string, callbackIDLocation string) *Executor {
+func NewExecutor(
+	s immune.CallbackServer,
+	client *http.Client,
+	vm *immune.VariableMap,
+	maxCallbackWaitSeconds uint,
+	baseURL string,
+	callbackIDLocation string,
+	dbTruncator database.Truncator, idFn func() string) *Executor {
 	return &Executor{
 		s:                      s,
 		vm:                     vm,
+		idFn:                   idFn,
 		client:                 client,
 		baseURL:                baseURL,
+		dbTruncator:            dbTruncator,
 		callbackIDLocation:     callbackIDLocation,
 		maxCallbackWaitSeconds: maxCallbackWaitSeconds,
 	}
@@ -41,12 +52,12 @@ func NewExecutor(s immune.CallbackServer, client *http.Client, vm *immune.Variab
 func (ex *Executor) ExecuteSetupTestCase(ctx context.Context, setupTC *immune.SetupTestCase) error {
 	u, err := url.Parse(fmt.Sprintf("%s%s", ex.baseURL, setupTC.Endpoint))
 	if err != nil {
-		return errors.Wrapf(err, "setup_test_case %d: failed to parse url", setupTC.Position)
+		return errors.Wrapf(err, "setup_test_case %s: failed to parse url", setupTC.Name)
 	}
 
 	result, err := u.ProcessWithVariableMap(ex.vm)
 	if err != nil {
-		return errors.Wrapf(err, "setup_test_case %d: failed to process parsed url with variable map", setupTC.Position)
+		return errors.Wrapf(err, "setup_test_case %s: failed to process parsed url with variable map", setupTC.Name)
 	}
 
 	r := &request{
@@ -58,39 +69,39 @@ func (ex *Executor) ExecuteSetupTestCase(ctx context.Context, setupTC *immune.Se
 
 	err = r.processWithVariableMap(ex.vm)
 	if err != nil {
-		return errors.Wrapf(err, "setup_test_case %d: failed to process request body with variable map", setupTC.Position)
+		return errors.Wrapf(err, "setup_test_case %s: failed to process request body with variable map", setupTC.Name)
 	}
-	//log.Infof("setup_test_case %d: request body: %s", setupTC.Position, pretty.Sprint(r.body))
+	//log.Infof("setup_test_case %s: request body: %s", setupTC.Name, pretty.Sprint(r.body))
 
 	resp, err := ex.sendRequest(ctx, r)
 	if err != nil {
 		return err
 	}
 
 	if setupTC.StatusCode != resp.statusCode {
-		return errors.Errorf("setup_test_case %d: wants status code %d but got status code %d", setupTC.Position, setupTC.StatusCode, resp.statusCode)
+		return errors.Errorf("setup_test_case %s: wants status code %d but got status code %d, response body: %s", setupTC.Name, setupTC.StatusCode, resp.statusCode, resp.body.String())
 	}
 
 	if setupTC.ResponseBody {
 		if resp.body.Len() == 0 {
-			return errors.Errorf("setup_test_case %d: wants response body but got no response body", setupTC.Position)
+			return errors.Errorf("setup_test_case %s: wants response body but got no response body", setupTC.Name)
 		}
 
 		m := immune.M{}
 		err = resp.Decode(&m)
 		if err != nil {
-			return errors.Wrapf(err, "setup_test_case %d: failed to decode response body", setupTC.Position)
+			return errors.Wrapf(err, "setup_test_case %s: failed to decode response body: response body: %s", setupTC.Name, resp.body.String())
 		}
 
 		if setupTC.StoreResponseVariables != nil {
 			err = ex.vm.ProcessResponse(ctx, setupTC.StoreResponseVariables, m)
 			if err != nil {
-				return errors.Wrapf(err, "setup_test_case %d: failed to process response body", setupTC.Position)
+				return errors.Wrapf(err, "setup_test_case %s: failed to process response body: response body: %s", setupTC.Name, resp.body.String())
 			}
 		}
 	} else {
 		if resp.body.Len() > 0 {
-			return errors.Errorf("setup_test_case %d: does not want a response body but got a response body: '%s'", setupTC.Position, resp.body.String())
+			return errors.Errorf("setup_test_case %s: does not want a response body but got a response body: '%s'", setupTC.Name, resp.body.String())
 		}
 	}
 
@@ -101,20 +112,20 @@ func (ex *Executor) ExecuteSetupTestCase(ctx context.Context, setupTC *immune.Se
 func (ex *Executor) ExecuteTestCase(ctx context.Context, tc *immune.TestCase) error {
 	u, err := url.Parse(fmt.Sprintf("%s%s", ex.baseURL, tc.Endpoint))
 	if err != nil {
-		return errors.Wrapf(err, "test_case %d: failed to parse url", tc.Position)
+		return errors.Wrapf(err, "test_case %s: failed to parse url", tc.Name)
 	}
 
 	result, err := u.ProcessWithVariableMap(ex.vm)
 	if err != nil {
-		return errors.Wrapf(err, "test_case %d: failed to process parsed url with variable map", tc.Position)
+		return errors.Wrapf(err, "test_case %s: failed to process parsed url with variable map", tc.Name)
 	}
 
 	var uid string
 	if tc.Callback.Enabled {
-		uid = uuid.New().String()
+		uid = ex.idFn()
 		err = immune.InjectCallbackID(ex.callbackIDLocation, uid, tc.RequestBody)
 		if err != nil {
-			return errors.Wrapf(err, "test_case %d: failed to inject callback id into request body", tc.Position)
+			return errors.Wrapf(err, "test_case %s: failed to inject callback id into request body", tc.Name)
 		}
 	}
 
@@ -127,7 +138,7 @@ func (ex *Executor) ExecuteTestCase(ctx context.Context, tc *immune.TestCase) er
 
 	err = r.processWithVariableMap(ex.vm)
 	if err != nil {
-		return errors.Wrapf(err, "test_case %d: failed to process request body with variable map", tc.Position)
+		return errors.Wrapf(err, "test_case %s: failed to process request body with variable map", tc.Name)
 	}
 
 	resp, err := ex.sendRequest(ctx, r)
@@ -136,23 +147,23 @@ func (ex *Executor) ExecuteTestCase(ctx context.Context, tc *immune.TestCase) er
 	}
 
 	if tc.StatusCode != resp.statusCode {
-		return errors.Errorf("test_case %d: wants status code %d but got status code %d", tc.Position, tc.StatusCode, resp.statusCode)
+		return errors.Errorf("test_case %s: wants status code %d but got status code %d", tc.Name, tc.StatusCode, resp.statusCode)
 	}
 
 	if tc.ResponseBody {
 		if resp.body.Len() == 0 {
-			return errors.Errorf("test_case %d: wants response body but got no response body: %+v", tc.Position, resp)
+			return errors.Errorf("test_case %s: wants response body but got no response body: status_code: %d", tc.Name, resp.statusCode)
 		}
 
 		m := immune.M{}
 		err = resp.Decode(&m)
 		if err != nil {
-			return errors.Errorf("test_case %d: failed to decode response body: %+v", tc.Position, resp)
+			return errors.Wrapf(err, "test_case %s: failed to decode response body: %s", tc.Name, string(resp.buf))
 		}
 
 	} else {
 		if resp.body.Len() > 0 {
-			return errors.Wrapf(err, "test_case %d: does not want a response body but got a response body: '%s'", tc.Position, resp.body.String())
+			return errors.Errorf("test_case %s: does not want a response body but got a response body: '%s'", tc.Name, resp.body.String())
 		}
 	}
 
@@ -163,19 +174,19 @@ func (ex *Executor) ExecuteTestCase(ctx context.Context, tc *immune.TestCase) er
 		for i := uint(1); i <= tc.Callback.Times; i++ {
 			select {
 			case <-cctx.Done():
-				log.Infof("succesfully received %d callbacks for test_case %d before max callback wait seconds elapsed", i, tc.Position)
+				log.Infof("succesfully received %d callbacks for test_case %s before max callback wait seconds elapsed", i, tc.Name)
 				break
 			default:
 				sig := ex.s.ReceiveCallback()
 				if sig.ImmuneCallBackID != uid {
-					return errors.Errorf("test_case %d: incorrect callback_id: expected_callback_id '%s', got_callback_id '%s'", tc.Position, uid, sig.ImmuneCallBackID)
+					return errors.Errorf("test_case %s: incorrect callback_id: expected_callback_id '%s', got_callback_id '%s'", tc.Name, uid, sig.ImmuneCallBackID)
 				}
-				log.Infof("callback %d for test_case %d received", i, tc.Position)
+				log.Infof("callback %d for test_case %s received", i, tc.Name)
 			}
 		}
 	}
 
-	return nil
+	return ex.dbTruncator.Truncate(ctx)
 }
 
 func (ex *Executor) sendRequest(ctx context.Context, r *request) (*response, error) {
@@ -202,5 +213,5 @@ func (ex *Executor) sendRequest(ctx context.Context, r *request) (*response, err
 		return nil, err
 	}
 
-	return &response{body: bytes.NewBuffer(buf), statusCode: resp.StatusCode}, nil
+	return &response{body: bytes.NewBuffer(buf), buf: buf, statusCode: resp.StatusCode}, nil
 }