Ard2025/e2e

E2eTest/OpenTest.cs

@@ -1,6 +1,8 @@
 using E2eTest.Entities;
 using E2eTest.Extensions;
+using E2eTestWebApp.Models;
 using E2eTestWebApp.TestPages;
+using Magic.IndexedDb;
 
 namespace E2eTest;
 
@@ -10,48 +12,22 @@ public class OpenTest : TestBase<OpenTestPage>
     [TestMethod]
     public async Task DirectOpenTest()
     {
+
         var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("OpenTest.DirectOpen");
+        await page.DeleteDatabaseAsync("Person");
 
         var result = await this.RunTestPageMethodAsync(p => p.DirectOpen);
         Assert.AreEqual("OK", result);
 
         var databases = await page.EvaluateAsync<DatabaseInfo[]>("indexedDB.databases()");
         // The actual version will be 10:
         // https://dexie.org/docs/Dexie/Dexie.version()
-        Assert.IsTrue(databases!.Any(x => x.Name == "OpenTest.DirectOpen" && x.Version == 10));
-    }
-
-    [TestMethod]
-    public async Task RegisteredOpenTest1()
-    {
-        var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("OpenTest.RegisteredOpen1");
-
-        var result = await this.RunTestPageMethodAsync(p => p.RegisteredOpen1);
-        Assert.AreEqual("OK", result);
-
-        var databases = await page.EvaluateAsync<DatabaseInfo[]>("indexedDB.databases()");
-        // The actual version will be 20:
-        // https://dexie.org/docs/Dexie/Dexie.version()
-        Assert.IsTrue(databases!.Any(x => x.Name == "OpenTest.RegisteredOpen1" && x.Version == 20));
-    }
-
-    [TestMethod]
-    public async Task RegisteredOpenTest2()
-    {
-        var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("OpenTest.RegisteredOpen2");
-
-        var result = await this.RunTestPageMethodAsync(p => p.RegisteredOpen2);
-        Assert.AreEqual("OK", result);
-
-        var databases = await page.EvaluateAsync<DatabaseInfo[]>("indexedDB.databases()");
-        // The actual version will be 30:
-        // https://dexie.org/docs/Dexie/Dexie.version()
-        Assert.IsTrue(databases!.Any(x => x.Name == "OpenTest.RegisteredOpen2" && x.Version == 30));
+        Assert.IsTrue(databases!.Any(x => x.Name == "Person" && x.Version == 10));
     }
 
+
+    /*
+    // TODO: port scema test to magicDB v2
     [TestMethod]
     public async Task GetTest()
     {
@@ -93,5 +69,5 @@ public async Task StoreSchemaTest()
                 }
             }
             """, storeSchema);
-    }
+    }*/
 }

E2eTest/SingleRecordBasicTest.cs

@@ -10,105 +10,39 @@ public class SingleRecordBasicTest : TestBase<SingleRecordBasicTestPage>
     public async Task AddTest()
     {
         var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("SingleRecordBasic.Add");
+        await page.DeleteDatabaseAsync("Person");
 
         var result = await this.RunTestPageMethodAsync(p => p.Add);
-        Assert.AreEqual("12", result);
-        var records = await page.EvaluateAsync<string>("getAll('SingleRecordBasic.Add', 'Records')");
-
-        // TODO:
-        // Ignored should not exist here
-        // the property of Nested should be "Value" rather than "value"
-        Assert.That.AreJsonEqual("""
-            [
-                {
-                    "id":12,
-                    "Normal":"Norm",
-                    "Renamed":"R",
-                    "Index":"I",
-                    "UniqueIndex":"633a97d2-0c92-4c68-883b-364f94ad6030",
-                    "Enum":0,
-                    "Nested":{"value":1234},
-                    "LargeNumber":9007199254740991
-                }
-            ]
-            """, records);
+        Assert.AreEqual(result, "OK");
     }
 
     [TestMethod]
     public async Task DeleteTest()
     {
         var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("SingleRecordBasic.Delete");
+        await page.DeleteDatabaseAsync("Person");
 
         var result = await this.RunTestPageMethodAsync(p => p.Delete);
-        Assert.AreEqual("OK", result);
-
-        var records = await page.EvaluateAsync<string>("getAll('SingleRecordBasic.Delete', 'Records')");
-        Assert.That.AreJsonEqual("[]", records);
+        Assert.AreEqual(result, "OK");
     }
 
     [TestMethod]
     public async Task UpdateTest()
     {
         var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("SingleRecordBasic.Update");
+        await page.DeleteDatabaseAsync("Person");
 
         var result = await this.RunTestPageMethodAsync(p => p.Update);
-        Assert.AreEqual("1", result);
-
-        var records = await page.EvaluateAsync<string>("getAll('SingleRecordBasic.Update', 'Records')");
-
-        // TODO:
-        // Ignored should not exist here
-        // the property of Nested should be "Value" rather than "value"
-        Assert.That.AreJsonEqual("""
-            [
-                {
-                    "id":12,
-                    "Normal":"Updated",
-                    "Renamed":"R",
-                    "Index":"I",
-                    "UniqueIndex":"633a97d2-0c92-4c68-883b-364f94ad6030",
-                    "Enum":0,
-                    "Nested":{"value":1234},
-                    "LargeNumber":9007199254740991
-                }
-            ]
-            """, records);
-    }
-
-    [TestMethod]
-    public async Task GetByIdTest()
-    {
-        var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("SingleRecordBasic.GetById");
-
-        var result = await this.RunTestPageMethodAsync(p => p.GetById);
-        Assert.AreEqual("Norm", result);
+        Assert.AreEqual(result, "OK");
     }
 
     [TestMethod]
     public async Task GetAllTest()
     {
         var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("SingleRecordBasic.GetAll");
+        await page.DeleteDatabaseAsync("Person");
 
         var result = await this.RunTestPageMethodAsync(p => p.GetAll);
-
-        // Nested.Value should be 1234
-        Assert.That.AreJsonEqual("""
-            [{
-                "Id":12,
-                "Normal":"Norm",
-                "ShouldBeRenamed":"R",
-                "Ignored":false,
-                "Index":"I",
-                "UniqueIndex":"633a97d2-0c92-4c68-883b-364f94ad6030",
-                "Enum":0,
-                "Nested":{"Value":1234},
-                "LargeNumber":9007199254740991
-            }]
-            """, result);
+        Assert.AreEqual(result, "OK");
     }
 }

