text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>old := timingWheel.Load()
ticker := timex.NewFakeTicker()
tw, err := collection.NewTimingWheelWithTicker(
time.Millisecond, timingWheelSlots, func(key, value any) {
clean(key, value)
}, ticker)
timingWheel.Store(tw)
assert.NoError(t, err)
t.Cleanup(func() {
timingWheel.Stor... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package cache
import "github.com/zeromicro/go-zero/core/stores/redis"
type (
// A ClusterConf is the config of a redis cluster that used as cache.
Clust<|fim_suffix|>ed as cache.
NodeConf struct {
redis.RedisConf
Weight int `json:",default=100"`
}
)
<|fim_middle|>erConf []NodeConf
// A NodeCon... | fim | zeromicro/go-zero | go |
package cache
import "strings"
const keySeparator = ","
// TotalWeights returns the total weights of given nodes.
func TotalWeights(c []NodeConf) int {
var weights int
for _, node := range c {
if node.Weight < 0 {
node.Weight = 0
}
weights += node.Weight
}
return weights
}
func formatKeys(keys []stri... | fim | zeromicro/go-zero | go |
<|fim_suffix|>eight: 0,
},
{
Weight: 1,
},
})
assert.Equal(t, 1, val)
}
<|fim_prefix|>package cache
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestFormatKeys(t *testing.T) {
assert.Eq<|fim_middle|>ual(t, "a,b", formatKeys([]string{"a", "b"}))
}
func TestTotalWeights(t *testing.T) {... | fim | zeromicro/go-zero | go |
<|fim_suffix|>.T, f func(tx *sql.Tx, mock sqlmock.Sqlmock)) {
RunTest(t, func(db *sql.DB, mock sqlmock.Sqlmock) {
mock.ExpectBegin()
tx, err := db.Begin()
if assert.NoError(t, err) {
f(tx, mock)
}
})
}
<|fim_prefix|>package dbtest
import (
"database/sql"
"testing"
"github.com/DATA-DOG/go-sqlmock"
"gi... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package kv
import "github.com/zeromicro/go-zero/core/stores/cache"
// KvConf is<|fim_suffix|><|fim_middle|> an alias of cache.ClusterConf.
type KvConf = cache.ClusterConf
<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package kv
import (
"context"
"errors"
"log"
"github.com/zeromicro/go-zero/core/errorx"
"github.com/zeromicro/go-zero/core/hash"
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/redis"
)
// ErrNoRedisNode is an error that indicates no redis node.
var Err... | fim | zeromicro/go-zero | go |
<|fim_suffix|>
assert.True(t, ok)
ok, err = client.Zadd("key", 8, "value4")
assert.Nil(t, err)
assert.True(t, ok)
num, err = client.Zremrangebyscore("key", 6, 7)
assert.Nil(t, err)
assert.Equal(t, 2, num)
ok, err = client.Zadd("key", 6, "value2")
assert.Nil(t, err)
assert.True(t, ok)
ok, err = cli... | fim | zeromicro/go-zero | go |
<|fim_prefix|>//go:generate mockgen -package mon -destination collectioninserter_mock.go -source bulkinserter.go collectionInserter
package mon
import (
"context"
"time"
"github.com/zeromicro/go-zero/core/executors"
"github.com/zeromicro/go-zero/core/logx"
"go.mongodb.org/mongo-driver/v2/mongo"
"go.mongodb.org/... | fim | zeromicro/go-zero | go |
<|fim_suffix|>rtMany(gomock.Any(), gomock.Any()).Return(&mongo.InsertManyResult{}, errors.New("error"))
},
},
{
name: "no error",
fields: fields{
collection: mockCollection,
resultHandler: nil,
},
args: args{
objs: make([]any, 1),
},
mock: func() {
mockCollection.EXPECT().Ins... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package mon
<|fim_suffix|>..Option) (*mongo.Client, error) {
val, err := clientManager.GetResource(url, func() (io.Closer, error) {
o := options.Client().ApplyURI(url)
opts = append([]Option{defaultTimeoutOption()}, opts...)
for _, opt := range opts {
opt(o)
}
cli, err := mongo.Connect(o)
... | fim | zeromicro/go-zero | go |
<|fim_suffix|> TestClientManger_getClient(t *testing.T) {
c := &mongo.Client{}
Inject("foo", c)
cli, err := getClient("foo")
assert.Nil(t, err)
assert.Equal(t, c, cli)
}
<|fim_prefix|>package mon
impor<|fim_middle|>t (
"testing"
"github.com/stretchr/testify/assert"
"go.mongodb.org/mongo-driver/v2/mongo"
)
fu... | fim | zeromicro/go-zero | go |
<|fim_suffix|> updateMany)
defer func() {
endSpan(span, err)
}()
err = c.brk.DoWithAcceptableCtx(ctx, func() error {
startTime := timex.Now()
defer func() {
c.logDurationSimple(ctx, updateMany, startTime, err)
}()
res, err = c.Collection.UpdateMany(ctx, filter, update, opts...)
return err
}, accept... | fim | zeromicro/go-zero | go |
<|fim_prefix|>// Code generated by MockGen. DO NOT EDIT.
// Source: collection.go
//
// Generated by this command:
//
// mockgen -package mon -destination collection_mock.go -source collection.go Collection,monCollection
//
// Package mon is a generated GoMock package.
package mon
import (
context "context"
reflect... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package mon
import (
"context"
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/logx/logtest"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/core/timex"
"go.mongodb.org/mongo-driver/... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ionInserterMockRecorder) InsertMany(ctx, documents any, opts ...any) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx, documents}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMany", reflect.TypeOf((*MockcollectionInserter)(nil).InsertMany), varargs...)
}
<|fi... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ansaction(
ctx context.Context,
fn func(sessCtx context.Context) (any, error),
opts ...options.Lister[options.TransactionOptions],
) (res any, err error) {
ctx, span := startSpan(ctx, withTransaction)
defer func() {
endSpan(span, err)
}()
err = w.brk.DoWithAcceptableCtx(ctx, func() error {
sta... | fim | zeromicro/go-zero | go |
<|fim_prefix|>// Code generated by MockGen. DO NOT EDIT.
// Source: model.go
//
// Generated by this command:
//
// mockgen -package mon -destination model_mock.go -source model.go monClient monSession
//
// Package mon is a generated GoMock package.
package mon
import (
context "context"
reflect "reflect"
option... | fim | zeromicro/go-zero | go |
<|fim_suffix|> := newTestModel("foo", mockedMonClient, mockMonCollection, breaker.GetBreaker("test"))
_, err := m.DeleteMany(context.Background(), bson.D{})
assert.Nil(t, err)
triggerBreaker(m)
_, err = m.DeleteMany(context.Background(), bson.D{})
assert.Equal(t, errDummy, err)
}
func TestModel_DeleteOne(t *testi... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package mon
import (
"reflect"
"time"
"github.com/zeromicro/go-zero/core/syncx"
"go.mongodb.org/mongo-driver/v2/bson"
"go.mongodb.org/mongo-driver/v2/mongo/options"
)
const defaultTimeout = time.Second * 3
var (
slowThreshold = syncx.ForAtomicDuration(defaultSlowThreshold)
logMon = syncx... | fim | zeromicro/go-zero | go |
<|fim_suffix|>l(err)
}
if assert.ObjectsAreEqual(v.Decoder, dec) {
t.Errorf("Decoder got from Registry: %v, but want: %v", dec, v.Decoder)
}
}
}
<|fim_prefix|>package mon
import (
"fmt"
"reflect"
"testing"
"time"
"github.com/stretchr/testify/assert"
"go.mongodb.org/mongo-driver/v2/bson"
"go.mongodb.o... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ongo.cmd")
func startSpan(ctx context.Context, cmd string) (context.Context, oteltrace.Span) {
tracer := trace.TracerFromContext(ctx)
ctx, span := tracer.Start(ctx, spanName, oteltrace.WithSpanKind(oteltrace.SpanKindClient))
span.SetAttributes(mongoCmdAttributeKey.String(cmd))
return ctx, span
}
fu... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package mon
import (
"context"
"encoding/json"
"strings"
"time"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/timex"
)
const mongoAddrSep = ","
// FormatAddr formats mongo hosts to a string.
func FormatAddr(hosts []string) string {
return strings.Join(hosts, mongoA... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package mon
import (
"context"
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/logx/logtest"
"github.com/zeromicro/go-zero/core/timex"
)
func TestFormatAddrs(t *testing.T) {
tests := []struct {
addrs []string
expect string
}{
{
addrs: []stri... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package monc
import (
"context"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/mon"
"github.com/zeromicro/go-zero/core/stores/redis"
"github.com/zeromicro/go-zero/core/syncx"
"go.mongodb.org/mongo-driver/v2/mongo... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package monc
import (
"context"
"errors"
"sync/atomic"
"testing"
"github.com/alicebob/miniredis/v2"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/mon"
"github.com/zeromicr... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package postgres
import (
// imports the driver, don't remove this comment, golint requires.
_ "github.com/jackc/pgx/v5/stdlib"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
const postgresDriverName = "pgx"
// New returns a postgres connection.
func New(datasource string, opts ...sqlx.Sql<|fim_... | fim | zeromicro/go-zero | go |
<|fim_suffix|><|fim_prefix|>package postgres
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestP<|fim_middle|>ostgreSql(t *testing.T) {
assert.NotNil(t, New("postgre"))
}
<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"context"
<|fim_suffix|>ineHook {
return func(ctx context.Context, cmds []red.Cmder) error {
return h.brk.DoWithAcceptableCtx(ctx, func() error {
return next(ctx, cmds)
}, acceptable)
}
}
<|fim_middle|>red "github.com/redis/go-redis/v9"
"github.com/zeromicro/go-zero/co... | fim | zeromicro/go-zero | go |
<|fim_suffix|>f err != nil && err.Error() != someError.Error() {
break
}
}
assert.Equal(t, someError.Error(), err.Error())
})
}
func TestBreakerHook_ProcessPipelineHook(t *testing.T) {
t.Run("breakerPipelineHookOpen", func(t *testing.T) {
s := miniredis.RunT(t)
rds := MustNewRedis(RedisConf{
Host:... | fim | zeromicro/go-zero | go |
<|fim_suffix|>onf) NewRedis() *Redis {
var opts []Option
if rc.Type == ClusterType {
opts = append(opts, Cluster())
}
if len(rc.User) > 0 {
opts = append(opts, WithUser(rc.User))
}
if len(rc.Pass) > 0 {
opts = append(opts, WithPass(rc.Pass))
}
if rc.Tls {
opts = append(opts, WithTLS())
}
return newRe... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stringx"
)
func TestRedisConf(t *testing.T) {
tests := []struct {
name string
RedisConf
ok bool
}{
{
name: "missing host",
RedisConf: RedisConf{
Host: "",
Type: NodeType,
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"context"
"errors"
"io"
"net"
"strings"
"time"
red "github.com/redis/go-redis/v9"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/mapping"
"github.com/zeromicro/go-zero/core/timex"
"github.com/zero... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"context"
"errors"
"io"
"net"
"strings"
"testing"
"time"
red "github.com/redis/go-redis/v9"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/logx/logtest"
"github.com/zeromicro/go-zero/core/trace/tracet... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"sync"
"github.com/prometheus/client_golang/prometheus"
red "github.com/redis/go-redis/v9"
"github.com/zeromicro/go-zero/core/metric"
)
const namespace = "redis_client"
var (
metricReqDur = metric.NewHistogramVec(&metric.HistogramVecOpts{
Namespace: namespace,
Subsystem... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"io"
"net/http"
"strings"
"testing"
"time"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/testutil"
red "github.com/redis/go-redis/v9"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/conf"
"github... | fim | zeromicro/go-zero | go |
<|fim_suffix|> *Redis) Rpop(key string) (string, error) {
return s.RpopCtx(context.Background(), key)
}
// RpopCtx is the implementation of redis rpop command.
func (s *Redis) RpopCtx(ctx context.Context, key string) (string, error) {
conn, err := getRedis(s)
if err != nil {
return "", err
}
return conn.RPop(c... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"context"
"crypto/tls"
"errors"
"io"
"strconv"
"testing"
"time"
<|fim_suffix|>e()).Incrby("a", 2)
assert.NotNil(t, err)
val, err := client.Incrby("a", 2)
assert.Nil(t, err)
assert.Equal(t, int64(2), val)
val, err = client.Incrby("a", 3)
assert.Nil(t, err)
asser... | fim | zeromicro/go-zero | go |
package redis
import (
"fmt"
red "github.com/redis/go-redis/v9"
"github.com/zeromicro/go-zero/core/logx"
)
// ClosableNode interface represents a closable redis node.
type ClosableNode interface {
RedisNode
Close()
}
// CreateBlockingNode creates a dedicated RedisNode for blocking operations.
//
// Blocking Re... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"testing"
<|fim_suffix|>gNode(New(r.Addr()))
assert.NoError(t, err)
node.Close()
// close again to make sure it's safe
assert.NotPanics(t, func() {
node.Close()
})
})
t.Run("test blocking node with cluster", func(t *testing.T) {
r, err := miniredis.Run()
asser... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package<|fim_suffix|>il
})
if err != nil {
return nil, err
}
return val.(*red.Client), nil
}
<|fim_middle|> redis
import (
"crypto/tls"
"io"
"runtime"
red "github.com/redis/go-redis/v9"
"github.com/zeromicro/go-zero/core/syncx"
)
const (
defaultDatabase = 0
maxRetries = 3
idleConns ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"crypto/tls"
"io"
"runtime"
"strings"
red "github.com/redis/go-redis/v9"
"github.com/zeromicro/go-zero/core/syncx"
)
const addrSep = ","
var (
clusterManager = syncx.NewResourceManager()
// clusterPoolSize is default pool size for cluster type of redis.
clusterPoolSize ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"testing"
"github.com/alicebob/miniredis/v2"
red "github.com/redis/go-redis/v9"
"github.com/stretchr/testify/assert"
)
func TestSplitClusterAddrs(t *testing.T) {
testCases := []struct {
name string
input string
expected []string
}{
{
name: <|fim_suffix|>t... | fim | zeromicro/go-zero | go |
<|fim_suffix|>]string{rl.key}, []string{rl.id})
if err != nil {
return false, err
}
reply, ok := resp.(int64)
if !ok {
return false, nil
}
return reply == 1, nil
}
// SetExpire sets the expiration.
func (rl *RedisLock) SetExpire(seconds int) {
atomic.StoreUint32(&rl.seconds, uint32(seconds))
}
<|fim_prefi... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tNil(t, err)
})
}
<|fim_prefix|>package redis
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stringx"
)
func TestRedisLock(t *testing.T) {
testFn := func(ctx context.Context) func(client *Redis) {
return func(client *Redis) {
key := stri... | fim | zeromicro/go-zero | go |
package redistest
import (
"testing"
"github.com/alicebob/miniredis/v2"
"github.com/zeromicro/go-zero/core/stores/redis"
)
// CreateRedis returns an in process redis.Redis.
func CreateRedis(t *testing.T) *redis.Redis {
r, _ := CreateRedisWithClean(t)
return r
}
// CreateRedisWithClean returns an in process red... | fim | zeromicro/go-zero | go |
<|fim_suffix|>return ret, ok
}
// SetSha sets script with sha into the ScriptCache.
func (sc *ScriptCache) SetSha(script, sha string) {
lock.Lock()
defer lock.Unlock()
cache := sc.Load().(Map)
newCache := make(Map)
for k, v := range cache {
newCache[k] = v
}
newCache[script] = sha
sc.Store(newCache)
}
<|fim... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package redis
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/logx"
)
func TestScriptCache(t *tes<|fim_suffix|> ok := cache.GetSha("foo")
assert.True(t, ok)
assert.Equal(t, "bar", bar)
}
<|fim_middle|>ting.T) {
logx.Disable()
cache := GetScriptCache()
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tx(ctx context.Context, q string, args ...any) (
sql.Result, error) {
return cc.db.ExecCtx(ctx, q, args...)
}
// QueryRow unmarshals into v with given key and query func.
func (cc CachedConn) QueryRow(v any, key string, query QueryFn) error {
queryCtx := func(_ context.Context, conn sqlx.SqlConn, v an... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlc
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"os"
"runtime"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/DATA-DOG/go-sqlmock"
"github.com/alicebob/miniredis/v2"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/fx"
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>tch: %q", stmt)
}
return bulkStmt{
prefix: stmt[:pos+len(valuesKeyword)],
valueFormat: valueFormat,
suffix: suffix,
}, nil
}
<|fim_prefix|>package sqlx
import (
"database/sql"
"fmt"
"strings"
"sync"
"time"
"github.com/zeromicro/go-zero/core/executors"
"github.com/zeromicro/go-... | fim | zeromicro/go-zero | go |
<|fim_suffix|>v.Itoa(i), i))
}
inserter.SetResultHandler(func(result sql.Result, err error) {})
inserter.Flush()
assert.Equal(t, `INSERT INTO classroom_dau(classroom, user, count) VALUES `+
`('class_0', 'user_0', 0), ('class_1', 'user_1', 1), ('class_2', 'user_2', 2), `+
`('class_3', 'user_3', 3), ('class... | fim | zeromicro/go-zero | go |
<|fim_suffix|>efault=round-robin,options=round-robin|random"`
}
// Validate validates the SqlxConf.
func (sc SqlConf) Validate() error {
if len(sc.DataSource) == 0 {
return errEmptyDatasource
}
if len(sc.DriverName) == 0 {
return errEmptyDriverName
}
return nil
}
<|fim_prefix|>package sqlx
import "errors"
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ame = "mysql"
assert.Nil(t, sc.Validate())
}
<|fim_prefix|>package sqlx
import (
"testing"
"github.com/stre<|fim_middle|>tchr/testify/assert"
"github.com/zeromicro/go-zero/core/conf"
)
func TestValidate(t *testing.T) {
text := []byte(`DataSource: primary:password@tcp(127.0.0.1:3306)/primary_db
`)
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>wDBFromTx = errors.New("cannot get raw db from transaction")
)
<|fim_prefix|>package sqlx
import (
"database/sql"
"errors"
)
var (
// ErrNotFound is an alias of sql.ErrNoRows
ErrNotFound = sql.ErrNoRows
errCantNestTx = errors.New("cannot nest t<|fim_middle|>ransactions")
errNoRa<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"database/sql"
"sync"
"github.com/prometheus/client_golang/prometheus"
"github.com/zeromicro/go-zero/core/metric"
)
const namespace = "sql_client"
var (
metricReqDur = metric.NewHistogramVec(&metric.HistogramVecOpts{
Namespace: namespace,
Subsystem: "requests",
Name: ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"database/sql"
"io"
"net/http"
"strings"
"testing"
"time"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/testutil"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zer... | fim | zeromicro/go-zero | go |
<|fim_suffix|>= errors.As(err, &myerr)
if !ok {
return false
}
switch myerr.Number {
case duplicateEntryCode:
return true
default:
return false
}
}
func withMysqlAcceptable() SqlOption {
return WithAcceptable(mysqlAcceptable)
}
<|fim_prefix|>package sqlx
import (
"errors"
"github.com/go-sql-driver/my... | fim | zeromicro/go-zero | go |
<|fim_suffix|> }
}, conn.acceptable))
}
return conn.brk.DoWithAcceptable(func() error {
return &mysql.MySQLError{
Number: duplicateEntryCode,
}
}, conn.acceptable)
}
<|fim_prefix|>package <|fim_middle|>sqlx
import (
"errors"
"testing"
"github.com/go-sql-driver/mysql"
"github.com/stretchr/testify/asse... | fim | zeromicro/go-zero | go |
<|fim_suffix|>return err
}
if err := scanner.Scan(values...); err != nil {
return err
}
appendFn(value)
}
default:
return ErrUnsupportedValueType
}
return scanner.Err()
default:
return ErrUnsupportedValueType
}
}
func unwrapFields(v reflect.Value) []reflect.Value {
var fields [... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ipline"`
Score uint `db:"score"`
}
type ClassType struct {
Grade sql.NullString `db:"grade"`
ClassName *string `db:"class_name"`
}
type Class struct {
*ClassType
Score
}
expect := []*struct {
Name string
Age int64
Grade sql.NullString
Discipline ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import "context"
const (
// policyRoundRobin round-robin policy for selecting replicas.
policyRoundRobin = "round-robin"
// policyRandom random policy for selecting replicas.
policyRandom = "random"
// readPrimaryMode indicates that the operation is a read,
// but should be performed... | fim | zeromicro/go-zero | go |
package sqlx
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
)
func TestIsValid(t *testing.T) {
testCases := []struct {
name string
mode readWriteMode
expected bool
}{
{
name: "valid read-primary mode",
mode: readPrimaryMode,
expected: true,
},
{
name: ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"context"
"database/sql"
"errors"
"fmt"
"math/rand"
"sync/atomic"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/errorx"
"github.com/zeromicro/go-zero/core/logx"
)
// spanName is used to identify the span name for the SQL execution.
const s... | fim | zeromicro/go-zero | go |
<|fim_suffix|>SqlConf{})
})
})
t.Run("on error", func(t *testing.T) {
db, mock, err := sqlmock.New()
assert.NotNil(t, db)
assert.NotNil(t, mock)
assert.Nil(t, err)
connManager.Inject(mockedDatasource, db)
conf := SqlConf{DataSource: mockedDatasource, DriverName: mysqlDriverName}
conn := MustNewConn(c... | fim | zeromicro/go-zero | go |
<|fim_suffix|>xOpenConns(maxOpenConns)
conn.SetConnMaxLifetime(maxLifetime)
if err := conn.Ping(); err != nil {
_ = conn.Close()
return nil, err
}
return conn, nil
}
<|fim_prefix|>package sqlx
import (
"crypto/sha256"
"database/sql"
"encoding/hex"
"io"
"time"
"github.com/go-sql-driver/mysql"
"github.... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"context"
"database/sql"
"errors"
"time"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/syncx"
"github.com/zeromicro/go-zero/core/timex"
)
const defaultSlowThreshold = time.Millisecond * 500
var (
s... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"context"
"database/sql"
"errors"
"strconv"
"testing"
"time"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/stores/dbtest"
)
var errMockedPlaceholder = errors.New("place... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"context"
"datab<|fim_suffix|> sql.ErrNoRows) {
span.SetStatus(codes.Ok, "")
return
}
span.SetStatus(codes.Error, err.Error())
span.RecordError(err)
}
<|fim_middle|>ase/sql"
"errors"
"github.com/zeromicro/go-zero/core/trace"
"go.opentelemetry.io/otel/attribute"
"go.op... | fim | zeromicro/go-zero | go |
<|fim_suffix|> if err != nil {
return
}
defer func() {
if p := recover(); p != nil {
if e := tx.Rollback(); e != nil {
err = fmt.Errorf("recover from %#v, rollback failed: %w", p, e)
} else {
err = fmt.Errorf("recover from %#v", p)
}
} else if err != nil {
if e := tx.Rollback(); e != nil {
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"context"
"database/sql"
"errors"
"testing"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/stores/dbtest"
)
const (
mockCommit = 1
mockRollback = 2
)
type mockTx stru... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package sqlx
import (
"context"
"errors"
"fmt"
"strconv"
"strings"
"time"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/mapping"
)
var errUnbalancedEscape = errors.New("no char after escape char")
func desensitize(datasource string) string {
// remove account
po... | fim | zeromicro/go-zero | go |
<|fim_suffix|>from users where bool=0 and phone='133'",
},
{
name: "pg error not number",
query: "select name, age from users where bool=$a and phone=$1",
args: []any{"133", false},
hasErr: true,
},
{
name: "pg error more args",
query: "select name, age from users where bool=$2 and pho... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
type node struct {
children map[rune]*node
fail *node
depth int
end bool
}
func (n *node) add(word string) {
chars := []rune(word)
if len(chars) == 0 {
return
}
nd := n
for i, char := range chars {
if nd.children == nil {
child := new(node)
child.depth = i... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
"fmt"
"math/rand"
"strings"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func FuzzNodeFind(f *testing.F) {
rand.NewSource(time.Now().UnixNano())
f.Add(10)
f.Fuzz(func(t *testing.T, keys int) {
str := Randn(rand.Intn(100) + 50)
keywords := make(map[strin... | fim | zeromicro/go-zero | go |
<|fim_suffix|>words := []string{
"A",
"AV",
"AV演员",
"无名氏",
"AV演员色情",
"日本AV女优",
}
trie := new(node)
for _, keyword := range keywords {
trie.add(keyword)
}
trie.build()
for i := 0; i < b.N; i++ {
trie.find([]rune("日本AV演员兼电视、电影演员。无名氏AV女优是xx出道, 日本AV女优们最精彩的表演是AV演员色情表演"))
}
}
<|fim_prefix|>package str... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
crand "crypto/rand"
"fmt"
"math/rand"
"sync"
"time"
)
const (
letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
letterIdxBits = 6 // 6 bits to represent a letter index
idLen = 8
defaultRandLen = 8
letterIdxMask = 1<<letterIdxB... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
"testing"
<|fim_suffix|>ting.T) {
Seed(time.Now().UnixNano())
assert.True(t, len(Rand()) > 0)
assert.True(t, len(RandId()) > 0)
const size = 10
assert.True(t, len(Randn(size)) == size)
}
func BenchmarkRandString(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = Randn(10)
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
"sort"
"strings"
)
// replace more than once to avoid overlapped keywords after replace.
// only try 2 times to avoid too many or infinite loops.
const replaceTimes = 2
type (
// Replacer interface wraps the Replace method.
Replacer interface {
Replace(text string) string... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
"fmt"
"math/rand"
"strings"
"testing"
)
func FuzzReplacerReplace(f *testing.F) {
keywords := make(map[string]string)
for i := 0; i < 20; i++ {
keywords[Randn(rand.Intn(10)+5)] = Randn(rand.Intn(5) + 1)
}
rep := NewReplacer(keywords)
printableKeywords := func() string ... | fim | zeromicro/go-zero | go |
<|fim_suffix|>0iOg72QcPo": "RP",
"pSEqeL": "5KZ",
"GOyYqTgmvQ": "9",
"Qv4qCsj": "nl52E",
"wNQ5tOutYu5s8": "6iGa",
}
rep := NewReplacer(keywords)
text := "AoRxrdKWsGhFpXwVqMLWRL74OukwjBuBh0g7pSrk"
val := rep.Replace(text)
keys := rep.(*replacer).node.find([]rune(val))
if len(keys) >... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
"errors"
"slices"
"strings"
"unicode"
"github.com/zeromicro/go-zero/core/lang"
)
var (
// ErrInvalidStartPosition is an error that indicates the start position is invalid.
ErrInvalidStartPosition = errors.New("start position is invalid")
// ErrInvalidStopPosition is an ... | fim | zeromicro/go-zero | go |
<|fim_suffix|> {
input: []string{"b", "a", "c"},
remove: []string{"a"},
expect: []string{"b", "c"},
},
{
input: []string{},
remove: []string{"a"},
expect: []string{},
},
}
for _, each := range cases {
t.Run(path.Join(each.input...), func(t *testing.T) {
assert.ElementsMatch(t, each.exp... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import "github.com/zeromicro/go-zero/core/lang"
const defaultMask = '*'
type (
// TrieOption defines the method to customize a Trie.
TrieOption func(trie *trieNode)
// A Trie is a tree implementation that used to find elements rapidly.
Trie interface {
Filter(text string) (string... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestTrieSimple(t *testing.T) {
trie := NewTrie([<|fim_suffix|>ange tests {
t.Run(test.input, func(t *testing.T) {
output, keywords, ok := trie.Filter(test.input)
assert.Equal(t, test.found, ok)
assert.Equal(t, ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package syncx
import "sync/atomic"
// An AtomicBo<|fim_suffix|>l {
return new(AtomicBool)
}
// ForAtomicBool returns an AtomicBool with given val.
func ForAtomicBool(val bool) *AtomicBool {
b := NewAtomicBool()
b.Set(val)
return b
}
// CompareAndSwap compares current value with given old, if equal... | fim | zeromicro/go-zero | go |
package syncx
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestAtomicBool(t *testing.T) {
val := ForAtomicBool(true)
assert.True(t, val.True())
val.Set(false)
assert.False(t, val.True())
val.Set(true)
assert.True(t, val.True())
val.Set(false)
assert.False(t, val.True())
ok := val.Compare... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package syncx
import (
"sync/atomic"
"time"
)
// An AtomicDuration is an implementation of atomic duration.
type AtomicDuration int64
// NewAtomicDura<|fim_suffix|>ation {
return new(AtomicDuration)
}
// ForAtomicDuration returns an AtomicDuration with given value.
func ForAtomicDuration(val time.D... | fim | zeromicro/go-zero | go |
<|fim_suffix|>d.Load())
}
<|fim_prefix|>package syncx
import (
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func TestAtomicDuration(t *testing.T) {
d := ForAtomicDuration(time.Duration(100))
assert.Equal(t, time.Duration(100), d.Load())
d.Set(time.Duration(200))
assert.Equal(t, time.Duration(200), ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package syncx
import (
"math"
"sync/atomic"
)
// An AtomicFloat64 is an implementation of atomic float64.
type AtomicFloat64 uint64
// NewAtomicFloat64 returns an AtomicFloat64.
func NewAtomicFloat64() *AtomicFloat64 {
return new(AtomicFloat64)
}
// ForAtomicFloat64 returns an AtomicFloat64 with gi... | fim | zeromicro/go-zero | go |
<|fim_suffix|><|fim_prefix|>package syncx
import (
"sync"
"testing"
"github.com/stretchr/testify/assert"
)
func TestAtomicFloat64(t *testing.T) {
f := ForAtomicFloat64(100)
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func() {
for i := 0; i < 100; i++ {
f.Add(1)
}
wg.Done()
}(... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package syncx
import "sync"
// A Barrier is used to facility the barrier on a resource.
type Ba<|fim_suffix|>{
Guard(&b.lock, fn)
}
// Guard guards the given fn with lock.
func Guard(lock sync.Locker, fn func()) {
lock.Lock()
defer lock.Unlock()
fn()
}
<|fim_middle|>rrier struct {
lock sync.Mutex
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>t *testing.T) {
const total = 10000
barrier := new(Barrier)
var count int
wg := new(sync.WaitGroup)
wg.Add(total)
for i := 0; i < total; i++ {
go barrier.Guard(func() {
count++
wg.Done()
})
}
wg.Wait()
assert.Equal(t, total, count)
}
func TestGuard(t *testing.T) {
const total = 10000
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package syncx
import (
"time"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/core/timex"
)
// A Cond is used to wait for conditions.
type Cond struct {
signal chan lang.PlaceholderType
}
// NewCond returns a Cond.
func NewCond() *Cond {
return &Cond{
signal: make(chan la... | fim | zeromicro/go-zero | go |
package syncx
import (
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func TestTimeoutCondWait(t *testing.T) {
var wait sync.WaitGroup
cond := NewCond()
wait.Add(2)
go func() {
cond.Wait()
wait.Done()
}()
time.Sleep(time.Duration(50) * time.Millisecond)
go func() {
cond.Signal()
wa... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ed on dc closed.
func (dc *DoneChan) Done() chan lang.PlaceholderType {
return dc.done
}
<|fim_prefix|>package syncx
import (
"sync"
<|fim_middle|> "github.com/zeromicro/go-zero/core/lang"
)
// A DoneChan is used as a channel that can be closed multiple times and wait for done.
type DoneChan struct {... | fim | zeromicro/go-zero | go |
<|fim_suffix|>}
<|fim_prefix|>package syncx
import (
"sync"
"testing"
)
func TestDoneChanClose(t *testing.T) {
doneChan := NewDoneChan()
for i := 0; i < 5; i++ {
doneChan.Close()
}
}
func TestDoneChanDone(t *testing.T) {
var waitGroup sync.WaitGroup
doneChan := NewDoneChan()
waitGroup.Add(1)
go func() {... | fim | zeromicro/go-zero | go |
<|fim_suffix|>rvalOnFailure(interval time.Duration) ImmutableResourceOption {
return func(resource *ImmutableResource) {
resource.refreshInterval = interval
}
}
<|fim_prefix|>package syncx
import (
"sync"
"time"
"github.com/zeromicro/go-zero/core/timex"
)
const defaultRefreshInterval <|fim_middle|>= time.Seco... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package syncx
import (
"errors"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func TestImmutableResource(t *testing.T) {
var count int
r := NewImmutableResource(func() (any, error) {
count++
return "hello", nil
<|fim_suffix|>idx] = err
}(i)
}
// wait for... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ng mode.
// If success, true returned, false for otherwise.
func (l Limit) TryBorrow() bool {
select {
case l.pool <- lang.Placeholder:
return true
default:
return false
}
}
<|fim_prefix|>package syncx
import (
"errors"
"github.com/zero<|fim_middle|>micro/go-zero/core/lang"
)
// ErrLimitRetur... | fim | zeromicro/go-zero | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.