From b22b53aceaf95663387f3412e495d471e9f3d5d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= <kasper@byolimit.com>
Date: Mon, 5 Feb 2024 11:15:34 +0100
Subject: [PATCH] Added test of FTS with prefix on embedded objects

---
 test/indexed_test.dart   | 48 ++++++++++++++++++++
 test/indexed_test.g.dart | 96 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 144 insertions(+)

diff --git a/test/indexed_test.dart b/test/indexed_test.dart
index 96107e31e..83d4bff4d 100644
--- a/test/indexed_test.dart
+++ b/test/indexed_test.dart
@@ -87,6 +87,21 @@ const String lordOfTheFlies = 'Lord of the Flies';
 const String wheelOfTime = 'The Wheel of Time';
 const String silmarillion = 'The Silmarillion';
 
+@RealmModel()
+class _ParentWithFts {
+  @Indexed(RealmIndexType.fullText)
+  late String name;
+  List<_EmbeddedWithFts> embedded = [];
+}
+
+@RealmModel(ObjectType.embeddedObject)
+class _EmbeddedWithFts {
+  @Indexed(RealmIndexType.fullText)
+  late String nameSingular;
+  @Indexed(RealmIndexType.fullText)
+  late String namePlural;
+}
+
 void main() {
   setupTests();
 
@@ -240,4 +255,37 @@ void main() {
 
     expect(() => realm.query<ObjectWithFTSIndex>('title TEXT \$0', ["lord"]), throws<RealmException>('Column has no fulltext index'));
   });
+
+  group('FTS with prefix search on embedded objects', () {
+    late Realm realm;
+    setUpAll(() {
+      final config = Configuration.local([ParentWithFts.schema, EmbeddedWithFts.schema]);
+      realm = Realm(config);
+
+      realm.write(() {
+        realm.addAll([
+          ParentWithFts('Object 1', embedded: [
+            EmbeddedWithFts('salt', 'salt'),
+            EmbeddedWithFts('pepper', 'pepper'),
+          ]),
+          ParentWithFts('Object 2', embedded: [
+            EmbeddedWithFts('basil', 'basil'),
+            EmbeddedWithFts('oregano', 'oregano'),
+          ])
+        ]);
+      });
+    });
+
+    for (final searchTerm in [
+      'sal*',
+      'Object 2*',
+      'basil*',
+      'Object*',
+      'doesnotexist*',
+    ]) {
+      test('search term: $searchTerm', () {
+        expect(realm.query<ParentWithFts>(r"name TEXT $0 OR embedded.nameSingular TEXT $0 OR embedded.namePlural TEXT $0", [searchTerm]), isNotNull);
+      });
+    }
+  });
 }
diff --git a/test/indexed_test.g.dart b/test/indexed_test.g.dart
index 79787b278..840c6aa3c 100644
--- a/test/indexed_test.g.dart
+++ b/test/indexed_test.g.dart
@@ -217,3 +217,99 @@ class ObjectWithFTSIndex extends _ObjectWithFTSIndex
     ]);
   }
 }
+
+class ParentWithFts extends _ParentWithFts
+    with RealmEntity, RealmObjectBase, RealmObject {
+  ParentWithFts(
+    String name, {
+    Iterable<EmbeddedWithFts> embedded = const [],
+  }) {
+    RealmObjectBase.set(this, 'name', name);
+    RealmObjectBase.set<RealmList<EmbeddedWithFts>>(
+        this, 'embedded', RealmList<EmbeddedWithFts>(embedded));
+  }
+
+  ParentWithFts._();
+
+  @override
+  String get name => RealmObjectBase.get<String>(this, 'name') as String;
+  @override
+  set name(String value) => RealmObjectBase.set(this, 'name', value);
+
+  @override
+  RealmList<EmbeddedWithFts> get embedded =>
+      RealmObjectBase.get<EmbeddedWithFts>(this, 'embedded')
+          as RealmList<EmbeddedWithFts>;
+  @override
+  set embedded(covariant RealmList<EmbeddedWithFts> value) =>
+      throw RealmUnsupportedSetError();
+
+  @override
+  Stream<RealmObjectChanges<ParentWithFts>> get changes =>
+      RealmObjectBase.getChanges<ParentWithFts>(this);
+
+  @override
+  ParentWithFts freeze() => RealmObjectBase.freezeObject<ParentWithFts>(this);
+
+  static SchemaObject get schema => _schema ??= _initSchema();
+  static SchemaObject? _schema;
+  static SchemaObject _initSchema() {
+    RealmObjectBase.registerFactory(ParentWithFts._);
+    return const SchemaObject(
+        ObjectType.realmObject, ParentWithFts, 'ParentWithFts', [
+      SchemaProperty('name', RealmPropertyType.string,
+          indexType: RealmIndexType.fullText),
+      SchemaProperty('embedded', RealmPropertyType.object,
+          linkTarget: 'EmbeddedWithFts',
+          collectionType: RealmCollectionType.list),
+    ]);
+  }
+}
+
+class EmbeddedWithFts extends _EmbeddedWithFts
+    with RealmEntity, RealmObjectBase, EmbeddedObject {
+  EmbeddedWithFts(
+    String nameSingular,
+    String namePlural,
+  ) {
+    RealmObjectBase.set(this, 'nameSingular', nameSingular);
+    RealmObjectBase.set(this, 'namePlural', namePlural);
+  }
+
+  EmbeddedWithFts._();
+
+  @override
+  String get nameSingular =>
+      RealmObjectBase.get<String>(this, 'nameSingular') as String;
+  @override
+  set nameSingular(String value) =>
+      RealmObjectBase.set(this, 'nameSingular', value);
+
+  @override
+  String get namePlural =>
+      RealmObjectBase.get<String>(this, 'namePlural') as String;
+  @override
+  set namePlural(String value) =>
+      RealmObjectBase.set(this, 'namePlural', value);
+
+  @override
+  Stream<RealmObjectChanges<EmbeddedWithFts>> get changes =>
+      RealmObjectBase.getChanges<EmbeddedWithFts>(this);
+
+  @override
+  EmbeddedWithFts freeze() =>
+      RealmObjectBase.freezeObject<EmbeddedWithFts>(this);
+
+  static SchemaObject get schema => _schema ??= _initSchema();
+  static SchemaObject? _schema;
+  static SchemaObject _initSchema() {
+    RealmObjectBase.registerFactory(EmbeddedWithFts._);
+    return const SchemaObject(
+        ObjectType.embeddedObject, EmbeddedWithFts, 'EmbeddedWithFts', [
+      SchemaProperty('nameSingular', RealmPropertyType.string,
+          indexType: RealmIndexType.fullText),
+      SchemaProperty('namePlural', RealmPropertyType.string,
+          indexType: RealmIndexType.fullText),
+    ]);
+  }
+}