chainimport: remove skip import operation

Author: mohamedawnallah

chainimport/headers_import.go

@@ -736,28 +736,8 @@ type HeadersImport struct {
 }
 
 // Import is a multi-pass algorithm that loads, validates, and processes
-// headers from the configured import sources into the target header stores. The
-// Import process is currently performed only if the target stores are
-// completely empty except for gensis block/filter header otherwise it is
-// entirely skipped. On first development iteration, it is designed to serve new
-// users who don't yet have headers data, or existing users who are willing to
-// reset their headers data.
+// headers from the configured import sources into the target header stores.
 func (s *HeadersImport) Import(ctx context.Context) (*ImportResult, error) {
-	// Check first if the target header stores are fresh.
-	isFresh, err := s.isTargetFresh(
-		s.options.TargetBlockHeaderStore,
-		s.options.TargetFilterHeaderStore,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to detect if target stores "+
-			"are fresh import failed: %w", err)
-	}
-	if !isFresh {
-		log.Info("Skipping headers import: target header stores are " +
-			"not empty")
-		return &ImportResult{}, nil
-	}
-
 	// Create result structure at the beginning to capture total duration.
 	result := &ImportResult{
 		StartTime: time.Now(),

chainimport/headers_import_test.go

@@ -107,95 +107,6 @@ func TestHeadersConjunctionProperty(t *testing.T) {
 	}
 }
 
-// TestImportSkipOperation tests the import skip operation. It checks that
-// the import is skipped if the target header store is populated with headers.
-func TestImportSkipOperation(t *testing.T) {
-	t.Parallel()
-	ctx := context.Background()
-	type Prep struct {
-		options *ImportOptions
-	}
-	type Verify struct {
-		tc            *testing.T
-		importOptions *ImportOptions
-		importResult  *ImportResult
-	}
-	testCases := []struct {
-		name         string
-		prep         func() Prep
-		verify       func(Verify)
-		expectErr    bool
-		expectErrMsg string
-	}{
-		{
-			name: "TargetFilterStorePopulatedWithHeaders",
-			prep: func() Prep {
-				// Mock target block header store.
-				tBS := &headerfs.MockBlockHeaderStore{}
-				tBS.On("ChainTip").Return(
-					&wire.BlockHeader{}, uint32(0), nil,
-				)
-
-				// Mock target filter header store.
-				tFS := &headerfs.MockFilterHeaderStore{}
-				tFS.On("ChainTip").Return(
-					&chainhash.Hash{}, uint32(3), nil,
-				)
-
-				// Configure header import sources.
-				bIS := "/path/to/blocks"
-				fIS := "/path/to/filters"
-
-				ops := &ImportOptions{
-					BlockHeadersSource:      bIS,
-					FilterHeadersSource:     fIS,
-					TargetBlockHeaderStore:  tBS,
-					TargetFilterHeaderStore: tFS,
-				}
-
-				return Prep{
-					options: ops,
-				}
-			},
-			verify: func(v Verify) {
-				// Verify the default batch size is set.
-				ops := v.importOptions
-				require.Equal(
-					v.tc, DefaultWriteBatchSizePerRegion,
-					ops.WriteBatchSizePerRegion,
-				)
-
-				// Verify no headers added/processed.
-				require.Equal(
-					v.tc, 0, v.importResult.AddedCount,
-				)
-				require.Equal(
-					v.tc, 0, v.importResult.ProcessedCount,
-				)
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			prep := tc.prep()
-			importResult, err := prep.options.Import(ctx)
-			verify := Verify{
-				tc:            t,
-				importOptions: prep.options,
-				importResult:  importResult,
-			}
-			if tc.expectErr {
-				require.ErrorContains(t, err, tc.expectErrMsg)
-				tc.verify(verify)
-				return
-			}
-			require.NoError(t, err)
-			tc.verify(verify)
-		})
-	}
-}
-
 // TestImportOperationOnFileHeaderSource tests the import operation on a file
 // header source. It checks that the import is successful and that the headers
 // are written to the target header stores.
@@ -599,104 +510,6 @@ func TestImportOperationOnHTTPHeaderSource(t *testing.T) {
 	}
 }
 
-// TestTargetStoreFreshnessDetection tests the logic for detecting whether the
-// target header stores are fresh (only contain genesis headers). It covers
-// various combinations of block and filter header heights and error cases.
-func TestTargetStoreFreshnessDetection(t *testing.T) {
-	t.Parallel()
-	testCases := []struct {
-		name                 string
-		blockHeight          uint32
-		filterHeight         uint32
-		expectFresh          bool
-		expectErr            bool
-		expectFilterStoreErr error
-		expectBlockStoreErr  error
-	}{
-		{
-			name:         "OnlyGenesisHeadersExist",
-			blockHeight:  0,
-			filterHeight: 0,
-			expectFresh:  true,
-		},
-		{
-			name:         "BlockHeightGreaterThanZero",
-			blockHeight:  1,
-			filterHeight: 0,
-			expectFresh:  false,
-		},
-		{
-			name:         "FilterHeightGreaterThanZero",
-			blockHeight:  0,
-			filterHeight: 1,
-			expectFresh:  false,
-		},
-		{
-			name:         "BothHeightsGreaterThanZero",
-			blockHeight:  10,
-			filterHeight: 10,
-			expectFresh:  false,
-		},
-		{
-			name:      "ErrorOnBlockStore",
-			expectErr: true,
-			expectBlockStoreErr: errors.New(
-				"failed to get target block header",
-			),
-		},
-		{
-			name:      "ErrorOnFilterStore",
-			expectErr: true,
-			expectFilterStoreErr: errors.New(
-				"failed to get target filter header",
-			),
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Setup mock block header store.
-			mockBlockStore := &headerfs.MockBlockHeaderStore{}
-			mockBlockStore.On("ChainTip").Return(
-				&wire.BlockHeader{}, tc.blockHeight,
-				tc.expectBlockStoreErr,
-			)
-
-			// Setup mock filter header store.
-			mockFilterStore := &headerfs.MockFilterHeaderStore{}
-			mockFilterStore.On("ChainTip").Return(
-				&chainhash.Hash{}, tc.filterHeight,
-				tc.expectFilterStoreErr,
-			)
-
-			// Create importer.
-			importer := &HeadersImport{}
-
-			// Test the function.
-			isFresh, err := importer.isTargetFresh(
-				mockBlockStore, mockFilterStore,
-			)
-			if tc.expectErr {
-				if tc.expectBlockStoreErr != nil {
-					require.ErrorContains(
-						t, err,
-						tc.expectBlockStoreErr.Error(),
-					)
-				}
-				if tc.expectFilterStoreErr != nil {
-					require.ErrorContains(
-						t, err,
-						tc.expectFilterStoreErr.Error(),
-					)
-				}
-				return
-			}
-			require.NoError(t, err)
-			require.Equal(t, isFresh, tc.expectFresh)
-		})
-	}
-}
-
 // TestOpenFileHeaderImportSources tests the open operation on a file header
 // import source.
 func TestOpenFileHeaderImportSources(t *testing.T) {