fix(test): let the fetch-failure inte test expect a converted missing file

TestWriteNullOnFetchFailureKeepsMissingFileFailing still asserted that a
missing descriptor file fails the write when only
'blob-write-null-on-fetch-failure' is enabled. That is the behavior the
previous commit deliberately removed: the FileSystem::Exists check that tells
a missing file apart runs only when 'blob-write-null-on-missing-file' needs
the classification, so with just the fetch-failure option a missing file is
an ordinary open failure and is converted to a NULL element. Only the
comment and the expected message were updated, so the test failed on CI in
every build job.

Rename it to TestWriteNullOnFetchFailureCoversMissingFile and assert the
conversion the way the neighbouring write-null tests do: the write and commit
succeed, both files keep the full row count, and the read merges them back
into a row whose blob is NULL.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: SteNicholas

test/inte/blob_table_inte_test.cpp

@@ -766,9 +766,11 @@ TEST_P(BlobTableInteTest, TestWriteNullOnFetchFailure) {
         << "expected:" << expected_with_rk->ToString();
 }
 
-TEST_P(BlobTableInteTest, TestWriteNullOnFetchFailureKeepsMissingFileFailing) {
-    // blob-write-null-on-fetch-failure does not cover a missing file, which is identified with
-    // FileSystem::Exists and left to blob-write-null-on-missing-file.
+TEST_P(BlobTableInteTest, TestWriteNullOnFetchFailureCoversMissingFile) {
+    // The existence check that tells a missing file apart runs only when
+    // blob-write-null-on-missing-file needs the classification. With only
+    // blob-write-null-on-fetch-failure enabled a missing file is just an open failure, so it is
+    // converted to a NULL blob element like any other fetch failure.
     arrow::FieldVector fields = {arrow::field("f0", arrow::utf8()),
                                  arrow::field("f1", arrow::int32()),
                                  BlobUtils::ToArrowField("blob", true)};
@@ -788,16 +790,48 @@ TEST_P(BlobTableInteTest, TestWriteNullOnFetchFailureKeepsMissingFileFailing) {
 
     std::string raw_json = R"([
         ["str_0", 0, "blob_data_0"],
-        ["str_1", 1, "blob_data_1"]
+        ["str_1", 1, "blob_data_1"],
+        ["str_2", 2, "blob_data_2"]
     ])";
     auto raw_array = std::dynamic_pointer_cast<arrow::StructArray>(
         arrow::ipc::internal::json::ArrayFromJSON(arrow::struct_(fields), raw_json).ValueOrDie());
     ASSERT_OK_AND_ASSIGN(auto desc_array, ConvertRawBlobToDescriptor(raw_array, {"blob"}));
+
+    // Remove the file behind row 1's descriptor so the write observes a missing file.
     ASSERT_OK(DeleteDescriptorTarget(desc_array, "blob", /*row=*/1));
 
     auto schema = arrow::schema(fields);
-    ASSERT_NOK_WITH_MSG(WriteArray(table_path, {}, schema->field_names(), {desc_array}),
-                        "does not exist");
+    ASSERT_OK_AND_ASSIGN(auto commit_msgs,
+                         WriteArray(table_path, {}, schema->field_names(), {desc_array}));
+    ASSERT_OK(Commit(table_path, commit_msgs));
+
+    // Both the main data file and the .blob file keep the full row count; the read path
+    // merges them back into rows where row 1's blob is NULL.
+    ASSERT_OK_AND_ASSIGN(auto plan, ScanTable(table_path));
+    VerifyDataFileMetas(plan, /*expected_file_count=*/2, /*expected_row_counts=*/{3, 3},
+                        /*expected_min_seqs=*/{1, 1}, /*expected_max_seqs=*/{1, 1},
+                        /*expected_first_row_ids=*/{0, 0},
+                        /*expected_write_cols=*/
+                        {std::vector<std::string>{"f0", "f1"}, std::vector<std::string>{"blob"}});
+
+    ASSERT_OK_AND_ASSIGN(auto result, ReadTable(table_path, schema->field_names(), plan));
+    ASSERT_TRUE(result.chunked_array);
+    auto read_concat = arrow::Concatenate(result.chunked_array->chunks()).ValueOrDie();
+    auto read_struct = std::dynamic_pointer_cast<arrow::StructArray>(read_concat);
+    ASSERT_OK_AND_ASSIGN(auto resolved, ConvertDescriptorToRawBlob(read_struct, {"blob"}));
+
+    std::string expected_json = R"([
+        ["str_0", 0, "blob_data_0"],
+        ["str_1", 1, null],
+        ["str_2", 2, "blob_data_2"]
+    ])";
+    auto expected_array = std::dynamic_pointer_cast<arrow::StructArray>(
+        arrow::ipc::internal::json::ArrayFromJSON(arrow::struct_(fields), expected_json)
+            .ValueOrDie());
+    ASSERT_OK_AND_ASSIGN(auto expected_with_rk, PrependRowKindColumn(expected_array));
+    ASSERT_TRUE(resolved->Equals(expected_with_rk))
+        << "result:" << resolved->ToString() << std::endl
+        << "expected:" << expected_with_rk->ToString();
 }
 
 TEST_P(BlobTableInteTest, TestBasic) {