Fix for updated flexible sync error message

CHANGELOG.md

@@ -1,12 +1,12 @@
 x.x.x Release notes (yyyy-MM-dd)
 =============================================================
 ### Enhancements
-* None.
+* Creating an object for a class that has no subscriptions opened for it will throw an exception. ([realm/realm-core#5488](https://github.com/realm/realm-core/pull/5488))
 
 ### Fixed
-* <How to hit and notice issue? what was the impact?> ([#????](https://github.com/realm/realm-js/issues/????), since v?.?.?)
-* Add canonical schema type for returned schemas ([#4580](https://github.com/realm/realm-js/pull/4580))
-* Fixed invalid type for schema properties([#4577](https://github.com/realm/realm-js/pull/4577)).
+* Add canonical schema type for returned schemas. ([#4580](https://github.com/realm/realm-js/pull/4580))
+* Fixed invalid type for schema properties. ([#4577](https://github.com/realm/realm-js/pull/4577))
+* FLX sync subscription state changes will now correctly be reported after sync progress is reported. ([realm/realm-core#5553](https://github.com/realm/realm-core/pull/5553), since v10.18.0)
 
 ### Compatibility
 * MongoDB Realm Cloud.
@@ -15,6 +15,8 @@ x.x.x Release notes (yyyy-MM-dd)
 * File format: generates Realms with format v22 (reads and upgrades file format v5 or later for non-synced Realm, upgrades file format v10 or later for synced Realms).
 
 ### Internal
+* Upgraded Realm Core from v12.0.0 to v12.1.0.
+* Fix for updated FLX sync error message. ([#4611](https://github.com/realm/realm-js/pull/4611))
 * Updated build script to use Xcode 13.1 to match latest Apple App Store compatibility. ([#4605](https://github.com/realm/realm-js/issues/4605))
 
 10.18.0 Release notes (2022-5-29)

integration-tests/tests/src/tests/sync/flexible.ts

@@ -33,8 +33,8 @@ import Realm, { BSON, ClientResetMode, FlexibleSyncConfiguration, SessionStopPol
 
 import { authenticateUserBefore, importAppBefore, openRealmBeforeEach } from "../../hooks";
 import { DogSchema, IPerson, PersonSchema } from "../../schemas/person-and-dog-with-object-ids";
-import { expectClientResetError } from "../../utils/expect-sync-error";
-import { closeAndReopenRealm, closeRealm, closeThisRealm } from "../../utils/close-realm";
+import { expectInvalidWriteSyncError } from "../../utils/expect-sync-error";
+import { closeAndReopenRealm, closeRealm } from "../../utils/close-realm";
 
 const FlexiblePersonSchema = { ...PersonSchema, properties: { ...PersonSchema.properties, nonQueryable: "string?" } };
 
@@ -1568,9 +1568,9 @@ describe.skipIf(environment.missingServer, "Flexible sync", function () {
 
     // TODO test more complex integration scenarios, e.g. links, embedded objects, collections, complex queries
 
-    describe("client reset scenarios", function () {
-      it("triggers a client reset if items are added without a subscription", async function (this: RealmContext) {
-        await expectClientResetError(this.config, this.user, (realm) => {
+    describe("error scenarios", function () {
+      it("triggers an error if items are added without a subscription", async function (this: RealmContext) {
+        await expectInvalidWriteSyncError(this.config, this.user, (realm) => {
           realm.write(() => {
             return realm.create<IPerson>(FlexiblePersonSchema.name, {
               _id: new BSON.ObjectId(),
@@ -1581,10 +1581,10 @@ describe.skipIf(environment.missingServer, "Flexible sync", function () {
         });
       });
 
-      it("triggers a client reset and deletes the item if an item not matching the filter is created", async function (this: RealmContext) {
+      it("triggers an error and deletes the item if an item not matching the filter is created", async function (this: RealmContext) {
         await addSubscriptionAndSync(this.realm, this.realm.objects(FlexiblePersonSchema.name).filtered("age < 30"));
 
-        await expectClientResetError(
+        await expectInvalidWriteSyncError(
           this.config,
           this.user,
           (realm) => {
@@ -1602,8 +1602,8 @@ describe.skipIf(environment.missingServer, "Flexible sync", function () {
         );
       });
 
-      it("triggers a client reset if you remove a subscription without waiting for server acknowledgement, then modify objects that were only matched by the now removed subscription", async function (this: RealmContext) {
-        await expectClientResetError(this.config, this.user, async (realm) => {
+      it("triggers an error if you remove a subscription without waiting for server acknowledgement, then modify objects that were only matched by the now removed subscription", async function (this: RealmContext) {
+        await expectInvalidWriteSyncError(this.config, this.user, async (realm) => {
           const { sub } = await addSubscriptionForPersonAndSync(this.realm);
 
           this.realm.subscriptions.update((mutableSubs) => {

integration-tests/tests/src/tests/sync/mixed.ts

@@ -70,7 +70,7 @@ function describeRoundtrip({
 
   async function setupTest(realm: Realm) {
     if (flexibleSync) {
-      realm.subscriptions.update((mutableSubs) => {
+      await realm.subscriptions.update((mutableSubs) => {
         mutableSubs.add(realm.objects("MixedClass"));
       });
       await realm.subscriptions.waitForSynchronization();
@@ -94,6 +94,7 @@ function describeRoundtrip({
     });
 
     it("writes", async function (this: RealmContext) {
+      this.timeout(6000);
       await setupTest(this.realm);
 
       this._id = new Realm.BSON.ObjectId();

integration-tests/tests/src/utils/expect-sync-error.ts

@@ -19,6 +19,8 @@
 import { expect } from "chai";
 import { openRealm } from "./open-realm";
 
+type Error = Realm.SyncError | (Realm.ClientResetError & { message: string });
+
 /**
  * Open a new Realm and perform an action, expecting a sync error to occur. Will
  * never resolve and therefore timeout if a sync error does not occur.
@@ -34,28 +36,58 @@ export async function expectSyncError(
   config: Realm.Configuration,
   user: Realm.User,
   action: (realm: Realm) => void,
-  expectation: (error: Realm.SyncError | Realm.ClientResetError) => void,
+  expectation: (error: Error) => void,
 ): Promise<void> {
-  let handleError: Realm.ErrorCallback | undefined;
-
-  const configWithErrorHandler = { ...config };
-  if (!configWithErrorHandler.sync) {
-    throw new Error("Expected a sync config");
-  }
-
-  configWithErrorHandler.sync.error = (session, error) => {
-    if (handleError) handleError(session, error);
-  };
+  return new Promise((resolve, reject) => {
+    if (!config.sync) {
+      throw new Error("Expected a sync config");
+    }
 
-  const { realm } = await openRealm(configWithErrorHandler, user);
-
-  return new Promise((resolve) => {
-    handleError = (session, error) => {
-      expectation(error);
-      resolve();
+    // Shallow copy the sync configuration to modifying the original
+    const modifiedConfig: Realm.Configuration = {
+      ...config,
+      sync: {
+        ...config.sync,
+        error(_, error: Error) {
+          try {
+            expectation(error);
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        },
+      },
     };
 
-    action(realm);
+    openRealm(modifiedConfig, user).then(({ realm }) => action(realm), reject);
+  });
+}
+
+/**
+ * Expect a sync error to occur with a message about an invalid write.
+ * Optionally specify more expectations about the sync error.  Will
+ * never resolve and therefore timeout if a sync error does not occur.
+ *
+ * @param config The Realm config to use
+ * @param user The Realm user to use
+ * @param action Callback receiving a Realm instance and containing the
+ * action(s) to take which should trigger a client reset error
+ * @param extraExpectation Optional callback receiving the sync error, in order to make more
+ * assertions about it
+ * @returns Promise which resolves if the sync error occurs
+ */
+export async function expectInvalidWriteSyncError(
+  config: Realm.Configuration,
+  user: Realm.User,
+  action: (realm: Realm) => void,
+  extraExpectation?: (error: Error) => void,
+): Promise<void> {
+  return expectSyncError(config, user, action, (error) => {
+    expect(error.name).to.equal("Error");
+    expect(error.message).to.match(
+      /Client attempted a write that is outside of permissions or query filters; it has been reverted.*/,
+    );
+    if (extraExpectation) extraExpectation(error);
   });
 }
 
@@ -76,7 +108,7 @@ export async function expectClientResetError(
   config: Realm.Configuration,
   user: Realm.User,
   action: (realm: Realm) => void,
-  extraExpectation?: (error: Realm.SyncError | Realm.ClientResetError) => void,
+  extraExpectation?: (error: Error) => void,
 ): Promise<void> {
   return expectSyncError(config, user, action, (error) => {
     expect(error.name).to.equal("ClientReset");