Changes from review.

Author: shaunrd0

test/regression/CMakeLists.txt

@@ -48,7 +48,6 @@ if (TILEDB_CPP_API)
   list(APPEND SOURCES targets/sc-25116.cc)
   list(APPEND SOURCES targets/sc-29682.cc)
   list(APPEND SOURCES targets/sc-33480.cc)
-  list(APPEND SOURCES targets/sc-35424.cc)
   list(APPEND SOURCES targets/sc-36372.cc)
   list(APPEND SOURCES targets/sc-38300.cc)
 endif()

test/regression/targets/sc-35424.cc

@@ -1,3 +1,35 @@
+/**
+ * @file cpp-integration-rest-schema-evolution.cc
+ *
+ * @section LICENSE
+ *
+ * The MIT License
+ *
+ * @copyright Copyright (c) 2024 TileDB Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ * Tests the C++ schema evolution API integration with REST server.
+ */
+
 #include <test/support/src/vfs_helpers.h>
 #include <test/support/tdb_catch.h>
 #include "tiledb/sm/c_api/tiledb_struct_def.h"

test/src/cpp-integration-rest-schema-evolution.cc

@@ -461,7 +461,7 @@ HandleLoadArraySchemaRequestFx::call_handler(
   REQUIRE(rval == TILEDB_OK);
 
   return serialization::deserialize_load_array_schema_response(
-      stype, resp_buf->buffer(), memory_tracker_);
+      uri_, stype, resp_buf->buffer(), memory_tracker_);
 }
 
 shared_ptr<ArraySchema> HandleQueryPlanRequestFx::create_schema() {

test/src/unit-request-handlers.cc

@@ -5,7 +5,7 @@
  *
  * The MIT License
  *
- * @copyright Copyright (c) 2023 TileDB Inc.
+ * @copyright Copyright (c) 2024 TileDB Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -27,7 +27,7 @@
  *
  * @section DESCRIPTION
  *
- * Tests tiledb_array_schema_load* functions via a REST server.
+ * Tests tiledb_array_schema_load* functions across VFS backends and REST.
  */
 
 #include "test/support/src/vfs_helpers.h"
@@ -40,19 +40,21 @@
 
 using namespace tiledb;
 
-struct RESTArraySchemaLoadFx {
-  RESTArraySchemaLoadFx();
-  ~RESTArraySchemaLoadFx() = default;
+struct ArraySchemaLoadFx {
+  ArraySchemaLoadFx();
+  ~ArraySchemaLoadFx() = default;
 
   void create_array();
+  void check_schema(const ArraySchema& schema) const;
 
   test::VFSTestSetup vfs_test_setup_;
   std::string uri_;
   Context ctx_;
+  ArraySchema schema_;
 };
 
 TEST_CASE_METHOD(
-    RESTArraySchemaLoadFx,
+    ArraySchemaLoadFx,
     "Simple schema load test",
     "[rest][array-schema][simple-load]") {
   create_array();
@@ -68,10 +70,12 @@ TEST_CASE_METHOD(
   REQUIRE_THROWS_WITH(
       ArraySchemaExperimental::get_enumeration(ctx_, schema, "my_enum"),
       matcher);
+
+  check_schema(schema);
 }
 
 TEST_CASE_METHOD(
-    RESTArraySchemaLoadFx,
+    ArraySchemaLoadFx,
     "Simple schema load with enumerations test",
     "[rest][array-schema][simple-load-with-enumerations]") {
   create_array();
@@ -80,15 +84,18 @@ TEST_CASE_METHOD(
       ArrayExperimental::load_schema_with_enumerations(ctx_, uri_);
   REQUIRE_NOTHROW(
       ArraySchemaExperimental::get_enumeration(ctx_, schema, "my_enum"));
+
+  check_schema(schema);
 }
 
-RESTArraySchemaLoadFx::RESTArraySchemaLoadFx()
+ArraySchemaLoadFx::ArraySchemaLoadFx()
     : vfs_test_setup_()
     , uri_(vfs_test_setup_.array_uri("array-schema-load-tests"))
-    , ctx_(vfs_test_setup_.ctx()) {
+    , ctx_(vfs_test_setup_.ctx())
+    , schema_(ctx_, TILEDB_DENSE) {
 }
 
-void RESTArraySchemaLoadFx::create_array() {
+void ArraySchemaLoadFx::create_array() {
   // Create a simple array for testing. This ends up with just five elements in
   // the array. dim is an int32_t dimension, attr1 is an enumeration with string
   // values and int32_t attribute values. attr2 is a float attribute.
@@ -99,24 +106,45 @@ void RESTArraySchemaLoadFx::create_array() {
   // dim = {1, 2, 3, 4, 5}
   // attr1 = {"fred", "wilma", "barney", "wilma", "fred"}
   // attr2 = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f}
-  ArraySchema schema(ctx_, TILEDB_DENSE);
-
   auto dim = Dimension::create<int>(ctx_, "dim", {{-100, 100}});
   auto dom = Domain(ctx_);
   dom.add_dimension(dim);
-  schema.set_domain(dom);
+  schema_.set_domain(dom);
 
   // The list of string values in the attr1 enumeration
   std::vector<std::string> values = {"fred", "wilma", "barney", "pebbles"};
   auto enmr = Enumeration::create(ctx_, "my_enum", values);
-  ArraySchemaExperimental::add_enumeration(ctx_, schema, enmr);
+  ArraySchemaExperimental::add_enumeration(ctx_, schema_, enmr);
 
   auto attr1 = Attribute::create<int>(ctx_, "attr1");
   AttributeExperimental::set_enumeration_name(ctx_, attr1, "my_enum");
-  schema.add_attribute(attr1);
+  schema_.add_attribute(attr1);
 
   auto attr2 = Attribute::create<float>(ctx_, "attr2");
-  schema.add_attribute(attr2);
+  schema_.add_attribute(attr2);
+
+  Array::create(uri_, schema_);
+}
 
-  Array::create(uri_, schema);
+void ArraySchemaLoadFx::check_schema(const ArraySchema& schema) const {
+  CHECK(schema.array_type() == schema_.array_type());
+  CHECK(schema.attributes().size() == schema_.attributes().size());
+  for (unsigned int i = 0; i < schema.attribute_num(); i++) {
+    auto a = schema_.attribute(i);
+    auto b = schema.attribute(i);
+    CHECK(a.cell_val_num() == b.cell_val_num());
+    CHECK(a.name() == b.name());
+    CHECK(a.type() == b.type());
+    CHECK(a.nullable() == b.nullable());
+    CHECK(
+        AttributeExperimental::get_enumeration_name(ctx_, a) ==
+        AttributeExperimental::get_enumeration_name(ctx_, b));
+  }
+  CHECK(schema.capacity() == schema_.capacity());
+  CHECK(schema.cell_order() == schema_.cell_order());
+  CHECK(schema.tile_order() == schema_.tile_order());
+  CHECK(schema.allows_dups() == schema_.allows_dups());
+  CHECK(
+      schema.ptr()->array_schema_->array_uri().to_string() ==
+      sm::URI(uri_).to_string());
 }

test/src/unit-rest-array-schema-load.cc

@@ -123,7 +123,7 @@ shared_ptr<ArraySchema> ArrayDirectory::load_array_schema_latest(
   auto&& array_schema = load_array_schema_from_uri(
       resources_.get(), schema_uri, encryption_key, memory_tracker);
 
-  array_schema->set_array_uri(uri_);
+  array_schema->set_array_uri(uri_.remove_trailing_slash());
 
   return std::move(array_schema);
 }