README.md

@@ -21,7 +21,6 @@ type Migrator interface {
 	DriverName() string
 	Setup() error
 	MigrateToStep(step int) error
-	Interceptors() map[int]Interceptor
 	TearDown() error
 }
 
@@ -40,6 +39,7 @@ your assertions:
 ```go
 t.Run("migration should link book 1 with its author", func(t *testing.T) {
 	f := foundation.New(t, migrator).
+		RegisterInterceptors(interceptors).
 		// runs migrations up to and including 5
 		MigrateToStep(5).
 		// loads the SQL of the file
@@ -48,21 +48,14 @@ t.Run("migration should link book 1 with its author", func(t *testing.T) {
 		MigrateToStep(6)
 	defer f.TearDown()
 
-	book := struct{ID int; AuthorID int}{}
+	book := struct{
+		ID int
+		AuthorID int
+	}{}
 
-	err := f.DB().Get(&book, "SELECT id, authorID FROM books")
+	err = f.DB().Get(&book, "SELECT id, authorID FROM books")
 	require.NoError(t, err)
 	require.Equal(t, 1, book.ID)
 	require.Equal(t, 3, book.AuthorID)
 })
-
-t.Run("test specifically the interceptor 6", func(t *testing.T) {
-	f := foundation.New(t, migrator).
-		MigrateToStepSkippingLastInterceptor(6).
-		ExecFile("./myfixtures.sql").
-		RunInterceptor(6)
-	defer f.TearDown()
-
-	// ...
-})
 ```

foundation.go

@@ -22,7 +22,6 @@ type Migrator interface {
 	DriverName() string
 	Setup() error
 	MigrateToStep(step int) error
-	Interceptors() map[int]Interceptor
 	TearDown() error
 }
 
@@ -41,15 +40,12 @@ func New(t *testing.T, migrator Migrator) *Foundation {
 		currentStep: 0,
 		// if true, will run the migrator Step function once per step
 		// instead of just once with the final step
-		stepByStep:   false,
+		stepByStep: false,
-		migrator:     migrator,
+		migrator:   migrator,
-		interceptors: migrator.Interceptors(),
+		db:         db,
-		db:           db,
 	}
 }
 
-// RegisterInterceptors replaced the migrator interceptors with new
-// ones, in case we want to check a special case for a given test
 func (f *Foundation) RegisterInterceptors(interceptors map[int]Interceptor) *Foundation {
 	f.interceptors = interceptors
 	return f
@@ -87,7 +83,7 @@ func (f *Foundation) calculateNextStep(step int) int {
 	return i
 }
 
-func (f *Foundation) migrateToStep(step int, skipLastInterceptor bool) *Foundation {
+func (f *Foundation) MigrateToStep(step int) *Foundation {
 	if step == f.currentStep {
 		// log nothing to do
 		return f
@@ -99,7 +95,7 @@ func (f *Foundation) migrateToStep(step int, skipLastInterceptor bool) *Foundati
 
 	// if there are no interceptors, just migrate to the last step
 	if f.interceptors == nil {
-		if err := f.doMigrateToStep(step); err != nil {
+		if err := f.migrateToStep(step); err != nil {
 			f.t.Fatalf("migration to step %d failed: %s", step, err)
 		}
 
@@ -109,20 +105,14 @@ func (f *Foundation) migrateToStep(step int, skipLastInterceptor bool) *Foundati
 	for f.currentStep < step {
 		nextStep := f.calculateNextStep(step)
 
-		if err := f.doMigrateToStep(nextStep); err != nil {
+		if err := f.migrateToStep(nextStep); err != nil {
 			f.t.Fatalf("migration to step %d failed: %s", nextStep, err)
 		}
 
-		// if we want to skip the last interceptor and we're in the
-		// last step, just continue
-		if skipLastInterceptor && nextStep == step {
-			continue
-		}
-
 		interceptorFn, ok := f.interceptors[nextStep]
 		if ok {
 			if err := interceptorFn(); err != nil {
-				f.t.Fatalf("interceptor function for step %d failed: %s", nextStep, err)
+				f.t.Fatalf("interceptor function for step %d failed", nextStep)
 			}
 		}
 	}
@@ -130,42 +120,11 @@ func (f *Foundation) migrateToStep(step int, skipLastInterceptor bool) *Foundati
 	return f
 }
 
-// MigrateToStep instructs the migrator to move forward until step is
+// migrateToStep executes the migrator function to migrate to a
-// reached. While migrating, it will run the interceptors after the
-// step they're defined for
-func (f *Foundation) MigrateToStep(step int) *Foundation {
-	return f.migrateToStep(step, false)
-}
-
-// MigrateToStepSkippingLastInterceptor instructs the migrator to move
-// forward until step is reached, skipping the last interceptor. This
-// is useful if we want to load fixtures on the last step but before
-// running the interceptor code, so we can check how that data is
-// modified by the interceptor
-func (f *Foundation) MigrateToStepSkippingLastInterceptor(step int) *Foundation {
-	return f.migrateToStep(step, true)
-}
-
-// RunInterceptor executes the code of the interceptor corresponding
-// to step
-func (f *Foundation) RunInterceptor(step int) *Foundation {
-	interceptorFn, ok := f.interceptors[step]
-	if !ok {
-		f.t.Fatalf("no interceptor found for step %d", step)
-	}
-
-	if err := interceptorFn(); err != nil {
-		f.t.Fatalf("interceptor function for step %d failed: %s", step, err)
-	}
-
-	return f
-}
-
-// doMigrateToStep executes the migrator function to migrate to a
 // specific step and updates the foundation currentStep to reflect the
 // result. This function doesn't take into account interceptors, that
 // happens on MigrateToStep
-func (f *Foundation) doMigrateToStep(step int) error {
+func (f *Foundation) migrateToStep(step int) error {
 	if f.stepByStep {
 		for f.currentStep < step {
 			if err := f.migrator.MigrateToStep(f.currentStep + 1); err != nil {