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,9 @@ 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 runs only under blob-write-null-on-missing-file, so with only
+    // blob-write-null-on-fetch-failure a missing file is converted as an ordinary fetch failure.
     arrow::FieldVector fields = {arrow::field("f0", arrow::utf8()),
                                  arrow::field("f1", arrow::int32()),
                                  BlobUtils::ToArrowField("blob", true)};
@@ -788,16 +788,44 @@ 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"}));
     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));
+
+    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) {