Merge pull request #1032 from kupriyanovkk/master

asmyasnikov · web-flow · commit d1f6e5b78b1b · 2024-03-04T01:14:53.000+03:00
enable errname linter
diff --git a/.golangci.yml b/.golangci.yml
@@ -223,7 +223,6 @@ linters:
     - cyclop
     - depguard
     - dupl
-    - errname
     - exhaustive
     - exhaustivestruct
     - exhaustruct
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -42,14 +42,14 @@
 
 ## v3.54.2
 * Added context to some internal methods for better tracing
-* Added `trace.FunctionID` helper and `FunctionID` field to trace start info's 
+* Added `trace.FunctionID` helper and `FunctionID` field to trace start info's
 * Replaced lazy initialization of ydb clients (table, topic, etc.) to explicit initialization on `ydb.Open` step
 
 ## v3.54.1
-* Fixed inconsistent labels in `metrics` 
+* Fixed inconsistent labels in `metrics`
 
 ## v3.54.0
-* Allowed `sql.LevelSerializable` isolation level in read-write mode in `database/sql` transactions 
+* Allowed `sql.LevelSerializable` isolation level in read-write mode in `database/sql` transactions
 * Refactored traces and metrics
 * Added `{retry,table}.WithLabel` options for mark retriers calls
 * Added `ydb.WithTraceRetry` option
@@ -73,7 +73,7 @@
 * Fixed stringification of credentials object
 
 ## v3.53.2
-* Fixed panic when try to unwrap values with more than 127 columns with custom ydb unmarshaler 
+* Fixed panic when try to unwrap values with more than 127 columns with custom ydb unmarshaler
 
 ## v3.53.1
 * Bumps `github.com/ydb-platform/ydb-go-genproto` for support `query` service
@@ -222,7 +222,7 @@
 * Added `table/options.WithCallOptions` options for append custom grpc call options into `session.{BulkUpsert,Execute,StreamExecuteScanQuery}`
 * Supported fake transactions in `database/sql` driver over connector option `ydb.WithFakeTx(queryMode)` and connection string param `go_fake_tx`
 * Removed `testutil/timeutil` package (all usages replaced with `clockwork` package)
-* Changed behaviour of retryer on transport errors `cancelled` and `deadline exceeded` - will retry idempotent operation if context is not done  
+* Changed behaviour of retryer on transport errors `cancelled` and `deadline exceeded` - will retry idempotent operation if context is not done
 * Added address of node to operation error description as optional
 * Fixed bug with put session from unknown node
 * Fixed bug with parsing of `TzTimestamp` without microseconds
diff --git a/internal/conn/error_test.go b/internal/conn/error_test.go
@@ -32,30 +32,30 @@ func TestNodeErrorIs(t *testing.T) {
 	require.NotErrorIs(t, nodeErr, testErr2)
 }
 
