added some unit tests for checkpoint

Author: zacharysierakowski

go/base/context_test.go

@@ -61,6 +61,44 @@ func TestGetTableNames(t *testing.T) {
 	}
 }
 
+func TestMoveTableDelName(t *testing.T) {
+	context := NewMigrationContext()
+	// Per-table `_<table>_del` rollback handle, independent of any other table.
+	require.Equal(t, "_some_table_del", context.MoveTableDelName("some_table"))
+	require.Equal(t, "_other_del", context.MoveTableDelName("other"))
+
+	// Honors --timestamp-old-table like the single-table GetOldTableName does.
+	context.TimestampOldTable = true
+	longForm := "Jan 2, 2006 at 3:04pm (MST)"
+	context.StartTime, _ = time.Parse(longForm, "Feb 3, 2013 at 7:54pm (PST)")
+	require.Equal(t, "_some_table_20130203195400_del", context.MoveTableDelName("some_table"))
+}
+
+func TestMoveTablesRunToken(t *testing.T) {
+	// Empty outside move-tables mode.
+	require.Equal(t, "", NewMigrationContext().MoveTablesRunToken())
+
+	context := NewMigrationContext()
+	context.MoveTables.TableNames = []string{"a", "b", "c"}
+	token := context.MoveTablesRunToken()
+	// Fixed length, lowercase hex (12 chars / 48 bits).
+	require.Len(t, token, 12)
+	require.Regexp(t, "^[0-9a-f]{12}$", token)
+	// Deterministic: the same set always yields the same token (so a resumed run
+	// finds the same run-wide artifacts).
+	require.Equal(t, token, context.MoveTablesRunToken())
+
+	// Order-independent: --move-tables=a,b,c and =c,b,a match.
+	reordered := NewMigrationContext()
+	reordered.MoveTables.TableNames = []string{"c", "b", "a"}
+	require.Equal(t, token, reordered.MoveTablesRunToken())
+
+	// A different set yields a different token.
+	different := NewMigrationContext()
+	different.MoveTables.TableNames = []string{"a", "b", "d"}
+	require.NotEqual(t, token, different.MoveTablesRunToken())
+}
+
 func TestGetTriggerNames(t *testing.T) {
 	{
 		context := NewMigrationContext()

go/logic/checkpoint_test.go

@@ -0,0 +1,75 @@
+/*
+   Copyright 2025 GitHub Inc.
+         See https://github.com/github/gh-ost/blob/master/LICENSE
+*/
+
+package logic
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/github/gh-ost/go/sql"
+)
+
+// TestSerializeRangeValues covers the table-agnostic, hex-per-value encoding used
+// to store a move-table's unique-key range in the single checkpoint table.
+func TestSerializeRangeValues(t *testing.T) {
+	// nil ColumnValues serializes to the empty string.
+	require.Equal(t, "", serializeRangeValues(nil))
+
+	// A single integer key: hex of its decimal text ("172" -> 31 37 32).
+	require.Equal(t, "313732", serializeRangeValues(sql.ToColumnValues([]interface{}{172})))
+
+	// A varchar key: hex of the UTF-8 bytes ("code_8" -> 63 6f 64 65 5f 38).
+	require.Equal(t, "636f64655f38", serializeRangeValues(sql.ToColumnValues([]interface{}{"code_8"})))
+
+	// A compound key of heterogeneous types is comma-joined.
+	require.Equal(t, "3235,636f64655f38",
+		serializeRangeValues(sql.ToColumnValues([]interface{}{25, "code_8"})))
+
+	// Raw bytes are hex-encoded as-is.
+	require.Equal(t, "e590",
+		serializeRangeValues(sql.ToColumnValues([]interface{}{[]byte{0xe5, 0x90}})))
+
+	// A nil column value is encoded with the unambiguous NULL token.
+	require.Equal(t, moveTableCheckpointNullToken,
+		serializeRangeValues(sql.ToColumnValues([]interface{}{nil})))
+}
+
+// TestDeserializeRangeValuesRoundTrip verifies the encode->store->decode cycle.
+// Values come back as []byte (accepted directly as prepared-statement args), so
+// the round trip is checked on the serialized (canonical) form, which is what a
+// resumed run actually compares.
+func TestDeserializeRangeValuesRoundTrip(t *testing.T) {
+	orig := sql.ToColumnValues([]interface{}{172, "code_8"})
+	s := serializeRangeValues(orig)
+
+	got := deserializeRangeValues(s, 2)
+	require.Equal(t, s, serializeRangeValues(got), "re-serializing the decoded range must reproduce the stored text")
+
+	vals := got.AbstractValues()
+	require.Len(t, vals, 2)
+	require.Equal(t, []byte("172"), vals[0])
+	require.Equal(t, []byte("code_8"), vals[1])
+}
+
+// TestDeserializeRangeValuesNullToken verifies the NULL marker decodes back to a
+// nil column value while other columns decode normally.
+func TestDeserializeRangeValuesNullToken(t *testing.T) {
+	got := deserializeRangeValues(moveTableCheckpointNullToken+",3235", 2)
+	vals := got.AbstractValues()
+	require.Len(t, vals, 2)
+	require.Nil(t, vals[0])
+	require.Equal(t, []byte("25"), vals[1])
+}
+
+// TestIsEmptyRange verifies the predicate that tells a resumed run a table had no
+// completed chunk yet (so it must restart from the table minimum).
+func TestIsEmptyRange(t *testing.T) {
+	require.True(t, isEmptyRange(nil), "nil range is empty")
+	require.True(t, isEmptyRange(sql.NewColumnValues(0)), "zero-column range is empty")
+	require.True(t, isEmptyRange(deserializeRangeValues(moveTableCheckpointNullToken, 1)), "all-nil range is empty")
+	require.False(t, isEmptyRange(sql.ToColumnValues([]interface{}{1})), "a range with a value is not empty")
+}