E2eTest/WhereTest.cs

@@ -10,8 +10,8 @@ public class WhereTest : TestBase<WhereTestPage>
     public async Task Where1Test()
     {
         var page = await this.NewPageAsync();
-        await page.DeleteDatabaseAsync("Where.Where1");
+        await page.DeleteDatabaseAsync("Person");
         var result = await this.RunTestPageMethodAsync(p => p.Where1);
-        Assert.That.AreJsonEqual("[1,2]", result);
+        Assert.AreEqual(result, "OK");
     }
 }

E2eTestWebApp/Models/IndexedDbContext.cs

@@ -0,0 +1,9 @@
+using Magic.IndexedDb;
+using Magic.IndexedDb.Interfaces;
+
+namespace E2eTestWebApp.Models;
+
+public class IndexedDbContext : IMagicRepository
+{
+    public static readonly IndexedDbSet Person = new("Person");
+}

E2eTestWebApp/Models/Person.cs

@@ -0,0 +1,34 @@
+using Magic.IndexedDb;
+using Magic.IndexedDb.SchemaAnnotations;
+
+namespace E2eTestWebApp.Models;
+
+public class Person : MagicTableTool<Person>, IMagicTable<Person.DbSets>
+{
+    public int Id { get; set; }
+
+    public IMagicCompoundKey GetKeys() =>
+        CreatePrimaryKey(x => x.Id, true); // Auto-incrementing primary key
+
+    public List<IMagicCompoundIndex>? GetCompoundIndexes() => [];
+
+    public string GetTableName() => "Person";
+    public IndexedDbSet GetDefaultDatabase() => IndexedDbContext.Person;
+
+    public DbSets Databases { get; } = new();
+    public sealed class DbSets
+    {
+        public readonly IndexedDbSet Person = IndexedDbContext.Person;
+    }
+
+    [MagicIndex] // Creates an index on this field
+    public string Name { get; set; }
+
+    [MagicUniqueIndex("guid")] // Unique constraint
+    public Guid UniqueGuid { get; set; } = Guid.NewGuid();
+
+    public int Age { get; set; }
+
+    [MagicNotMapped] // Exclude from IndexedDB schema
+    public string Secret { get; set; }
+}

E2eTestWebApp/Program.cs

@@ -16,21 +16,14 @@ public static async Task Main(string[] args)
 
         var builder = WebApplication.CreateBuilder(args);
         _ = builder.Services.AddRazorComponents().AddInteractiveServerComponents();
-
-        _ = builder.Services.AddBlazorDB((x) =>
-        {
-            x.Name = "OpenTest.RegisteredOpen1";
-            x.Version = 2;
-            x.StoreSchemas = [];
-        });
+        _ = builder.Services.AddMagicBlazorDB(BlazorInteropMode.WASM, true);
         _ = builder.Services.AddSingleton(new DbStore()
         {
             Name = "OpenTest.RegisteredOpen2",
             Version = 3,
             StoreSchemas = []
         });
-
-
+
         var app = builder.Build();
         _ = app.UseExceptionHandler("/Error", createScopeForErrors: true);
         _ = app.UseAntiforgery();

E2eTestWebApp/TestPages/OpenTestPage.cs

@@ -1,3 +1,4 @@
+using E2eTestWebApp.Models;
 using Magic.IndexedDb;
 using Microsoft.AspNetCore.Components;
 
@@ -8,42 +9,29 @@ public class OpenTestPage(IMagicIndexedDb magic) : TestPageBase
 {
     public async Task<string> DirectOpen()
     {
-        _ = await magic.OpenAsync(new DbStore()
-        {
-            Name = "OpenTest.DirectOpen",
-            Version = 1,
-            StoreSchemas = []
-        });
-        return "OK";
-    }
-
-    public async Task<string> RegisteredOpen1()
-    {
-        _ = await magic.GetRegisteredAsync("OpenTest.RegisteredOpen1");
-        return "OK";
-    }
-
-    public async Task<string> RegisteredOpen2()
-    {
-        _ = await magic.GetRegisteredAsync("OpenTest.RegisteredOpen2");
+        var connection = await magic.Database(IndexedDbContext.Person);
+        await connection.OpenAsync();
         return "OK";
     }
 
     public async Task<string> Get()
     {
-        _ = await magic.OpenAsync(new DbStore()
+        /*_ = await magic.OpenAsync(new DbStore()
         {
             Name = "OpenTest.Get",
             Version = 1,
             StoreSchemas = []
         });
         var database = magic.Get("OpenTest.Get");
-        return database.DbName;
+        return database.DbName;*/
+
+        return "TODO";
     }
 
     public async Task<string> StoreSchema()
     {
-        _ = await magic.OpenAsync(new DbStore()
+        var connection = await magic.Query<Person>();
+        /*_ = await magic.OpenAsync(new DbStore()
         {
             Name = "OpenTest.StoreSchema",
             Version = 1,
@@ -67,6 +55,8 @@ public async Task<string> StoreSchema()
                 }
             ]
         });
-        return "OK";
+        return "OK";*/
+
+        return "TODO";
     }
 }