Merge pull request scylladb#510 from sylwiaszunejko/query-error-unit

Add unit test for QueryError

Author: dkropachev

policies_test.go

@@ -400,20 +400,49 @@ func TestSimpleRetryPolicy(t *testing.T) {
 	// this should allow a total of 3 tries.
 	rt := &SimpleRetryPolicy{NumRetries: 2}
 
+	regular_error := errors.New("regular error")
+
+	qe1 := &QueryError{
+		err:                 errors.New("connection error"),
+		potentiallyExecuted: false,
+		isIdempotent:        false,
+	}
+
+	qe2 := &QueryError{
+		err:                 errors.New("timeout error"),
+		potentiallyExecuted: true,
+		isIdempotent:        true,
+	}
+
+	qe3 := &QueryError{
+		err:                 errors.New("write timeout"),
+		potentiallyExecuted: true,
+		isIdempotent:        false,
+	}
+
 	cases := []struct {
-		attempts int
-		allow    bool
+		attempts     int
+		allow        bool
+		err          error
+		retryType    RetryType
+		LWTRetryType RetryType
 	}{
-		{0, true},
-		{1, true},
-		{2, true},
-		{3, false},
-		{4, false},
-		{5, false},
+		{0, true, qe1, RetryNextHost, Retry},
+		{1, true, qe2, RetryNextHost, Retry},
+		{2, true, qe3, Rethrow, Rethrow},
+		{3, false, regular_error, RetryNextHost, Retry},
+		{4, false, regular_error, RetryNextHost, Retry},
+		{5, false, regular_error, RetryNextHost, Retry},
 	}
 
 	for _, c := range cases {
 		q.metrics = preFilledQueryMetrics(map[string]*hostMetrics{"127.0.0.1": {Attempts: c.attempts}})
+		if c.retryType != rt.GetRetryType(c.err) {
+			t.Fatalf("retry type for %v should be %v", c.err, c.retryType)
+		}
+		if c.LWTRetryType != rt.GetRetryTypeLWT(c.err) {
+			t.Fatalf("LWT retry type for %v should be %v", c.err, c.LWTRetryType)
+		}
 		if c.allow && !rt.Attempt(q) {
 			t.Fatalf("should allow retry after %d attempts", c.attempts)
 		}
@@ -439,17 +468,45 @@ func TestExponentialBackoffPolicy(t *testing.T) {
 	// test with defaults
 	sut := &ExponentialBackoffRetryPolicy{NumRetries: 2}
 
+	regular_error := errors.New("regular error")
+
+	qe1 := &QueryError{
+		err:                 errors.New("connection error"),
+		potentiallyExecuted: false,
+		isIdempotent:        false,
+	}
+
+	qe2 := &QueryError{
+		err:                 errors.New("timeout error"),
+		potentiallyExecuted: true,
+		isIdempotent:        true,
+	}
+
+	qe3 := &QueryError{
+		err:                 errors.New("write timeout"),
+		potentiallyExecuted: true,
+		isIdempotent:        false,
+	}
+
 	cases := []struct {
-		attempts int
-		delay    time.Duration
+		attempts     int
+		delay        time.Duration
+		err          error
+		retryType    RetryType
+		LWTRetryType RetryType
 	}{
-
-		{1, 100 * time.Millisecond},
-		{2, (2) * 100 * time.Millisecond},
-		{3, (2 * 2) * 100 * time.Millisecond},
-		{4, (2 * 2 * 2) * 100 * time.Millisecond},
+		{1, 100 * time.Millisecond, qe1, RetryNextHost, Retry},
+		{2, (2) * 100 * time.Millisecond, qe2, RetryNextHost, Retry},
+		{3, (2 * 2) * 100 * time.Millisecond, qe3, Rethrow, Rethrow},
+		{4, (2 * 2 * 2) * 100 * time.Millisecond, regular_error, RetryNextHost, Retry},
 	}
 	for _, c := range cases {
+		if c.retryType != sut.GetRetryType(c.err) {
+			t.Fatalf("retry type for %v should be %v", c.err, c.retryType)
+		}
+		if c.LWTRetryType != sut.GetRetryTypeLWT(c.err) {
+			t.Fatalf("LWT retry type for %v should be %v", c.err, c.LWTRetryType)
+		}
 		// test 100 times for each case
 		for i := 0; i < 100; i++ {
 			d := sut.napTime(c.attempts)

query_error_test.go

@@ -0,0 +1,117 @@
+//go:build unit
+// +build unit
+
+package gocql
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestQueryError_PotentiallyExecuted(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name                string
+		potentiallyExecuted bool
+		expected            bool
+	}{
+		{
+			name:                "potentially executed true",
+			potentiallyExecuted: true,
+			expected:            true,
+		},
+		{
+			name:                "potentially executed false",
+			potentiallyExecuted: false,
+			expected:            false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			qErr := &QueryError{
+				err:                 errors.New("test error"),
+				potentiallyExecuted: tt.potentiallyExecuted,
+			}
+
+			got := qErr.PotentiallyExecuted()
+			if got != tt.expected {
+				t.Fatalf("QueryError.PotentiallyExecuted() = %v, expected %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestQueryError_IsIdempotent(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		isIdempotent bool
+		expected     bool
+	}{
+		{
+			name:         "idempotent true",
+			isIdempotent: true,
+			expected:     true,
+		},
+		{
+			name:         "idempotent false",
+			isIdempotent: false,
+			expected:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			qErr := &QueryError{
+				err:          errors.New("test error"),
+				isIdempotent: tt.isIdempotent,
+			}
+
+			got := qErr.IsIdempotent()
+			if got != tt.expected {
+				t.Errorf("QueryError.IsIdempotent() = %v, expected %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestQueryError_Error(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name                string
+		err                 error
+		potentiallyExecuted bool
+		expected            string
+	}{
+		{
+			name:                "with potentially executed true",
+			err:                 errors.New("connection error"),
+			potentiallyExecuted: true,
+			expected:            "connection error (potentially executed: true)",
+		},
+		{
+			name:                "with potentially executed false",
+			err:                 errors.New("syntax error"),
+			potentiallyExecuted: false,
+			expected:            "syntax error (potentially executed: false)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			qErr := &QueryError{
+				err:                 tt.err,
+				potentiallyExecuted: tt.potentiallyExecuted,
+			}
+
+			got := qErr.Error()
+			if got != tt.expected {
+				t.Errorf("QueryError.Error() = %v, expected %v", got, tt.expected)
+			}
+		})
+	}
+}