Function TestModule_ProvideRunGroup

otgorm/module_test.go:99–152

(t *testing.T)

}

func TestModule_ProvideRunGroup(t *testing.T) {
	t.Parallel()

	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	withValues := []interface{}{
		gomock.Eq("dbname"),
		gomock.Eq("default"),
		gomock.Eq("driver"),
		gomock.Eq("sqlite"),
	}

	idle := mock_metrics.NewMockGauge(ctrl)
	idle.EXPECT().With(withValues...).Return(idle).MinTimes(1)
	idle.EXPECT().Set(gomock.Eq(0.0)).MinTimes(1)

	open := mock_metrics.NewMockGauge(ctrl)
	open.EXPECT().With(withValues...).Return(open).MinTimes(1)
	open.EXPECT().Set(gomock.Eq(2.0)).MinTimes(1)

	inUse := mock_metrics.NewMockGauge(ctrl)
	inUse.EXPECT().With(withValues...).Return(inUse).MinTimes(1)
	inUse.EXPECT().Set(gomock.Eq(2.0)).MinTimes(1)

	c := core.New(
		core.WithInline("gorm.default.database", "sqlite"),
		core.WithInline("gorm.default.dsn", "file::memory:?cache=shared"),
		core.WithInline("gormMetrics.interval", "1ms"),
		core.WithInline("log.level", "none"),
	)
	c.ProvideEssentials()
	c.Provide(di.Deps{func() *Gauges {
		return NewGauges(idle, inUse, open)
	}})
	c.Provide(Providers())
	c.AddModuleFunc(New)
	ctx, cancel := context.WithCancel(context.Background())
	var (
		c1 *sql.Conn
		c2 *sql.Conn
	)
	c.Invoke(func(db *gorm.DB) {
		rawSQL, _ := db.DB()
		c1, _ = rawSQL.Conn(ctx)
		c2, _ = rawSQL.Conn(ctx)
	})
	go c.Serve(ctx)
	<-time.After(10 * time.Millisecond)
	cancel()
	<-time.After(1000 * time.Millisecond)
	c1.Close()
	c2.Close()
}

func TestProviders(t *testing.T) {
	provider := Providers(