-type testErrorType1 struct {
+type testType1Error struct {
 	msg string
 }
 
-func (t testErrorType1) Error() string {
+func (t testType1Error) Error() string {
 	return "1 - " + t.msg
 }
 
-type testErrorType2 struct {
+type testType2Error struct {
 	msg string
 }
 
-func (t testErrorType2) Error() string {
+func (t testType2Error) Error() string {
 	return "2 - " + t.msg
 }
 
 func TestNodeErrorAs(t *testing.T) {
-	testErr := testErrorType1{msg: "test"}
+	testErr := testType1Error{msg: "test"}
 	nodeErr := newConnError(1, "localhost:1234", testErr)
 
-	target := testErrorType1{}
+	target := testType1Error{}
 	require.ErrorAs(t, nodeErr, &target)
 	require.Equal(t, testErr, target)
 
-	target2 := testErrorType2{}
+	target2 := testType2Error{}
 	require.False(t, errors.As(nodeErr, &target2))
 }
diff --git a/internal/topic/topicreaderinternal/decoders.go b/internal/topic/topicreaderinternal/decoders.go
@@ -36,7 +36,7 @@ func (m *decoderMap) Decode(codec rawtopiccommon.Codec, input io.Reader) (io.Rea
 	}
 
 	return nil, xerrors.WithStackTrace(xerrors.Wrap(
-		fmt.Errorf("ydb: failed decompress message with codec %v: %w", codec, PublicErrUnexpectedCodec),
+		fmt.Errorf("ydb: failed decompress message with codec %v: %w", codec, ErrPublicUnexpectedCodec),
 	))
 }
 
diff --git a/internal/topic/topicreaderinternal/message.go b/internal/topic/topicreaderinternal/message.go
@@ -14,8 +14,8 @@ import (
 
 var errMessageWasReadEarly = xerrors.Wrap(errors.New("ydb: message was read early"))
 
-// PublicErrUnexpectedCodec return when try to read message content with unknown codec
-var PublicErrUnexpectedCodec = errors.New("unexpected codec") //nolint:revive,stylecheck
+// ErrPublicUnexpectedCodec return when try to read message content with unknown codec
+var ErrPublicUnexpectedCodec = errors.New("unexpected codec")
 
 // PublicMessage is representation of topic message
 type PublicMessage struct {
diff --git a/internal/xcontext/context_error.go b/internal/xcontext/context_error.go
@@ -4,39 +4,39 @@ import (
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/stack"
 )
 
-var _ error = (*ctxErr)(nil)
+var _ error = (*ctxError)(nil)
 
 const (
 	atWord   = "at"
 	fromWord = "from"
 )
 
 func errAt(err error, skipDepth int) error {
-	return &ctxErr{
+	return &ctxError{
 		err:         err,
 		stackRecord: stack.Record(skipDepth + 1),
 		linkWord:    atWord,
 	}
 }
 
 func errFrom(err error, from string) error {
-	return &ctxErr{
+	return &ctxError{
 		err:         err,
 		stackRecord: from,
 		linkWord:    fromWord,
 	}
 }
 
-type ctxErr struct {
+type ctxError struct {
 	err         error
 	stackRecord string
 	linkWord    string
 }
 
-func (e *ctxErr) Error() string {
+func (e *ctxError) Error() string {
 	return "'" + e.err.Error() + "' " + e.linkWord + " `" + e.stackRecord + "`"
 }
 
-func (e *ctxErr) Unwrap() error {
+func (e *ctxError) Unwrap() error {
 	return e.err
 }
diff --git a/internal/xerrors/issues.go b/internal/xerrors/issues.go
@@ -57,7 +57,7 @@ func (ii issues) String() string {
 
 // NewWithIssues returns error which contains child issues
 func NewWithIssues(text string, issues ...error) error {
-	err := &errorWithIssues{
+	err := &withIssuesError{
 		reason: text,
 	}
 	for i := range issues {
@@ -69,14 +69,14 @@ func NewWithIssues(text string, issues ...error) error {
 	return err
 }
 
-type errorWithIssues struct {
+type withIssuesError struct {
 	reason string
 	issues []error
 }
 
-func (e *errorWithIssues) isYdbError() {}
+func (e *withIssuesError) isYdbError() {}
 
-func (e *errorWithIssues) Error() string {
+func (e *withIssuesError) Error() string {
 	var b bytes.Buffer
 	if len(e.reason) > 0 {
 		b.WriteString(e.reason)
@@ -95,7 +95,7 @@ func (e *errorWithIssues) Error() string {
 	return b.String()
 }
 
-func (e *errorWithIssues) As(target interface{}) bool {
+func (e *withIssuesError) As(target interface{}) bool {
 	for _, err := range e.issues {
 		if As(err, target) {
 			return true
@@ -105,7 +105,7 @@ func (e *errorWithIssues) As(target interface{}) bool {
 	return false
 }
 
-func (e *errorWithIssues) Is(target error) bool {
+func (e *withIssuesError) Is(target error) bool {
 	for _, err := range e.issues {
 		if Is(err, target) {
 			return true
diff --git a/internal/xerrors/join.go b/internal/xerrors/join.go
@@ -6,13 +6,13 @@ import (
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/xstring"
 )
 
-func Join(errs ...error) joinError {
+func Join(errs ...error) joinErrors {
 	return errs
 }
 
-type joinError []error
+type joinErrors []error
 
-func (errs joinError) Error() string {
+func (errs joinErrors) Error() string {
 	b := xstring.Buffer()
 	defer b.Free()
 	b.WriteByte('[')
@@ -27,7 +27,7 @@ func (errs joinError) Error() string {
 	return b.String()
 }
 
-func (errs joinError) As(target interface{}) bool {
+func (errs joinErrors) As(target interface{}) bool {
 	for _, err := range errs {
 		if As(err, target) {
 			return true
@@ -37,7 +37,7 @@ func (errs joinError) As(target interface{}) bool {
 	return false
 }
 
-func (errs joinError) Is(target error) bool {
+func (errs joinErrors) Is(target error) bool {
 	for _, err := range errs {
 		if Is(err, target) {
 			return true
@@ -47,6 +47,6 @@ func (errs joinError) Is(target error) bool {
 	return false
 }
 
-func (errs joinError) Unwrap() []error {
+func (errs joinErrors) Unwrap() []error {
 	return errs
 }
diff --git a/internal/xerrors/join_test.go b/internal/xerrors/join_test.go
@@ -10,7 +10,7 @@ import (
 
 func TestJoin(t *testing.T) {
 	for _, tt := range []struct {
-		err joinError
+		err joinErrors
 		iss []error
 		ass []interface{}
 		s   string
diff --git a/internal/xsql/conn.go b/internal/xsql/conn.go
@@ -465,7 +465,7 @@ func (c *conn) BeginTx(ctx context.Context, txOptions driver.TxOptions) (_ drive
 	if c.currentTx != nil {
 		return nil, xerrors.WithStackTrace(
 			xerrors.Retryable(
-				&ErrConnAlreadyHaveTx{
+				&ConnAlreadyHaveTxError{
 					currentTx: c.currentTx.ID(),
 				},
 				xerrors.WithDeleteSession(),
diff --git a/internal/xsql/errors.go b/internal/xsql/errors.go
@@ -14,17 +14,17 @@ var (
 	errNotReadyConn    = xerrors.Retryable(errors.New("conn not ready"), xerrors.WithDeleteSession())
 )
 
-type ErrConnAlreadyHaveTx struct {
+type ConnAlreadyHaveTxError struct {
 	currentTx string
 }
 
-func (err *ErrConnAlreadyHaveTx) Error() string {
+func (err *ConnAlreadyHaveTxError) Error() string {
 	return "conn already have an open currentTx: " + err.currentTx
 }
 
-func (err *ErrConnAlreadyHaveTx) As(target interface{}) bool {
+func (err *ConnAlreadyHaveTxError) As(target interface{}) bool {
 	switch t := target.(type) {
-	case *ErrConnAlreadyHaveTx:
+	case *ConnAlreadyHaveTxError:
 		t.currentTx = err.currentTx
 
 		return true
diff --git a/tests/integration/tx_test.go b/tests/integration/tx_test.go
@@ -138,14 +138,14 @@ func TestNoEffectsIfForgetCommitTx(t *testing.T) {
 
 		// check row for NO write
 		var (
-			value                string
-			errConnAlreadyHaveTx *xsql.ErrConnAlreadyHaveTx
+			value                  string
+			connAlreadyHaveTxError *xsql.ConnAlreadyHaveTxError
 		)
 		err = db.QueryRowContext(ctx, `SELECT val FROM table WHERE id = $1`, id).Scan(&value)
 		require.ErrorIs(t, err, sql.ErrNoRows)
 
 		// second tx on existing conn === session
 		_, err = cc.BeginTx(ctx, &sql.TxOptions{})
-		require.ErrorAs(t, err, &errConnAlreadyHaveTx)
+		require.ErrorAs(t, err, &connAlreadyHaveTxError)
 	})
 }
diff --git a/topic/topicreader/errors.go b/topic/topicreader/errors.go
@@ -9,7 +9,7 @@ import (
 
 // ErrUnexpectedCodec will return if topicreader receive message with unknown codec.
 // client side must check error with errors.Is
-var ErrUnexpectedCodec = topicreaderinternal.PublicErrUnexpectedCodec
+var ErrUnexpectedCodec = topicreaderinternal.ErrPublicUnexpectedCodec
 
 // ErrConcurrencyCall return if method on reader called in concurrency
 // client side must check error with errors.Is

Original file line number	Diff line number	Diff line change
`@@ -32,30 +32,30 @@ func TestNodeErrorIs(t *testing.T) {`
`32`	`32`	`require.NotErrorIs(t, nodeErr, testErr2)`
`33`	`33`	`}`
`34`	`34`
`35`		`-type testErrorType1 struct {`
	`35`	`+type testType1Error struct {`
`36`	`36`	`msg string`
`37`	`37`	`}`
`38`	`38`
`39`		`-func (t testErrorType1) Error() string {`
	`39`	`+func (t testType1Error) Error() string {`
`40`	`40`	`return "1 - " + t.msg`
`41`	`41`	`}`
`42`	`42`
`43`		`-type testErrorType2 struct {`
	`43`	`+type testType2Error struct {`
`44`	`44`	`msg string`
`45`	`45`	`}`
`46`	`46`
`47`		`-func (t testErrorType2) Error() string {`
	`47`	`+func (t testType2Error) Error() string {`
`48`	`48`	`return "2 - " + t.msg`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`func TestNodeErrorAs(t *testing.T) {`
`52`		`- testErr := testErrorType1{msg: "test"}`
	`52`	`+ testErr := testType1Error{msg: "test"}`
`53`	`53`	`nodeErr := newConnError(1, "localhost:1234", testErr)`
`54`	`54`
`55`		`- target := testErrorType1{}`
	`55`	`+ target := testType1Error{}`
`56`	`56`	`require.ErrorAs(t, nodeErr, &target)`
`57`	`57`	`require.Equal(t, testErr, target)`
`58`	`58`
`59`		`- target2 := testErrorType2{}`
	`59`	`+ target2 := testType2Error{}`
`60`	`60`	`require.False(t, errors.As(nodeErr, &target2))`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ func (m *decoderMap) Decode(codec rawtopiccommon.Codec, input io.Reader) (io.Rea`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`return nil, xerrors.WithStackTrace(xerrors.Wrap(`
`39`		`- fmt.Errorf("ydb: failed decompress message with codec %v: %w", codec, PublicErrUnexpectedCodec),`
	`39`	`+ fmt.Errorf("ydb: failed decompress message with codec %v: %w", codec, ErrPublicUnexpectedCodec),`
`40`	`40`	`))`
`41`	`41`	`}`
`42`	`42`
Original file line number	Diff line number	Diff line change
`@@ -4,39 +4,39 @@ import (`
`4`	`4`	`"github.com/ydb-platform/ydb-go-sdk/v3/internal/stack"`
`5`	`5`	`)`
`6`	`6`
`7`		`-var _ error = (*ctxErr)(nil)`
	`7`	`+var _ error = (*ctxError)(nil)`
`8`	`8`
`9`	`9`	`const (`
`10`	`10`	`atWord = "at"`
`11`	`11`	`fromWord = "from"`
`12`	`12`	`)`
`13`	`13`
`14`	`14`	`func errAt(err error, skipDepth int) error {`
`15`		`- return &ctxErr{`
	`15`	`+ return &ctxError{`
`16`	`16`	`err: err,`
`17`	`17`	`stackRecord: stack.Record(skipDepth + 1),`
`18`	`18`	`linkWord: atWord,`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`func errFrom(err error, from string) error {`
`23`		`- return &ctxErr{`
	`23`	`+ return &ctxError{`
`24`	`24`	`err: err,`
`25`	`25`	`stackRecord: from,`
`26`	`26`	`linkWord: fromWord,`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`		`-type ctxErr struct {`
	`30`	`+type ctxError struct {`
`31`	`31`	`err error`
`32`	`32`	`stackRecord string`
`33`	`33`	`linkWord string`
`34`	`34`	`}`
`35`	`35`
`36`		`-func (e *ctxErr) Error() string {`
	`36`	`+func (e *ctxError) Error() string {`
`37`	`37`	return "'" + e.err.Error() + "' " + e.linkWord + " `" + e.stackRecord + "`"
`38`	`38`	`}`
`39`	`39`
`40`		`-func (e *ctxErr) Unwrap() error {`
	`40`	`+func (e *ctxError) Unwrap() error {`
`41`	`41`	`return e.err`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@ import (`
`6`	`6`	`"github.com/ydb-platform/ydb-go-sdk/v3/internal/xstring"`
`7`	`7`	`)`
`8`	`8`
`9`		`-func Join(errs ...error) joinError {`
	`9`	`+func Join(errs ...error) joinErrors {`
`10`	`10`	`return errs`
`11`	`11`	`}`
`12`	`12`
`13`		`-type joinError []error`
	`13`	`+type joinErrors []error`
`14`	`14`
`15`		`-func (errs joinError) Error() string {`
	`15`	`+func (errs joinErrors) Error() string {`
`16`	`16`	`b := xstring.Buffer()`
`17`	`17`	`defer b.Free()`
`18`	`18`	`b.WriteByte('[')`
`@@ -27,7 +27,7 @@ func (errs joinError) Error() string {`
`27`	`27`	`return b.String()`
`28`	`28`	`}`
`29`	`29`
`30`		`-func (errs joinError) As(target interface{}) bool {`
	`30`	`+func (errs joinErrors) As(target interface{}) bool {`
`31`	`31`	`for _, err := range errs {`
`32`	`32`	`if As(err, target) {`
`33`	`33`	`return true`
`@@ -37,7 +37,7 @@ func (errs joinError) As(target interface{}) bool {`
`37`	`37`	`return false`
`38`	`38`	`}`
`39`	`39`
`40`		`-func (errs joinError) Is(target error) bool {`
	`40`	`+func (errs joinErrors) Is(target error) bool {`
`41`	`41`	`for _, err := range errs {`
`42`	`42`	`if Is(err, target) {`
`43`	`43`	`return true`
`@@ -47,6 +47,6 @@ func (errs joinError) Is(target error) bool {`
`47`	`47`	`return false`
`48`	`48`	`}`
`49`	`49`
`50`		`-func (errs joinError) Unwrap() []error {`
	`50`	`+func (errs joinErrors) Unwrap() []error {`
`51`	`51`	`return errs`
`52`	`52`	`}`