github.com/ydb-platform/ydb-go-sdk/v3@v3.89.2/testutil/compare_test.go (about)

     1  package testutil
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/ydb-platform/ydb-go-genproto/protos/Ydb"
     8  	"google.golang.org/protobuf/types/known/structpb"
     9  
    10  	"github.com/ydb-platform/ydb-go-sdk/v3/internal/allocator"
    11  	"github.com/ydb-platform/ydb-go-sdk/v3/internal/types"
    12  	"github.com/ydb-platform/ydb-go-sdk/v3/internal/value"
    13  )
    14  
    15  func TestUnwrapOptionalValue(t *testing.T) {
    16  	a := allocator.New()
    17  	defer a.Free()
    18  	v := value.OptionalValue(value.OptionalValue(value.TextValue("a")))
    19  	val := unwrapTypedValue(value.ToYDB(v, a))
    20  	typeID := val.GetType().GetTypeId()
    21  	if typeID != Ydb.Type_UTF8 {
    22  		t.Errorf("Types are different: expected %d, actual %d", Ydb.Type_UTF8, typeID)
    23  	}
    24  	textValue := val.GetValue().GetValue().(*Ydb.Value_TextValue)
    25  	if text := textValue.TextValue; text != "a" {
    26  		t.Errorf("Values are different: expected %q, actual %q", "a", text)
    27  	}
    28  }
    29  
    30  func TestUnwrapPrimitiveValue(t *testing.T) {
    31  	a := allocator.New()
    32  	defer a.Free()
    33  	v := value.TextValue("a")
    34  	val := unwrapTypedValue(value.ToYDB(v, a))
    35  	typeID := val.GetType().GetTypeId()
    36  	if typeID != Ydb.Type_UTF8 {
    37  		t.Errorf("Types are different: expected %d, actual %d", Ydb.Type_UTF8, typeID)
    38  	}
    39  	textValue := val.GetValue().GetValue().(*Ydb.Value_TextValue)
    40  	if text := textValue.TextValue; text != "a" {
    41  		t.Errorf("Values are different: expected %q, actual %q", "a", text)
    42  	}
    43  }
    44  
    45  func TestUnwrapNullValue(t *testing.T) {
    46  	a := allocator.New()
    47  	defer a.Free()
    48  	v := value.NullValue(types.Text)
    49  	val := unwrapTypedValue(value.ToYDB(v, a))
    50  	typeID := val.GetType().GetTypeId()
    51  	if typeID != Ydb.Type_UTF8 {
    52  		t.Errorf("Types are different: expected %d, actual %d", Ydb.Type_UTF8, typeID)
    53  	}
    54  	nullFlagValue := val.GetValue().GetValue().(*Ydb.Value_NullFlagValue)
    55  	if nullFlagValue.NullFlagValue != structpb.NullValue_NULL_VALUE {
    56  		t.Errorf("Values are different: expected %d, actual %d", structpb.NullValue_NULL_VALUE, nullFlagValue.NullFlagValue)
    57  	}
    58  }
    59  
    60  func TestUint8(t *testing.T) {
    61  	l := value.Uint8Value(byte(1))
    62  	r := value.Uint8Value(byte(10))
    63  	c, err := Compare(l, r)
    64  	requireNoError(t, err)
    65  	requireEqualValues(t, -1, c)
    66  
    67  	c, err = Compare(r, l)
    68  	requireNoError(t, err)
    69  	requireEqualValues(t, 1, c)
    70  
    71  	c, err = Compare(l, l)
    72  	requireNoError(t, err)
    73  	requireEqualValues(t, 0, c)
    74  }
    75  
    76  func TestInt8(t *testing.T) {
    77  	l := value.Int8Value(int8(1))
    78  	r := value.Int8Value(int8(10))
    79  	c, err := Compare(l, r)
    80  	requireNoError(t, err)
    81  	requireEqualValues(t, -1, c)
    82  
    83  	c, err = Compare(r, l)
    84  	requireNoError(t, err)
    85  	requireEqualValues(t, 1, c)
    86  
    87  	c, err = Compare(l, l)
    88  	requireNoError(t, err)
    89  	requireEqualValues(t, 0, c)
    90  }
    91  
    92  func TestTimestamp(t *testing.T) {
    93  	l := value.TimestampValue(1)
    94  	r := value.TimestampValue(10)
    95  	c, err := Compare(l, r)
    96  	requireNoError(t, err)
    97  	requireEqualValues(t, -1, c)
    98  
    99  	c, err = Compare(r, l)
   100  	requireNoError(t, err)
   101  	requireEqualValues(t, 1, c)
   102  
   103  	c, err = Compare(l, l)
   104  	requireNoError(t, err)
   105  	requireEqualValues(t, 0, c)
   106  }
   107  
   108  func TestDateTime(t *testing.T) {
   109  	l := value.DatetimeValue(1)
   110  	r := value.DatetimeValue(10)
   111  	c, err := Compare(l, r)
   112  	requireNoError(t, err)
   113  	requireEqualValues(t, -1, c)
   114  
   115  	c, err = Compare(r, l)
   116  	requireNoError(t, err)
   117  	requireEqualValues(t, 1, c)
   118  
   119  	c, err = Compare(l, l)
   120  	requireNoError(t, err)
   121  	requireEqualValues(t, 0, c)
   122  }
   123  
   124  func TestUint64(t *testing.T) {
   125  	l := value.Uint64Value(uint64(1))
   126  	r := value.Uint64Value(uint64(10))
   127  	c, err := Compare(l, r)
   128  	requireNoError(t, err)
   129  	requireEqualValues(t, -1, c)
   130  
   131  	c, err = Compare(r, l)
   132  	requireNoError(t, err)
   133  	requireEqualValues(t, 1, c)
   134  
   135  	c, err = Compare(l, l)
   136  	requireNoError(t, err)
   137  	requireEqualValues(t, 0, c)
   138  }
   139  
   140  func TestInt64(t *testing.T) {
   141  	l := value.Int64Value(int64(1))
   142  	r := value.Int64Value(int64(10))
   143  	c, err := Compare(l, r)
   144  	requireNoError(t, err)
   145  	requireEqualValues(t, -1, c)
   146  
   147  	c, err = Compare(r, l)
   148  	requireNoError(t, err)
   149  	requireEqualValues(t, 1, c)
   150  
   151  	c, err = Compare(l, l)
   152  	requireNoError(t, err)
   153  	requireEqualValues(t, 0, c)
   154  }
   155  
   156  func TestDouble(t *testing.T) {
   157  	l := value.DoubleValue(1.0)
   158  	r := value.DoubleValue(2.0)
   159  	c, err := Compare(l, r)
   160  	requireNoError(t, err)
   161  	requireEqualValues(t, -1, c)
   162  
   163  	c, err = Compare(r, l)
   164  	requireNoError(t, err)
   165  	requireEqualValues(t, 1, c)
   166  
   167  	c, err = Compare(l, l)
   168  	requireNoError(t, err)
   169  	requireEqualValues(t, 0, c)
   170  }
   171  
   172  func TestFloat(t *testing.T) {
   173  	l := value.FloatValue(1.0)
   174  	r := value.FloatValue(2.0)
   175  	c, err := Compare(l, r)
   176  	requireNoError(t, err)
   177  	requireEqualValues(t, -1, c)
   178  
   179  	c, err = Compare(r, l)
   180  	requireNoError(t, err)
   181  	requireEqualValues(t, 1, c)
   182  
   183  	c, err = Compare(l, l)
   184  	requireNoError(t, err)
   185  	requireEqualValues(t, 0, c)
   186  }
   187  
   188  func TestUTF8(t *testing.T) {
   189  	l := value.TextValue("abc")
   190  	r := value.TextValue("abx")
   191  	c, err := Compare(l, r)
   192  	requireNoError(t, err)
   193  	requireEqualValues(t, -1, c)
   194  
   195  	c, err = Compare(r, l)
   196  	requireNoError(t, err)
   197  	requireEqualValues(t, 1, c)
   198  
   199  	c, err = Compare(l, l)
   200  	requireNoError(t, err)
   201  	requireEqualValues(t, 0, c)
   202  }
   203  
   204  func TestOptionalUTF8(t *testing.T) {
   205  	l := value.OptionalValue(value.OptionalValue(value.TextValue("abc")))
   206  	r := value.TextValue("abx")
   207  	c, err := Compare(l, r)
   208  	requireNoError(t, err)
   209  	requireEqualValues(t, -1, c)
   210  
   211  	c, err = Compare(r, l)
   212  	requireNoError(t, err)
   213  	requireEqualValues(t, 1, c)
   214  
   215  	c, err = Compare(l, l)
   216  	requireNoError(t, err)
   217  	requireEqualValues(t, 0, c)
   218  }
   219  
   220  func TestBytes(t *testing.T) {
   221  	l := value.BytesValue([]byte{1, 2, 3})
   222  	r := value.BytesValue([]byte{1, 2, 5})
   223  	c, err := Compare(l, r)
   224  	requireNoError(t, err)
   225  	requireEqualValues(t, -1, c)
   226  
   227  	c, err = Compare(r, l)
   228  	requireNoError(t, err)
   229  	requireEqualValues(t, 1, c)
   230  
   231  	c, err = Compare(l, l)
   232  	requireNoError(t, err)
   233  	requireEqualValues(t, 0, c)
   234  }
   235  
   236  func TestNull(t *testing.T) {
   237  	l := value.NullValue(types.Text)
   238  	r := value.TextValue("abc")
   239  
   240  	c, err := Compare(l, r)
   241  	requireNoError(t, err)
   242  	requireEqualValues(t, -1, c)
   243  
   244  	c, err = Compare(r, l)
   245  	requireNoError(t, err)
   246  	requireEqualValues(t, 1, c)
   247  
   248  	c, err = Compare(l, l)
   249  	requireNoError(t, err)
   250  	requireEqualValues(t, 0, c)
   251  }
   252  
   253  func TestTuple(t *testing.T) {
   254  	withNull := value.TupleValue(value.Uint64Value(1), value.NullValue(types.Text))
   255  	least := value.TupleValue(value.Uint64Value(1), value.TextValue("abc"))
   256  	medium := value.TupleValue(value.Uint64Value(1), value.TextValue("def"))
   257  	largest := value.TupleValue(value.Uint64Value(2), value.TextValue("abc"))
   258  
   259  	c, err := Compare(least, medium)
   260  	requireNoError(t, err)
   261  	requireEqualValues(t, -1, c)
   262  
   263  	c, err = Compare(least, largest)
   264  	requireNoError(t, err)
   265  	requireEqualValues(t, -1, c)
   266  
   267  	c, err = Compare(largest, medium)
   268  	requireNoError(t, err)
   269  	requireEqualValues(t, 1, c)
   270  
   271  	c, err = Compare(withNull, least)
   272  	requireNoError(t, err)
   273  	requireEqualValues(t, -1, c)
   274  
   275  	c, err = Compare(withNull, withNull)
   276  	requireNoError(t, err)
   277  	requireEqualValues(t, 0, c)
   278  }
   279  
   280  func TestList(t *testing.T) {
   281  	least := value.ListValue(value.Uint64Value(1), value.Uint64Value(1))
   282  	medium := value.ListValue(value.Uint64Value(1), value.Uint64Value(2))
   283  	largest := value.ListValue(value.Uint64Value(2), value.Uint64Value(1))
   284  
   285  	c, err := Compare(least, medium)
   286  	requireNoError(t, err)
   287  	requireEqualValues(t, -1, c)
   288  
   289  	c, err = Compare(least, largest)
   290  	requireNoError(t, err)
   291  	requireEqualValues(t, -1, c)
   292  
   293  	c, err = Compare(largest, medium)
   294  	requireNoError(t, err)
   295  	requireEqualValues(t, 1, c)
   296  }
   297  
   298  func TestDyNumber(t *testing.T) {
   299  	l := value.DyNumberValue("2")
   300  	r := value.DyNumberValue("12")
   301  	c, err := Compare(l, r)
   302  	requireNoError(t, err)
   303  	requireEqualValues(t, -1, c)
   304  
   305  	c, err = Compare(r, l)
   306  	requireNoError(t, err)
   307  	requireEqualValues(t, 1, c)
   308  
   309  	c, err = Compare(l, l)
   310  	requireNoError(t, err)
   311  	requireEqualValues(t, 0, c)
   312  }
   313  
   314  func TestUUID(t *testing.T) {
   315  	l := value.UUIDWithIssue1501Value([16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16})
   316  	r := value.UUIDWithIssue1501Value([16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17})
   317  	g := value.UUIDWithIssue1501Value([16]byte{100, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17})
   318  	c, err := Compare(l, r)
   319  	requireNoError(t, err)
   320  	requireEqualValues(t, -1, c)
   321  
   322  	c, err = Compare(l, g)
   323  	requireNoError(t, err)
   324  	requireEqualValues(t, -1, c)
   325  
   326  	c, err = Compare(r, l)
   327  	requireNoError(t, err)
   328  	requireEqualValues(t, 1, c)
   329  
   330  	c, err = Compare(l, l)
   331  	requireNoError(t, err)
   332  	requireEqualValues(t, 0, c)
   333  }
   334  
   335  func TestIncompatiblePrimitives(t *testing.T) {
   336  	l := value.Uint64Value(1)
   337  	r := value.TimestampValue(2)
   338  	_, err := Compare(l, r)
   339  	if err == nil {
   340  		t.Errorf("WithStackTrace expected")
   341  	}
   342  	if !errors.Is(err, ErrNotComparable) {
   343  		t.Errorf("Unexpected error: %v", err)
   344  	}
   345  }
   346  
   347  func TestIncompatibleTuples(t *testing.T) {
   348  	l := value.TupleValue(value.Uint64Value(1), value.TextValue("abc"))
   349  	r := value.TupleValue(value.Uint64Value(1), value.BytesValue([]byte("abc")))
   350  	if _, err := Compare(l, r); err == nil {
   351  		t.Error("WithStackTrace expected")
   352  	} else if !errors.Is(err, ErrNotComparable) {
   353  		t.Errorf("Unexpected error: %v", err)
   354  	}
   355  }
   356  
   357  func TestTupleOfDifferentLength(t *testing.T) {
   358  	l := value.TupleValue(value.Uint64Value(1), value.TextValue("abc"))
   359  	r := value.TupleValue(value.Uint64Value(1), value.TextValue("abc"), value.TextValue("def"))
   360  
   361  	cmp, err := Compare(l, r)
   362  	requireNoError(t, err)
   363  	requireEqualValues(t, -1, cmp)
   364  
   365  	cmp, err = Compare(r, l)
   366  	requireNoError(t, err)
   367  	requireEqualValues(t, 1, cmp)
   368  }
   369  
   370  func TestTupleInTuple(t *testing.T) {
   371  	l := value.TupleValue(value.Uint64Value(1), value.TupleValue(value.TextValue("abc"), value.BytesValue([]byte("xyz"))))
   372  	r := value.TupleValue(value.Uint64Value(1), value.TupleValue(value.TextValue("def"), value.BytesValue([]byte("xyz"))))
   373  
   374  	cmp, err := Compare(l, r)
   375  	requireNoError(t, err)
   376  	requireEqualValues(t, -1, cmp)
   377  
   378  	cmp, err = Compare(r, l)
   379  	requireNoError(t, err)
   380  	requireEqualValues(t, 1, cmp)
   381  
   382  	cmp, err = Compare(l, l)
   383  	requireNoError(t, err)
   384  	requireEqualValues(t, 0, cmp)
   385  }
   386  
   387  func TestListInList(t *testing.T) {
   388  	l := value.ListValue(
   389  		value.ListValue(
   390  			value.TextValue("abc"), value.TextValue("def"),
   391  		), value.ListValue(
   392  			value.TextValue("uvw"), value.TextValue("xyz"),
   393  		),
   394  	)
   395  	r := value.ListValue(
   396  		value.ListValue(
   397  			value.TextValue("abc"), value.TextValue("deg"),
   398  		), value.ListValue(
   399  			value.TextValue("uvw"), value.TextValue("xyz"),
   400  		),
   401  	)
   402  
   403  	cmp, err := Compare(l, r)
   404  	requireNoError(t, err)
   405  	requireEqualValues(t, -1, cmp)
   406  
   407  	cmp, err = Compare(r, l)
   408  	requireNoError(t, err)
   409  	requireEqualValues(t, 1, cmp)
   410  
   411  	cmp, err = Compare(l, l)
   412  	requireNoError(t, err)
   413  	requireEqualValues(t, 0, cmp)
   414  }
   415  
   416  func requireNoError(t *testing.T, err error) {
   417  	t.Helper()
   418  	if err != nil {
   419  		t.Errorf("Unexpected error %v", err)
   420  	}
   421  }
   422  
   423  func requireEqualValues(t *testing.T, expected int, actual int) {
   424  	t.Helper()
   425  	if expected != actual {
   426  		t.Errorf("Values not equal: expected %v, actual %v", expected, actual)
   427  	}
   428  }