tests for reinit

Author: Wondertan

sync/sync_head_test.go

@@ -29,9 +29,10 @@ func TestSyncer_TailInit(t *testing.T) {
 	require.NoError(t, err)
 
 	tests := []struct {
-		name     string
-		option   Option
-		expected func() *headertest.DummyHeader
+		name                 string
+		option               Option
+		expected             func() *headertest.DummyHeader
+		expectedAfterRestart func() *headertest.DummyHeader
 	}{
 		{
 			"Estimate",
@@ -41,27 +42,42 @@ func TestSyncer_TailInit(t *testing.T) {
 				require.NoError(t, err)
 				return remoteTail
 			},
+			func() *headertest.DummyHeader {
+				remoteTail, err := remoteStore.Tail(ctx)
+				require.NoError(t, err)
+				return remoteTail
+			},
 		},
 		{
 			"SyncFromHash",
 			WithSyncFromHash(expectedTail.Hash()),
 			func() *headertest.DummyHeader {
 				return expectedTail
 			},
+			func() *headertest.DummyHeader {
+				expectedTail, err := remoteStore.GetByHeight(ctx, expectedTail.Height()+10)
+				require.NoError(t, err)
+				return expectedTail
+			},
 		},
 		{
 			"SyncFromHeight",
 			WithSyncFromHeight(expectedTail.Height()),
 			func() *headertest.DummyHeader {
 				return expectedTail
 			},
+			func() *headertest.DummyHeader {
+				expectedTail, err := remoteStore.GetByHeight(ctx, expectedTail.Height()-10)
+				require.NoError(t, err)
+				return expectedTail
+			},
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			ds := dssync.MutexWrap(datastore.NewMapDatastore())
-			localStore, err := store.NewStore[*headertest.DummyHeader](ds)
+			localStore, err := store.NewStore[*headertest.DummyHeader](ds, store.WithWriteBatchSize(1))
 			require.NoError(t, err)
 			err = localStore.Start(ctx)
 			require.NoError(t, err)
@@ -77,18 +93,30 @@ func TestSyncer_TailInit(t *testing.T) {
 
 			err = syncer.Start(ctx)
 			require.NoError(t, err)
-
 			time.Sleep(time.Millisecond * 100)
 
+			// check that the syncer has the expected tail and head
 			expectedTail := test.expected()
-
 			storeTail, err := localStore.Tail(ctx)
 			require.NoError(t, err)
 			assert.EqualValues(t, expectedTail.Height(), storeTail.Height())
-
 			storeHead, err := localStore.Head(ctx)
 			require.NoError(t, err)
 			assert.EqualValues(t, remoteStore.Height(), storeHead.Height())
+
+			// restart the Syncer and set a new tail
+			err = syncer.Stop(ctx)
+			require.NoError(t, err)
+			expectedTail = test.expectedAfterRestart()
+			syncer.Params.SyncFromHeight = expectedTail.Height()
+			syncer.Params.SyncFromHash = expectedTail.Hash()
+			err = syncer.Start(ctx)
+			require.NoError(t, err)
+
+			// ensure that the Syncer moved to the new tail after restart
+			storeTail, err = localStore.Tail(ctx)
+			require.NoError(t, err)
+			assert.EqualValues(t, expectedTail.Height(), storeTail.Height())
 		})
 	}
 }

sync/sync_store.go

@@ -48,26 +48,41 @@ func (s *syncStore[H]) Append(ctx context.Context, headers ...H) error {
 	}
 
 	head, err := s.Head(ctx)
-	if err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, header.ErrEmptyStore) {
+	if errors.Is(err, header.ErrEmptyStore) {
+		// short-circuit for an initialization path
+		if err := s.Store.Append(ctx, headers...); err != nil {
+			return err
+		}
+
+		s.head.Store(&headers[len(headers)-1])
+		return nil
+	}
+	if err != nil {
 		return err
 	}
 
-	if !errors.Is(err, header.ErrEmptyStore) {
+	// TODO(@Wondertan): As store evolved, certain invariants it had were removed.
+	//	However, Syncer has yet to be refactored to not assume those invariants and until then
+	//	this method is a shim that allows using store with old assumptions.
+	//  To be reworked by bsync.
+	if headers[0].Height() >= head.Height() {
 		for _, h := range headers {
 			if h.Height() != head.Height()+1 {
 				return &errNonAdjacent{
 					Head:      head.Height(),
 					Attempted: h.Height(),
 				}
 			}
+
 			head = h
 		}
+
+		s.head.Store(&head)
 	}
 
 	if err := s.Store.Append(ctx, headers...); err != nil {
 		return err
 	}
 
-	s.head.Store(&headers[len(headers)-1])
 	return nil
 }