diff --git a/common/database/db_test.go b/common/database/db_test.go
index df6bcd649..fdd273722 100644
--- a/common/database/db_test.go
+++ b/common/database/db_test.go
@@ -1,62 +1,27 @@
-package database
+package database_test
 
 import (
-	"context"
-	"errors"
-	"io"
-	"os"
 	"testing"
-	"time"
 
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/stretchr/testify/assert"
 
-	"scroll-tech/common/docker"
+	"scroll-tech/common/database"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/version"
 )
 
-func TestGormLogger(t *testing.T) {
-	output := io.Writer(os.Stderr)
-	usecolor := (isatty.IsTerminal(os.Stderr.Fd()) || isatty.IsCygwinTerminal(os.Stderr.Fd())) && os.Getenv("TERM") != "dumb"
-	if usecolor {
-		output = colorable.NewColorableStderr()
-	}
-	ostream := log.StreamHandler(output, log.TerminalFormat(usecolor))
-	glogger := log.NewGlogHandler(ostream)
-	// Set log level
-	glogger.Verbosity(log.LvlTrace)
-	log.Root().SetHandler(glogger)
-
-	var gl gormLogger
-	gl.gethLogger = log.Root()
-
-	gl.Error(context.Background(), "test %s error:%v", "testError", errors.New("test error"))
-	gl.Warn(context.Background(), "test %s warn:%v", "testWarn", errors.New("test warn"))
-	gl.Info(context.Background(), "test %s warn:%v", "testInfo", errors.New("test info"))
-	gl.Trace(context.Background(), time.Now(), func() (string, int64) { return "test trace", 1 }, nil)
-}
-
 func TestDB(t *testing.T) {
 	version.Version = "v4.1.98-aaa-bbb-ccc"
-	base := docker.NewDockerApp()
-	base.RunDBImage(t)
 
-	dbCfg := &Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
-	}
+	testApps := testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
 
-	var err error
-	db, err := InitDB(dbCfg)
+	db, err := testApps.GetGormDBClient()
 	assert.NoError(t, err)
 
-	sqlDB, err := Ping(db)
+	sqlDB, err := database.Ping(db)
 	assert.NoError(t, err)
 	assert.NotNil(t, sqlDB)
 
-	assert.NoError(t, CloseDB(db))
+	assert.NoError(t, database.CloseDB(db))
 }
diff --git a/common/database/logger_test.go b/common/database/logger_test.go
new file mode 100644
index 000000000..5440effc0
--- /dev/null
+++ b/common/database/logger_test.go
@@ -0,0 +1,35 @@
+package database
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/mattn/go-colorable"
+	"github.com/mattn/go-isatty"
+	"github.com/scroll-tech/go-ethereum/log"
+)
+
+func TestGormLogger(t *testing.T) {
+	output := io.Writer(os.Stderr)
+	usecolor := (isatty.IsTerminal(os.Stderr.Fd()) || isatty.IsCygwinTerminal(os.Stderr.Fd())) && os.Getenv("TERM") != "dumb"
+	if usecolor {
+		output = colorable.NewColorableStderr()
+	}
+	ostream := log.StreamHandler(output, log.TerminalFormat(usecolor))
+	glogger := log.NewGlogHandler(ostream)
+	// Set log level
+	glogger.Verbosity(log.LvlTrace)
+	log.Root().SetHandler(glogger)
+
+	var gl gormLogger
+	gl.gethLogger = log.Root()
+
+	gl.Error(context.Background(), "test %s error:%v", "testError", errors.New("test error"))
+	gl.Warn(context.Background(), "test %s warn:%v", "testWarn", errors.New("test warn"))
+	gl.Info(context.Background(), "test %s warn:%v", "testInfo", errors.New("test info"))
+	gl.Trace(context.Background(), time.Now(), func() (string, int64) { return "test trace", 1 }, nil)
+}
diff --git a/common/docker/docker_test.go b/common/docker/docker_test.go
index f1f978fff..71412fb48 100644
--- a/common/docker/docker_test.go
+++ b/common/docker/docker_test.go
@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/jmoiron/sqlx"
-	_ "github.com/lib/pq" //nolint:golint
 	"github.com/stretchr/testify/assert"
 
 	"scroll-tech/common/docker"
