add test

database/db/db.go

@@ -24,7 +24,7 @@ type DB struct {
 }
 
 func NewDB(ctx context.Context, config config.Config, driver contractsdriver.Driver, log log.Log, builder db.Builder) *DB {
-	return &DB{ctx: ctx, config: config, driver: driver, log: log, builder: builder}
+	return &DB{ctx: ctx, config: config, driver: driver, log: log, builder: builder, queries: make(map[string]db.DB)}
 }
 
 func BuildDB(ctx context.Context, config config.Config, log log.Log, connection string) (*DB, error) {
@@ -54,7 +54,8 @@ func (r *DB) Connection(name string) db.DB {
 	if _, ok := r.queries[name]; !ok {
 		db, err := BuildDB(r.ctx, r.config, r.log, name)
 		if err != nil {
-			panic(err)
+			r.log.Panic(err.Error())
+			return nil
 		}
 		r.queries[name] = db
 		db.queries = r.queries

database/db/db_test.go

@@ -8,10 +8,12 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/goravel/framework/contracts/database"
+	contractsdb "github.com/goravel/framework/contracts/database/db"
 	contractsdriver "github.com/goravel/framework/contracts/database/driver"
 	"github.com/goravel/framework/errors"
 	mocksconfig "github.com/goravel/framework/mocks/config"
 	mocksdriver "github.com/goravel/framework/mocks/database/driver"
+	mockslog "github.com/goravel/framework/mocks/log"
 )
 
 func TestBuildDB(t *testing.T) {
@@ -36,8 +38,6 @@ func TestBuildDB(t *testing.T) {
 				mockConfig.EXPECT().Get("database.connections.mysql.via").Return(driverCallback).Once()
 				mockDriver.EXPECT().DB().Return(&sql.DB{}, nil).Once()
 				mockDriver.EXPECT().Config().Return(database.Config{Driver: "mysql"}).Once()
-				mockConfig.EXPECT().GetBool("app.debug").Return(false).Once()
-				mockConfig.EXPECT().GetInt("database.slow_threshold", 200).Return(200).Once()
 			},
 			expectedError: nil,
 		},
@@ -68,3 +68,92 @@ func TestBuildDB(t *testing.T) {
 		})
 	}
 }
+
+func TestConnection(t *testing.T) {
+	var (
+		mockConfig *mocksconfig.Config
+		mockDriver *mocksdriver.Driver
+		mockLog    *mockslog.Log
+	)
+
+	tests := []struct {
+		name          string
+		connection    string
+		setup         func(*DB)
+		expectedPanic bool
+	}{
+		{
+			name:       "Success with empty connection name",
+			connection: "",
+			setup: func(db *DB) {
+				mockConfig.EXPECT().GetString("database.default").Return("mysql").Once()
+				driverCallback := func() (contractsdriver.Driver, error) {
+					return mockDriver, nil
+				}
+				mockConfig.EXPECT().Get("database.connections.mysql.via").Return(driverCallback).Once()
+				mockDriver.EXPECT().DB().Return(&sql.DB{}, nil).Once()
+				mockDriver.EXPECT().Config().Return(database.Config{Driver: "mysql"}).Once()
+			},
+			expectedPanic: false,
+		},
+		{
+			name:       "Success with specific connection",
+			connection: "postgres",
+			setup: func(db *DB) {
+				driverCallback := func() (contractsdriver.Driver, error) {
+					return mockDriver, nil
+				}
+				mockConfig.EXPECT().Get("database.connections.postgres.via").Return(driverCallback).Once()
+				mockDriver.EXPECT().DB().Return(&sql.DB{}, nil).Once()
+				mockDriver.EXPECT().Config().Return(database.Config{Driver: "postgres"}).Once()
+			},
+			expectedPanic: false,
+		},
+		{
+			name:       "Return cached connection",
+			connection: "mysql",
+			setup: func(db *DB) {
+				driverCallback := func() (contractsdriver.Driver, error) {
+					return mockDriver, nil
+				}
+				mockConfig.EXPECT().Get("database.connections.mysql.via").Return(driverCallback).Once()
+				mockDriver.EXPECT().DB().Return(&sql.DB{}, nil).Once()
+				mockDriver.EXPECT().Config().Return(database.Config{Driver: "mysql"}).Once()
+
+				cachedDB, _ := BuildDB(context.Background(), mockConfig, mockLog, "mysql")
+				db.queries = map[string]contractsdb.DB{"mysql": cachedDB}
+			},
+			expectedPanic: false,
+		},
+		{
+			name:       "Panic on BuildDB error",
+			connection: "invalid",
+			setup: func(db *DB) {
+				mockConfig.EXPECT().Get("database.connections.invalid.via").Return(nil).Once()
+				mockLog.EXPECT().Panic(errors.DatabaseConfigNotFound.Error()).Once()
+			},
+			expectedPanic: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			mockConfig = mocksconfig.NewConfig(t)
+			mockDriver = mocksdriver.NewDriver(t)
+			mockLog = mockslog.NewLog(t)
+
+			db := NewDB(context.Background(), mockConfig, mockDriver, mockLog, nil)
+			test.setup(db)
+
+			if test.expectedPanic {
+				assert.NotPanics(t, func() {
+					result := db.Connection(test.connection)
+					assert.Nil(t, result)
+				})
+			} else {
+				result := db.Connection(test.connection)
+				assert.NotNil(t, result)
+			}
+		})
+	}
+}

