test

Author: Shubham8287

crates/schema/tests/ensure_same_schema.rs

@@ -103,27 +103,25 @@ fn ensure_same_schema_rust_csharp_benchmarks() {
 fn test_case_converted_names() {
     let module_def: ModuleDef = get_normalized_schema("module-test");
 
-    // println!("Types {:?}", module_def.types().collect::<Vec<_>>());
+    //  println!("Types {:?}", module_def.lookup::<TableDef>::(Identifier::for_test("person")).unwrap().columns().collect::<Vec<_>>());
 
     // println!("Types space {:?}", module_def.typespace());
 
     // Test Tables
     let table_names = [
-        // Accessor is CamelCase in modules.
-        "test_a_table",
-        // Uses explicit canonical name
-        "Person",
+        // canonical name, accessor name
+        ("test_a", "TestATable"),
     ];
-    for name in table_names {
-        assert!(
-            TableDef::lookup(&module_def, &Identifier::for_test(name)).is_some(),
-            "Table '{}' not found",
-            name
-        );
+    for (name, accessor) in table_names {
+        let def = TableDef::lookup(&module_def, &Identifier::for_test(name));
+
+        assert!(def.is_some(), "Table '{}' not found", name);
+
+        assert_eq!(&*def.unwrap().accessor_name, &*accessor, "Table '{}' not found", name);
     }
 
     // Test Reducers
-    let reducer_names = [];
+    let reducer_names = ["list_over_age", "repeating_test"];
     for name in reducer_names {
         assert!(
             ReducerDef::lookup(&module_def, &ReducerName::for_test(name)).is_some(),
@@ -133,7 +131,7 @@ fn test_case_converted_names() {
     }
 
     // Test Procedures
-    let procedure_names = ["get_my_schema_via_http"];
+    let procedure_names = ["get_my_test_via_http"];
     for name in procedure_names {
         assert!(
             ProcedureDef::lookup(&module_def, &Identifier::for_test(name)).is_some(),
@@ -142,49 +140,34 @@ fn test_case_converted_names() {
         );
     }
 
-    // Test Views
-    // let view_names = ["my_player"];
-    // for name in view_names {
-    //     assert!(
-    //         ViewDef::lookup(&module_def, &Identifier::for_test(name)).is_some(),
-    //         "View '{}' not found",
-    //         name
-    //     );
-    // }
+    //  Test Views
+    let view_names = ["my_player"];
+    for name in view_names {
+        assert!(
+            ViewDef::lookup(&module_def, &Identifier::for_test(name)).is_some(),
+            "View '{}' not found",
+            name
+        );
+    }
 
     // Test Types
-    //    let type_names = [
-    //        "PkMultiIdentity",
-    //        "PrivateTable",
-    //        "Baz",
-    //        "TestA",
-    //        "TestFoobar",
-    //        "TestE",
-    //        "RemoveTable",
-    //        "Foobar",
-    //        "Player",
-    //        "RepeatingTestArg",
-    //        "Person",
-    //        "Point",
-    //        "TestB",
-    //        "HasSpecialStuff",
-    //        "TestD",
-    //        "Namespace::TestF",
-    //        "Namespace::TestC",
-    //    ];
-    //    for name in type_names {
-    //        assert!(
-    //            TypeDef::lookup(&module_def, &ScopedTypeName::new(name)).is_some(),
-    //            "Type '{}' not found",
-    //            name
-    //        );
-    //    }
-    //
+    let type_names = [
+        // types are Pascal case
+        "TestB", "Person",
+    ];
+    for name in type_names {
+        assert!(
+            TypeDef::lookup(&module_def, &ScopedTypeName::new([].into(), Identifier::for_test(name))).is_some(),
+            "Type '{}' not found",
+            name
+        );
+    }
+
     // Test Indexes (using lookup via stored_in_table_def)
     let index_names = [
-        "Person_age_idx_btree",
-        "Person_id_idx_btree",
-        "test_a_table_x_idx_btree",
+        // index name should be generated from canonical name
+        "test_a_x_idx_btree",
+        "person_id_idx_btree",
     ];
     for index_name in index_names {
         assert!(
@@ -194,17 +177,8 @@ fn test_case_converted_names() {
         );
     }
 
-    let index_names_and_alias = [("person_age_idx_btree", "P")];
-    // for (index_name, alias) in index_names {
-    //     assert!(
-    //         &IndexDef::lookup(&module_def, &RawIdentifier::new(index_name)).expect("index exists").accessor_name,
-    //         "Index '{}' not found",
-    //         alias
-    //     );
-    // }
-
     // Test Constraints
-    let constraint_names = ["Person_id_key"];
+    let constraint_names = ["person_id_key"];
     for constraint_name in constraint_names {
         assert!(
             ConstraintDef::lookup(&module_def, &RawIdentifier::new(constraint_name)).is_some(),
@@ -214,7 +188,7 @@ fn test_case_converted_names() {
     }
 
     // Test Sequences
-    let sequence_names = ["Person_id_seq"];
+    let sequence_names = ["person_id_seq"];
     for sequence_name in sequence_names {
         assert!(
             SequenceDef::lookup(&module_def, &RawIdentifier::new(sequence_name)).is_some(),
@@ -232,7 +206,8 @@ fn test_case_converted_names() {
     );
 
     // Test Columns (using composite key: table_name, column_name)
-    let column_names = [("Person", "id")];
+    // Id has bigger case in accessor
+    let column_names = [("person", "id")];
     for (table_name, col_name) in column_names {
         assert!(
             ColumnDef::lookup(
@@ -245,22 +220,4 @@ fn test_case_converted_names() {
             col_name
         );
     }
-
-    // Test View Columns
-    // let view_column_names = [
-    //     ("my_player", "identity"),
-    //     ("my_player", "player_id"),
-    //     ("my_player", "name"),
-    // ];
-    // for (view_name, col_name) in view_column_names {
-    //     assert!(
-    //         ViewColumnDef::lookup(
-    //             &module_def,
-    //             (&Identifier::for_test(view_name), &Identifier::for_test(col_name))
-    //         )
-    //         .is_some(),
-    //         "View column '{}.{}' not found",
-    //         view_name,
-    //         col_name
-    //     );
 }

modules/module-test-ts/src/index.ts

@@ -22,7 +22,7 @@ type TestAlias = TestA;
 // ─────────────────────────────────────────────────────────────────────────────
 
 // Rust: #[derive(SpacetimeType)] pub struct TestB { foo: String }
-const testB = t.object('TestB', {
+const testB = t.object('testB', {
   foo: t.string(),
 });
 type TestB = Infer<typeof testB>;
@@ -151,7 +151,6 @@ const spacetimedb = schema({
   // person (public) with btree index on age
   person: table(
     {
-      name: 'Person',
       public: true,
       indexes: [{ name: 'age', algorithm: 'btree', columns: ['age'] }],
     },
@@ -161,6 +160,7 @@ const spacetimedb = schema({
   // test_a with index foo on x
   testATable: table(
     {
+      name: "test_a",
       indexes: [{ name: 'foo', algorithm: 'btree', columns: ['x'] }],
     },
     testA
@@ -207,7 +207,7 @@ const spacetimedb = schema({
   repeatingTestArg: table(
     {
       name: 'repeating_test_arg',
-      scheduled: (): any => repeating_test,
+      scheduled: (): any => repeatingTest
     },
     repeatingTestArg
   ),
@@ -229,8 +229,8 @@ export default spacetimedb;
 // VIEWS
 // ─────────────────────────────────────────────────────────────────────────────
 
-export const my_player = spacetimedb.view(
-  { name: 'my_player', public: true },
+export const myPlayer = spacetimedb.view(
+  { public: true },
   playerLikeRow.optional(),
   // FIXME: this should not be necessary; change `OptionBuilder` to accept `null|undefined` for `none`
   ctx => ctx.db.player.identity.find(ctx.sender) ?? undefined
@@ -250,7 +250,7 @@ export const init = spacetimedb.init(ctx => {
 });
 
 // repeating_test
-export const repeating_test = spacetimedb.reducer(
+export const repeatingTest = spacetimedb.reducer(
   { arg: repeatingTestArg },
   (ctx, { arg }) => {
     const delta = ctx.timestamp.since(arg.prev_time); // adjust if API differs
@@ -275,7 +275,7 @@ export const say_hello = spacetimedb.reducer(ctx => {
 });
 
 // list_over_age(age)
-export const list_over_age = spacetimedb.reducer(
+export const listOverAge = spacetimedb.reducer(
   { age: t.u8() },
   (ctx, { age }) => {
     // Prefer an index-based scan if exposed by bindings; otherwise iterate.
@@ -464,7 +464,7 @@ export const assert_caller_identity_is_module_identity = spacetimedb.reducer(
 // Hit SpacetimeDB's schema HTTP route and return its result as a string.
 //
 // This is a silly thing to do, but an effective test of the procedure HTTP API.
-export const get_my_schema_via_http = spacetimedb.procedure(t.string(), ctx => {
+export const getMyTestViaHttp = spacetimedb.procedure(t.string(), ctx => {
   const module_identity = ctx.identity;
   try {
     const response = ctx.http.fetch(

modules/module-test/src/lib.rs

@@ -27,7 +27,7 @@ pub struct Person {
 }
 
 #[cfg(not(feature = "test-add-column"))]
-#[spacetimedb::table(accessor = person, name="Person", public, index(accessor = age, btree(columns = [age])))]
+#[spacetimedb::table(accessor = person, public, index(accessor = age, btree(columns = [age])))]
 pub struct Person {
     #[primary_key]
     #[auto_inc]
@@ -42,15 +42,16 @@ pub struct RemoveTable {
     pub id: u32,
 }
 
-#[spacetimedb::table(accessor = TestATable, index(accessor = foo, btree(columns = [x])))]
+#[spacetimedb::table(accessor = TestATable, name="test_a", index(accessor = foo, btree(columns = [x])))]
 pub struct TestA {
     pub x: u32,
     pub y: u32,
     pub z: String,
 }
 
 #[derive(SpacetimeType)]
-pub struct TestB {
+#[allow(non_camel_case_types)]
+pub struct Test_b {
     foo: String,
 }
 
@@ -204,7 +205,7 @@ impl Foo<'_> {
 // VIEWS
 // ─────────────────────────────────────────────────────────────────────────────
 
-#[spacetimedb::view(accessor = myOwnPlayer, public)]
+#[spacetimedb::view(accessor = myPlayer, public)]
 fn my_player(ctx: &ViewContext) -> Option<Player> {
     ctx.db.player().identity().find(ctx.sender())
 }
@@ -253,7 +254,7 @@ pub fn say_hello(ctx: &ReducerContext) {
 }
 
 #[spacetimedb::reducer]
-pub fn list_over_age(ctx: &ReducerContext, age: u8) {
+pub fn listOverAge(ctx: &ReducerContext, age: u8) {
     for person in ctx.db.person().age().filter(age..) {
         log::info!("{} has age {} >= {}", person.name, person.age, age);
     }
@@ -265,7 +266,7 @@ fn log_module_identity(ctx: &ReducerContext) {
 }
 
 #[spacetimedb::reducer]
-pub fn test(ctx: &ReducerContext, arg: TestAlias, arg2: TestB, arg3: TestC, arg4: TestF) -> anyhow::Result<()> {
+pub fn test(ctx: &ReducerContext, arg: TestAlias, arg2: Test_b, arg3: TestC, arg4: TestF) -> anyhow::Result<()> {
     log::info!("BEGIN");
     log::info!("sender: {:?}", ctx.sender());
     log::info!("timestamp: {:?}", ctx.timestamp);
@@ -502,8 +503,8 @@ fn with_tx(ctx: &mut ProcedureContext) {
 /// Hit SpacetimeDB's schema HTTP route and return its result as a string.
 ///
 /// This is a silly thing to do, but an effective test of the procedure HTTP API.
-#[spacetimedb::procedure]
-fn get_my_schema_via_http(ctx: &mut ProcedureContext) -> String {
+#[spacetimedb::procedure(name = "get_my_test_via_http")]
+fn getMyTestViaHttp(ctx: &mut ProcedureContext) -> String {
     let module_identity = ctx.identity();
     match ctx.http.get(format!(
         "http://localhost:3000/v1/database/{module_identity}/schema?version=9"