diff --git a/common/go.mod b/common/go.mod
index 7d241d77d..8a3e74e99 100644
--- a/common/go.mod
+++ b/common/go.mod
@@ -10,7 +10,6 @@ require (
 	github.com/gin-contrib/pprof v1.4.0
 	github.com/gin-gonic/gin v1.9.1
 	github.com/jmoiron/sqlx v1.3.5
-	github.com/lib/pq v1.10.9
 	github.com/mattn/go-colorable v0.1.13
 	github.com/mattn/go-isatty v0.0.20
 	github.com/modern-go/reflect2 v1.0.2
@@ -18,9 +17,9 @@ require (
 	github.com/prometheus/client_golang v1.16.0
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
 	github.com/stretchr/testify v1.9.0
-	github.com/testcontainers/testcontainers-go v0.29.1
-	github.com/testcontainers/testcontainers-go/modules/compose v0.29.1
-	github.com/testcontainers/testcontainers-go/modules/postgres v0.29.1
+	github.com/testcontainers/testcontainers-go v0.28.0
+	github.com/testcontainers/testcontainers-go/modules/compose v0.28.0
+	github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0
 	github.com/urfave/cli/v2 v2.25.7
 	gorm.io/driver/postgres v1.5.0
 	gorm.io/gorm v1.25.5
diff --git a/common/go.sum b/common/go.sum
index 1388b678f..c0cde110c 100644
--- a/common/go.sum
+++ b/common/go.sum
@@ -678,12 +678,12 @@ github.com/supranational/blst v0.3.11-0.20230124161941-ca03e11a3ff2 h1:wh1wzwAhZ
 github.com/supranational/blst v0.3.11-0.20230124161941-ca03e11a3ff2/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
-github.com/testcontainers/testcontainers-go v0.29.1 h1:z8kxdFlovA2y97RWx98v/TQ+tR+SXZm6p35M+xB92zk=
-github.com/testcontainers/testcontainers-go v0.29.1/go.mod h1:SnKnKQav8UcgtKqjp/AD8bE1MqZm+3TDb/B8crE3XnI=
-github.com/testcontainers/testcontainers-go/modules/compose v0.29.1 h1:47ipPM+s+ltCDOP3Sa1j95AkNb+z+WGiHLDbLU8ixuc=
-github.com/testcontainers/testcontainers-go/modules/compose v0.29.1/go.mod h1:Sqh+Ef2ESdbJQjTJl57UOkEHkOc7gXvQLg1b5xh6f1Y=
-github.com/testcontainers/testcontainers-go/modules/postgres v0.29.1 h1:hTn3MzhR9w4btwfzr/NborGCaeNZG0MPBpufeDj10KA=
-github.com/testcontainers/testcontainers-go/modules/postgres v0.29.1/go.mod h1:YsWyy+pHDgvGdi0axGOx6CGXWsE6eqSaApyd1FYYSSc=
+github.com/testcontainers/testcontainers-go v0.28.0 h1:1HLm9qm+J5VikzFDYhOd+Zw12NtOl+8drH2E8nTY1r8=
+github.com/testcontainers/testcontainers-go v0.28.0/go.mod h1:COlDpUXbwW3owtpMkEB1zo9gwb1CoKVKlyrVPejF4AU=
+github.com/testcontainers/testcontainers-go/modules/compose v0.28.0 h1:QOCeTYZIYixg796Ik60MOaeMgpAKPbQd5pJOdTrftyg=
+github.com/testcontainers/testcontainers-go/modules/compose v0.28.0/go.mod h1:lShXm8oldlLck3ltA5u+ShSvUnZ+wiNxwpp8wAQGZ1Y=
+github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0 h1:ff0s4JdYIdNAVSi/SrpN2Pdt1f+IjIw3AKjbHau8Un4=
+github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0/go.mod h1:fXgcYpbyrduNdiz2qRZuYkmvqLnEqsjbQiBNYH1ystI=
 github.com/theupdateframework/notary v0.7.0 h1:QyagRZ7wlSpjT5N2qQAh/pN+DVqgekv4DzbAiAiEL3c=
 github.com/theupdateframework/notary v0.7.0/go.mod h1:c9DRxcmhHmVLDay4/2fUYdISnHqbFDGRSlXPO0AhYWw=
 github.com/tilt-dev/fsnotify v1.4.8-0.20220602155310-fff9c274a375 h1:QB54BJwA6x8QU9nHY3xJSZR2kX9bgpZekRKGkLTmEXA=
diff --git a/common/testcontainers/testcontainers.go b/common/testcontainers/testcontainers.go
index ad34267e7..3bf404db9 100644
--- a/common/testcontainers/testcontainers.go
+++ b/common/testcontainers/testcontainers.go
@@ -10,6 +10,9 @@ import (
 	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/modules/postgres"
 	"github.com/testcontainers/testcontainers-go/wait"
+	"gorm.io/gorm"
+
+	"scroll-tech/common/database"
 )
 
 // TestcontainerApps testcontainers struct
@@ -129,6 +132,21 @@ func (t *TestcontainerApps) GetL2GethEndPoint() (string, error) {
 	return endpoint, nil
 }
 
+// GetGormDBClient returns a gorm.DB by connecting to the running postgres container
+func (t *TestcontainerApps) GetGormDBClient() (*gorm.DB, error) {
+	endpoint, err := t.GetDBEndPoint()
+	if err != nil {
+		return nil, err
+	}
+	dbCfg := &database.Config{
+		DSN:        endpoint,
+		DriverName: "postgres",
+		MaxOpenNum: 200,
+		MaxIdleNum: 20,
+	}
+	return database.InitDB(dbCfg)
+}
+
 // GetL1GethClient returns a ethclient by dialing running L1Geth
 func (t *TestcontainerApps) GetL1GethClient() (*ethclient.Client, error) {
 	endpoint, err := t.GetL1GethEndPoint()
diff --git a/common/testcontainers/testcontainers_test.go b/common/testcontainers/testcontainers_test.go
index dd3549774..58169b00c 100644
--- a/common/testcontainers/testcontainers_test.go
+++ b/common/testcontainers/testcontainers_test.go
@@ -5,14 +5,16 @@ import (
 
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/stretchr/testify/assert"
+	"gorm.io/gorm"
 )
 
 // TestNewTestcontainerApps tests NewTestcontainerApps
 func TestNewTestcontainerApps(t *testing.T) {
 	var (
-		err      error
-		endpoint string
-		client   *ethclient.Client
+		err          error
+		endpoint     string
+		gormDBclient *gorm.DB
+		ethclient    *ethclient.Client
 	)
 
 	// test start testcontainers
@@ -21,22 +23,25 @@ func TestNewTestcontainerApps(t *testing.T) {
 	endpoint, err = testApps.GetDBEndPoint()
 	assert.NoError(t, err)
 	assert.NotEmpty(t, endpoint)
+	gormDBclient, err = testApps.GetGormDBClient()
+	assert.NoError(t, err)
+	assert.NotNil(t, gormDBclient)
 
 	assert.NoError(t, testApps.StartL1GethContainer())
 	endpoint, err = testApps.GetL1GethEndPoint()
 	assert.NoError(t, err)
 	assert.NotEmpty(t, endpoint)
-	client, err = testApps.GetL1GethClient()
+	ethclient, err = testApps.GetL1GethClient()
 	assert.NoError(t, err)
-	assert.NotNil(t, client)
+	assert.NotNil(t, ethclient)
 
 	assert.NoError(t, testApps.StartL2GethContainer())
 	endpoint, err = testApps.GetL2GethEndPoint()
 	assert.NoError(t, err)
 	assert.NotEmpty(t, endpoint)
-	client, err = testApps.GetL2GethClient()
+	ethclient, err = testApps.GetL2GethClient()
 	assert.NoError(t, err)
-	assert.NotNil(t, client)
+	assert.NotNil(t, ethclient)
 
 	// test free testcontainers
 	testApps.Free()
diff --git a/coordinator/cmd/api/app/mock_app.go b/coordinator/cmd/api/app/mock_app.go
index e442ba940..b690592f3 100644
--- a/coordinator/cmd/api/app/mock_app.go
+++ b/coordinator/cmd/api/app/mock_app.go
@@ -12,11 +12,12 @@ import (
 
 	"github.com/scroll-tech/go-ethereum/params"
 
-	coordinatorConfig "scroll-tech/coordinator/internal/config"
-
 	"scroll-tech/common/cmd"
 	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/utils"
+
+	coordinatorConfig "scroll-tech/coordinator/internal/config"
 )
 
 var (
@@ -28,7 +29,7 @@ type CoordinatorApp struct {
 	Config      *coordinatorConfig.Config
 	ChainConfig *params.ChainConfig
 
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	configOriginFile      string
 	chainConfigOriginFile string
@@ -41,13 +42,13 @@ type CoordinatorApp struct {
 }
 
 // NewCoordinatorApp return a new coordinatorApp manager.
-func NewCoordinatorApp(base *docker.App, configFile string, chainConfigFile string) *CoordinatorApp {
-	coordinatorFile := fmt.Sprintf("/tmp/%d_coordinator-config.json", base.Timestamp)
-	genesisFile := fmt.Sprintf("/tmp/%d_genesis.json", base.Timestamp)
+func NewCoordinatorApp(testApps *testcontainers.TestcontainerApps, configFile string, chainConfigFile string) *CoordinatorApp {
+	coordinatorFile := fmt.Sprintf("/tmp/%d_coordinator-config.json", testApps.Timestamp)
+	genesisFile := fmt.Sprintf("/tmp/%d_genesis.json", testApps.Timestamp)
 	port, _ := rand.Int(rand.Reader, big.NewInt(2000))
 	httpPort := port.Int64() + httpStartPort
 	coordinatorApp := &CoordinatorApp{
-		base:                  base,
+		testApps:              testApps,
 		configOriginFile:      configFile,
 		chainConfigOriginFile: chainConfigFile,
 		coordinatorFile:       coordinatorFile,
@@ -82,7 +83,6 @@ func (c *CoordinatorApp) HTTPEndpoint() string {
 
 // MockConfig creates a new coordinator config.
 func (c *CoordinatorApp) MockConfig(store bool) error {
-	base := c.base
 	cfg, err := coordinatorConfig.NewConfig(c.configOriginFile)
 	if err != nil {
 		return err
@@ -97,7 +97,11 @@ func (c *CoordinatorApp) MockConfig(store bool) error {
 		MaxVerifierWorkers:     4,
 		MinProverVersion:       "v1.0.0",
 	}
-	cfg.DB.DSN = base.DBImg.Endpoint()
+	endpoint, err := c.testApps.GetDBEndPoint()
+	if err != nil {
+		return err
+	}
+	cfg.DB.DSN = endpoint
 	cfg.L2.ChainID = 111
 	cfg.Auth.ChallengeExpireDurationSec = 1
 	cfg.Auth.LoginExpireDurationSec = 1
diff --git a/coordinator/internal/orm/orm_test.go b/coordinator/internal/orm/orm_test.go
index ed6f719b7..0fcc84a2f 100644
--- a/coordinator/internal/orm/orm_test.go
+++ b/coordinator/internal/orm/orm_test.go
@@ -9,41 +9,36 @@ import (
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
-
 	"scroll-tech/database/migrate"
 )
 
 var (
-	base *docker.App
-
+	testApps      *testcontainers.TestcontainerApps
 	db            *gorm.DB
 	proverTaskOrm *ProverTask
 )
 
 func TestMain(m *testing.M) {
 	t := &testing.T{}
-	setupEnv(t)
-	defer tearDownEnv(t)
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		tearDownEnv(t)
+	}()
 	m.Run()
 }
 
 func setupEnv(t *testing.T) {
-	base = docker.NewDockerApp()
-	base.RunDBImage(t)
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+
 	var err error
-	db, err = database.InitDB(
-		&database.Config{
-			DSN:        base.DBConfig.DSN,
-			DriverName: base.DBConfig.DriverName,
-			MaxOpenNum: base.DBConfig.MaxOpenNum,
-			MaxIdleNum: base.DBConfig.MaxIdleNum,
-		},
-	)
+	db, err = testApps.GetGormDBClient()
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -56,10 +51,11 @@ func tearDownEnv(t *testing.T) {
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
 	sqlDB.Close()
-	base.Free()
 }
 
 func TestProverTaskOrm(t *testing.T) {
+	setupEnv(t)
+
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
 	assert.NoError(t, migrate.ResetDB(sqlDB))
diff --git a/coordinator/test/api_test.go b/coordinator/test/api_test.go
index c7e3a9810..8eee8918c 100644
--- a/coordinator/test/api_test.go
+++ b/coordinator/test/api_test.go
@@ -21,8 +21,8 @@ import (
 
 	"scroll-tech/database/migrate"
 
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
+	tc "scroll-tech/common/testcontainers"
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/types/message"
@@ -43,10 +43,9 @@ const (
 )
 
 var (
-	dbCfg *database.Config
-	conf  *config.Config
+	conf *config.Config
 
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	db                 *gorm.DB
 	l2BlockOrm         *orm.L2Block
@@ -70,13 +69,12 @@ var (
 )
 
 func TestMain(m *testing.M) {
-	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
-	glogger.Verbosity(log.LvlInfo)
-	log.Root().SetHandler(glogger)
-
-	base = docker.NewDockerApp()
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+	}()
 	m.Run()
-	base.Free()
 }
 
 func randomURL() string {
@@ -86,7 +84,8 @@ func randomURL() string {
 
 func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL string, nameForkMap map[string]int64) (*cron.Collector, *http.Server) {
 	var err error
-	db, err = database.InitDB(dbCfg)
+	db, err = testApps.GetGormDBClient()
+
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -149,20 +148,18 @@ func setupCoordinator(t *testing.T, proversPerSession uint8, coordinatorURL stri
 }
 
 func setEnv(t *testing.T) {
+	var err error
+
 	version.Version = "v4.1.98"
 
-	base = docker.NewDockerApp()
-	base.RunDBImage(t)
+	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.LogfmtFormat()))
+	glogger.Verbosity(log.LvlInfo)
+	log.Root().SetHandler(glogger)
 
-	dbCfg = &database.Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
-	}
+	testApps = tc.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
 
-	var err error
-	db, err = database.InitDB(dbCfg)
+	db, err = testApps.GetGormDBClient()
 	assert.NoError(t, err)
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -199,7 +196,6 @@ func setEnv(t *testing.T) {
 
 func TestApis(t *testing.T) {
 	// Set up the test environment.
-	base = docker.NewDockerApp()
 	setEnv(t)
 
 	t.Run("TestHandshake", testHandshake)
@@ -211,11 +207,6 @@ func TestApis(t *testing.T) {
 	t.Run("TestProofGeneratedFailed", testProofGeneratedFailed)
 	t.Run("TestTimeoutProof", testTimeoutProof)
 	t.Run("TestHardFork", testHardForkAssignTask)
-
-	// Teardown
-	t.Cleanup(func() {
-		base.Free()
-	})
 }
 
 func testHandshake(t *testing.T) {
diff --git a/go.work.sum b/go.work.sum
index d61375f39..880b19a02 100644
--- a/go.work.sum
+++ b/go.work.sum
@@ -1559,6 +1559,9 @@ github.com/tdewolff/parse/v2 v2.6.4 h1:KCkDvNUMof10e3QExio9OPZJT8SbdKojLBumw8YZy
 github.com/tdewolff/parse/v2 v2.6.4/go.mod h1:woz0cgbLwFdtbjJu8PIKxhW05KplTFQkOdX78o+Jgrs=
 github.com/tdewolff/test v1.0.7 h1:8Vs0142DmPFW/bQeHRP3MV19m1gvndjUb1sn8yy74LM=
 github.com/tdewolff/test v1.0.7/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/testcontainers/testcontainers-go v0.28.0/go.mod h1:COlDpUXbwW3owtpMkEB1zo9gwb1CoKVKlyrVPejF4AU=
+github.com/testcontainers/testcontainers-go/modules/compose v0.28.0/go.mod h1:lShXm8oldlLck3ltA5u+ShSvUnZ+wiNxwpp8wAQGZ1Y=
+github.com/testcontainers/testcontainers-go/modules/postgres v0.28.0/go.mod h1:fXgcYpbyrduNdiz2qRZuYkmvqLnEqsjbQiBNYH1ystI=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tinylib/msgp v1.0.2 h1:DfdQrzQa7Yh2es9SuLkixqxuXS2SxsdYn0KbdrOGWD8=
 github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
diff --git a/prover/cmd/app/mock_app.go b/prover/cmd/app/mock_app.go
index a9760be90..a8ed111c7 100644
--- a/prover/cmd/app/mock_app.go
+++ b/prover/cmd/app/mock_app.go
@@ -13,6 +13,7 @@ import (
 
 	"scroll-tech/common/cmd"
 	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types/message"
 	"scroll-tech/common/utils"
 )
@@ -30,7 +31,7 @@ func getIndex() int {
 type ProverApp struct {
 	Config *config.Config
 
-	base *docker.App
+	testApps *testcontainers.TestcontainerApps
 
 	originFile string
 	proverFile string
@@ -43,7 +44,7 @@ type ProverApp struct {
 }
 
 // NewProverApp return a new proverApp manager.
-func NewProverApp(base *docker.App, mockName utils.MockAppName, file string, httpURL string) *ProverApp {
+func NewProverApp(testApps *testcontainers.TestcontainerApps, mockName utils.MockAppName, file string, httpURL string) *ProverApp {
 	var proofType message.ProofType
 	switch mockName {
 	case utils.ChunkProverApp:
@@ -54,12 +55,12 @@ func NewProverApp(base *docker.App, mockName utils.MockAppName, file string, htt
 		return nil
 	}
 	name := string(mockName)
-	proverFile := fmt.Sprintf("/tmp/%d_%s-config.json", base.Timestamp, name)
+	proverFile := fmt.Sprintf("/tmp/%d_%s-config.json", testApps.Timestamp, name)
 	proverApp := &ProverApp{
-		base:       base,
+		testApps:   testApps,
 		originFile: file,
 		proverFile: proverFile,
-		bboltDB:    fmt.Sprintf("/tmp/%d_%s_bbolt_db", base.Timestamp, name),
+		bboltDB:    fmt.Sprintf("/tmp/%d_%s_bbolt_db", testApps.Timestamp, name),
 		index:      getIndex(),
 		name:       name,
 		args:       []string{"--log.debug", "--config", proverFile},
@@ -93,8 +94,13 @@ func (r *ProverApp) MockConfig(store bool, httpURL string, proofType message.Pro
 		return err
 	}
 	cfg.ProverName = fmt.Sprintf("%s_%d", r.name, r.index)
-	cfg.KeystorePath = fmt.Sprintf("/tmp/%d_%s.json", r.base.Timestamp, cfg.ProverName)
-	cfg.L2Geth.Endpoint = r.base.L2gethImg.Endpoint()
+	cfg.KeystorePath = fmt.Sprintf("/tmp/%d_%s.json", r.testApps.Timestamp, cfg.ProverName)
+
+	endpoint, err := r.testApps.GetL2GethEndPoint()
+	if err != nil {
+		return err
+	}
+	cfg.L2Geth.Endpoint = endpoint
 	cfg.L2Geth.Confirmations = rpc.LatestBlockNumber
 	// Reuse l1geth's keystore file
 	cfg.KeystorePassword = "scrolltest"
diff --git a/rollup/cmd/mock_app.go b/rollup/cmd/mock_app.go
index 8b81d6611..472c91c2f 100644
--- a/rollup/cmd/mock_app.go
+++ b/rollup/cmd/mock_app.go
@@ -17,9 +17,7 @@ import (
 
 // MockApp mockApp-test client manager.
 type MockApp struct {
-	Config *config.Config
-	// TODO field willl be replaced by testApps
-	base     *docker.App
+	Config   *config.Config
 	testApps *testcontainers.TestcontainerApps
 
 	mockApps map[utils.MockAppName]docker.AppAPI
@@ -30,24 +28,8 @@ type MockApp struct {
 	args []string
 }
 
-// NewRollupApp TODO function will be replaced by NewRollupApp2
-func NewRollupApp(base *docker.App, file string) *MockApp {
-	rollupFile := fmt.Sprintf("/tmp/%d_rollup-config.json", base.Timestamp)
-	rollupApp := &MockApp{
-		base:       base,
-		mockApps:   make(map[utils.MockAppName]docker.AppAPI),
-		originFile: file,
-		rollupFile: rollupFile,
-		args:       []string{"--log.debug", "--config", rollupFile},
-	}
-	if err := rollupApp.MockConfig(true); err != nil {
-		panic(err)
-	}
-	return rollupApp
-}
-
-// NewRollupApp2 return a new rollupApp manager, name mush be one them.
-func NewRollupApp2(testApps *testcontainers.TestcontainerApps, file string) *MockApp {
+// NewRollupApp return a new rollupApp manager.
+func NewRollupApp(testApps *testcontainers.TestcontainerApps, file string) *MockApp {
 	rollupFile := fmt.Sprintf("/tmp/%d_rollup-config.json", testApps.Timestamp)
 	rollupApp := &MockApp{
 		testApps:   testApps,
@@ -56,7 +38,7 @@ func NewRollupApp2(testApps *testcontainers.TestcontainerApps, file string) *Moc
 		rollupFile: rollupFile,
 		args:       []string{"--log.debug", "--config", rollupFile},
 	}
-	if err := rollupApp.MockConfig2(true); err != nil {
+	if err := rollupApp.MockConfig(true); err != nil {
 		panic(err)
 	}
 	return rollupApp
@@ -96,35 +78,8 @@ func (b *MockApp) Free() {
 	_ = os.Remove(b.rollupFile)
 }
 
-// MockConfig TODO function will be replaced by MockConfig2
+// MockConfig creates a new rollup config.
 func (b *MockApp) MockConfig(store bool) error {
-	base := b.base
-	// Load origin rollup config file.
-	cfg, err := config.NewConfig(b.originFile)
-	if err != nil {
-		return err
-	}
-
-	cfg.L1Config.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L2gethImg.Endpoint()
-	cfg.L2Config.Endpoint = base.L2gethImg.Endpoint()
-	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
-	cfg.DBConfig.DSN = base.DBImg.Endpoint()
-	b.Config = cfg
-
-	if !store {
-		return nil
-	}
-	// Store changed rollup config into a temp file.
-	data, err := json.Marshal(b.Config)
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(b.rollupFile, data, 0600)
-}
-
-// MockConfig2 creates a new rollup config.
-func (b *MockApp) MockConfig2(store bool) error {
 	// Load origin rollup config file.
 	cfg, err := config.NewConfig(b.originFile)
 	if err != nil {
diff --git a/rollup/tests/bridge_test.go b/rollup/tests/bridge_test.go
index f20450510..c1e766457 100644
--- a/rollup/tests/bridge_test.go
+++ b/rollup/tests/bridge_test.go
@@ -97,7 +97,7 @@ func setupEnv(t *testing.T) {
 	assert.NoError(t, testApps.StartPostgresContainer())
 	assert.NoError(t, testApps.StartL1GethContainer())
 	assert.NoError(t, testApps.StartL2GethContainer())
-	rollupApp = bcmd.NewRollupApp2(testApps, "../conf/config.json")
+	rollupApp = bcmd.NewRollupApp(testApps, "../conf/config.json")
 
 	l1Client, err = posL1TestEnv.L1Client()
 	assert.NoError(t, err)
diff --git a/tests/integration-test/contracts_test.go b/tests/integration-test/contracts_test.go
index 3d1be7d4f..40fbbaa55 100644
--- a/tests/integration-test/contracts_test.go
+++ b/tests/integration-test/contracts_test.go
@@ -20,11 +20,11 @@ var (
 	greeterAddress = common.HexToAddress("0x7363726f6c6c6c20000000000000000000000015")
 )
 
-func TestERC20(t *testing.T) {
-	base.RunL2Geth(t)
+func testERC20(t *testing.T) {
+	assert.NoError(t, testApps.StartL2GethContainer())
 	time.Sleep(time.Second * 3)
 
-	l2Cli, err := base.L2Client()
+	l2Cli, err := testApps.GetL2GethClient()
 	assert.Nil(t, err)
 
 	token, err := erc20.NewERC20Mock(erc20Address, l2Cli)
@@ -32,7 +32,9 @@ func TestERC20(t *testing.T) {
 	privKey, err := crypto.ToECDSA(common.FromHex("1212121212121212121212121212121212121212121212121212121212121212"))
 	assert.NoError(t, err)
 
-	auth, err := bind.NewKeyedTransactorWithChainID(privKey, base.L2gethImg.ChainID())
+	chainID, err := l2Cli.ChainID(context.Background())
+	assert.NoError(t, err)
+	auth, err := bind.NewKeyedTransactorWithChainID(privKey, chainID)
 	assert.NoError(t, err)
 
 	authBls0, err := token.BalanceOf(nil, auth.From)
@@ -45,7 +47,8 @@ func TestERC20(t *testing.T) {
 	value := big.NewInt(1000)
 	tx, err := token.Transfer(auth, erc20Address, value)
 	assert.NoError(t, err)
-	bind.WaitMined(context.Background(), l2Cli, tx)
+	_, err = bind.WaitMined(context.Background(), l2Cli, tx)
+	assert.NoError(t, err)
 
 	authBls1, err := token.BalanceOf(nil, auth.From)
 	assert.NoError(t, err)
@@ -58,12 +61,14 @@ func TestERC20(t *testing.T) {
 	assert.Equal(t, tokenBls1.Int64(), tokenBls0.Add(tokenBls0, value).Int64())
 }
 
-func TestGreeter(t *testing.T) {
-	base.RunL2Geth(t)
-	l2Cli, err := base.L2Client()
+func testGreeter(t *testing.T) {
+	assert.NoError(t, testApps.StartL2GethContainer())
+	l2Cli, err := testApps.GetL2GethClient()
 	assert.Nil(t, err)
 
-	auth, err := bind.NewKeyedTransactorWithChainID(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey, base.L2gethImg.ChainID())
+	chainID, err := l2Cli.ChainID(context.Background())
+	assert.NoError(t, err)
+	auth, err := bind.NewKeyedTransactorWithChainID(rollupApp.Config.L2Config.RelayerConfig.CommitSenderPrivateKey, chainID)
 	assert.NoError(t, err)
 
 	token, err := greeter.NewGreeter(greeterAddress, l2Cli)
diff --git a/tests/integration-test/integration_test.go b/tests/integration-test/integration_test.go
index baa44cceb..a62749934 100644
--- a/tests/integration-test/integration_test.go
+++ b/tests/integration-test/integration_test.go
@@ -10,52 +10,63 @@ import (
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/stretchr/testify/assert"
+	"gorm.io/gorm"
 
-	"scroll-tech/integration-test/orm"
-
-	rapp "scroll-tech/prover/cmd/app"
-
-	"scroll-tech/database/migrate"
-
-	capp "scroll-tech/coordinator/cmd/api/app"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/docker"
+	"scroll-tech/common/testcontainers"
 	"scroll-tech/common/types/encoding"
 	"scroll-tech/common/utils"
 	"scroll-tech/common/version"
-
+	capp "scroll-tech/coordinator/cmd/api/app"
+	"scroll-tech/database/migrate"
+	"scroll-tech/integration-test/orm"
+	rapp "scroll-tech/prover/cmd/app"
 	bcmd "scroll-tech/rollup/cmd"
 )
 
 var (
-	base      *docker.App
+	testApps  *testcontainers.TestcontainerApps
 	rollupApp *bcmd.MockApp
 )
 
 func TestMain(m *testing.M) {
-	base = docker.NewDockerApp()
-	rollupApp = bcmd.NewRollupApp(base, "../../rollup/conf/config.json")
+	defer func() {
+		if testApps != nil {
+			testApps.Free()
+		}
+		if rollupApp != nil {
+			rollupApp.Free()
+		}
+	}()
 	m.Run()
-	rollupApp.Free()
-	base.Free()
 }
 
-func TestCoordinatorProverInteraction(t *testing.T) {
-	// Start postgres docker containers
-	base.RunL2Geth(t)
-	base.RunDBImage(t)
+func setupEnv(t *testing.T) {
+	testApps = testcontainers.NewTestcontainerApps()
+	assert.NoError(t, testApps.StartPostgresContainer())
+	assert.NoError(t, testApps.StartL1GethContainer())
+	assert.NoError(t, testApps.StartL2GethContainer())
+	rollupApp = bcmd.NewRollupApp(testApps, "../../rollup/conf/config.json")
+}
 
-	// Init data
-	dbCfg := &database.Config{
-		DSN:        base.DBConfig.DSN,
-		DriverName: base.DBConfig.DriverName,
-		MaxOpenNum: base.DBConfig.MaxOpenNum,
-		MaxIdleNum: base.DBConfig.MaxIdleNum,
-	}
+func TestFunction(t *testing.T) {
+	setupEnv(t)
+	t.Run("TestCoordinatorProverInteraction", testCoordinatorProverInteraction)
+	t.Run("TestProverReLogin", testProverReLogin)
+	t.Run("TestERC20", testERC20)
+	t.Run("TestGreeter", testGreeter)
+}
 
-	db, err := database.InitDB(dbCfg)
+func setupDB(t *testing.T) *gorm.DB {
+	db, err := testApps.GetGormDBClient()
 	assert.NoError(t, err)
+	sqlDB, err := db.DB()
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(sqlDB))
+	return db
+}
+
+func testCoordinatorProverInteraction(t *testing.T) {
+	db := setupDB(t)
 
 	sqlDB, err := db.DB()
 	assert.NoError(t, err)
@@ -66,7 +77,7 @@ func TestCoordinatorProverInteraction(t *testing.T) {
 	l2BlockOrm := orm.NewL2Block(db)
 
 	// Connect to l2geth client
-	l2Client, err := base.L2Client()
+	l2Client, err := testApps.GetL2GethClient()
 	if err != nil {
 		log.Fatalf("Failed to connect to the l2geth client: %v", err)
 	}
@@ -111,10 +122,9 @@ func TestCoordinatorProverInteraction(t *testing.T) {
 	assert.NoError(t, err)
 	t.Log(version.Version)
 
-	base.Timestamp = time.Now().Nanosecond()
-	coordinatorApp := capp.NewCoordinatorApp(base, "../../coordinator/conf/config.json", "./genesis.json")
-	chunkProverApp := rapp.NewProverApp(base, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
-	batchProverApp := rapp.NewProverApp(base, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	coordinatorApp := capp.NewCoordinatorApp(testApps, "../../coordinator/conf/config.json", "./genesis.json")
+	chunkProverApp := rapp.NewProverApp(testApps, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	batchProverApp := rapp.NewProverApp(testApps, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
 	defer coordinatorApp.Free()
 	defer chunkProverApp.Free()
 	defer batchProverApp.Free()
@@ -139,17 +149,16 @@ func TestCoordinatorProverInteraction(t *testing.T) {
 	coordinatorApp.WaitExit()
 }
 
-func TestProverReLogin(t *testing.T) {
-	// Start postgres docker containers.
-	base.RunL2Geth(t)
-	base.RunDBImage(t)
+func testProverReLogin(t *testing.T) {
+	client, err := testApps.GetGormDBClient()
+	assert.NoError(t, err)
+	db, err := client.DB()
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(db))
 
-	assert.NoError(t, migrate.ResetDB(base.DBClient(t)))
-
-	base.Timestamp = time.Now().Nanosecond()
-	coordinatorApp := capp.NewCoordinatorApp(base, "../../coordinator/conf/config.json", "./genesis.json")
-	chunkProverApp := rapp.NewProverApp(base, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
-	batchProverApp := rapp.NewProverApp(base, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	coordinatorApp := capp.NewCoordinatorApp(testApps, "../../coordinator/conf/config.json", "./genesis.json")
+	chunkProverApp := rapp.NewProverApp(testApps, utils.ChunkProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
+	batchProverApp := rapp.NewProverApp(testApps, utils.BatchProverApp, "../../prover/config.json", coordinatorApp.HTTPEndpoint())
 	defer coordinatorApp.Free()
 	defer chunkProverApp.Free()
 	defer batchProverApp.Free()