tests/db_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/goravel/framework/support/carbon"
 	"github.com/goravel/sqlite"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
 
@@ -240,3 +241,55 @@ func (s *DBTestSuite) TestWhere() {
 		})
 	}
 }
+
+func TestDB_Connection(t *testing.T) {
+	t.Parallel()
+	postgresTestQuery := NewTestQueryBuilder().Postgres("", false)
+	postgresTestQuery.CreateTable(TestTableProducts)
+
+	sqliteTestQuery := NewTestQueryBuilder().Sqlite("", false)
+	sqliteTestQuery.CreateTable(TestTableProducts)
+	defer func() {
+		docker, err := sqliteTestQuery.Driver().Docker()
+		assert.NoError(t, err)
+		assert.NoError(t, docker.Shutdown())
+	}()
+
+	sqliteConnection := sqliteTestQuery.Driver().Config().Connection
+	mockDatabaseConfig(postgresTestQuery.MockConfig(), sqliteTestQuery.Driver().Config(), sqliteConnection, "", false)
+
+	result, err := postgresTestQuery.DB().Table("products").Insert(Product{
+		Name: "connection",
+	})
+
+	assert.NoError(t, err)
+	assert.Equal(t, int64(1), result.RowsAffected)
+
+	var product Product
+	err = postgresTestQuery.DB().Table("products").Where("name", "connection").First(&product)
+	assert.NoError(t, err)
+	assert.True(t, product.ID > 0)
+	assert.Equal(t, "connection", product.Name)
+
+	var product1 Product
+	err = postgresTestQuery.DB().Connection(sqliteConnection).Table("products").Where("name", "connection").First(&product1)
+	assert.NoError(t, err)
+	assert.True(t, product1.ID == 0)
+
+	result, err = postgresTestQuery.DB().Connection(sqliteConnection).Table("products").Insert(Product{
+		Name: "sqlite connection",
+	})
+	assert.NoError(t, err)
+	assert.Equal(t, int64(1), result.RowsAffected)
+
+	var product2 Product
+	err = postgresTestQuery.DB().Connection(sqliteConnection).Table("products").Where("name", "sqlite connection").First(&product2)
+	assert.NoError(t, err)
+	assert.True(t, product2.ID > 0)
+	assert.Equal(t, "sqlite connection", product2.Name)
+
+	var product3 Product
+	err = postgresTestQuery.DB().Table("products").Where("name", "sqlite connection").First(&product3)
+	assert.NoError(t, err)
+	assert.True(t, product3.ID == 0)
+}