Task TestFirestoreSettings()

in firestore/testapp/Assets/Firebase/Sample/Firestore/UIHandlerAutomated.cs [2768:2909]
113 lines of code
1 McCabe index (conditional complexity)

    Task TestFirestoreSettings() {
      return Async(() => {
        // Verify that ToString() returns a meaningful value.
        {
          FirebaseApp customApp = FirebaseApp.Create(db.App.Options, "settings-tostring-test");
          FirebaseFirestore customDb = FirebaseFirestore.GetInstance(customApp);
          customDb.Settings.Host = "a.b.c";
          customDb.Settings.SslEnabled = true;
          customDb.Settings.PersistenceEnabled = false;
          customDb.Settings.CacheSizeBytes = 9876543;
          AssertStringContainsNoCase(customDb.Settings.ToString(), "FirebaseFirestoreSettings");
          AssertStringContainsNoCase(customDb.Settings.ToString(), "Host=a.b.c");
          AssertStringContainsNoCase(customDb.Settings.ToString(), "SslEnabled=true");
          AssertStringContainsNoCase(customDb.Settings.ToString(), "PersistenceEnabled=false");
          AssertStringContainsNoCase(customDb.Settings.ToString(), "CacheSizeBytes=9876543");
          customApp.Dispose();
        }

        // Verify the default FirebaseFirestoreSettings values.
        {
          FirebaseApp customApp = FirebaseApp.Create(db.App.Options, "settings-defaults-test");
          FirebaseFirestore customDb = FirebaseFirestore.GetInstance(customApp);
          AssertEq(customDb.Settings.Host, "firestore.googleapis.com");
          AssertEq(customDb.Settings.SslEnabled, true);
          AssertEq(customDb.Settings.PersistenceEnabled, true);
          AssertEq(customDb.Settings.CacheSizeBytes, 100 * 1024 * 1024);
          customApp.Dispose();
        }

        // Verify that the FirebaseFirestoreSettings written are read back.
        {
          FirebaseApp customApp = FirebaseApp.Create(db.App.Options, "settings-readwrite-test");
          FirebaseFirestore customDb = FirebaseFirestore.GetInstance(customApp);

          customDb.Settings.Host = "a.b.c";
          AssertEq<string>(customDb.Settings.Host, "a.b.c");
          customDb.Settings.Host = "d.e.f";
          AssertEq<string>(customDb.Settings.Host, "d.e.f");

          customDb.Settings.SslEnabled = true;
          AssertEq<bool>(customDb.Settings.SslEnabled, true);
          customDb.Settings.SslEnabled = false;
          AssertEq<bool>(customDb.Settings.SslEnabled, false);

          customDb.Settings.PersistenceEnabled = true;
          AssertEq<bool>(customDb.Settings.PersistenceEnabled, true);
          customDb.Settings.PersistenceEnabled = false;
          AssertEq<bool>(customDb.Settings.PersistenceEnabled, false);

          customDb.Settings.CacheSizeBytes = 9876543;
          AssertEq<long>(customDb.Settings.CacheSizeBytes, 9876543);
          customDb.Settings.CacheSizeBytes = 1234567;
          AssertEq<long>(customDb.Settings.CacheSizeBytes, 1234567);

          customApp.Dispose();
        }

        // Verify the FirebaseFirestoreSettings behavior after the FirebaseFirestore is disposed.
        {
          FirebaseApp customApp = FirebaseApp.Create(db.App.Options, "settings-dispose-test");
          FirebaseFirestore customDb = FirebaseFirestore.GetInstance(customApp);
          FirebaseFirestoreSettings settings = customDb.Settings;

          var oldHost = settings.Host;
          var oldSslEnabled = settings.SslEnabled;
          var oldPersistenceEnabled = settings.PersistenceEnabled;
          var oldCacheSizeBytes = settings.CacheSizeBytes;

          customApp.Dispose();

          AssertException(typeof(InvalidOperationException), () => { settings.Host = "a.b.c"; });
          AssertException(typeof(InvalidOperationException),
                          () => { settings.SslEnabled = false; });
          AssertException(typeof(InvalidOperationException),
                          () => { settings.PersistenceEnabled = false; });
          AssertException(typeof(InvalidOperationException),
                          () => { settings.CacheSizeBytes = 9876543; });

          // Test "getting" the values after verifying that setting throws an exception to ensure
          // that the values were not actually changed by the exception-throwing set operation.
          AssertEq<string>(settings.Host, oldHost);
          AssertEq<bool>(settings.SslEnabled, oldSslEnabled);
          AssertEq<bool>(settings.PersistenceEnabled, oldPersistenceEnabled);
          AssertEq<long>(settings.CacheSizeBytes, oldCacheSizeBytes);
        }

        // Verify the FirebaseFirestoreSettings behavior after the FirebaseFirestore is used.
        {
          FirebaseApp customApp = FirebaseApp.Create(db.App.Options, "settings-toolate-test");
          FirebaseFirestore customDb = FirebaseFirestore.GetInstance(customApp);
          var oldHost = customDb.Settings.Host;
          var oldSslEnabled = customDb.Settings.SslEnabled;
          var oldPersistenceEnabled = customDb.Settings.PersistenceEnabled;
          var oldCacheSizeBytes = customDb.Settings.CacheSizeBytes;

          // "Use" the settings to lock them in, so that future "set" operations will fail.
          customDb.Collection("a");

          AssertException(typeof(InvalidOperationException),
                          () => { customDb.Settings.Host = "a.b.c"; });
          AssertException(typeof(InvalidOperationException),
                          () => { customDb.Settings.SslEnabled = false; });
          AssertException(typeof(InvalidOperationException),
                          () => { customDb.Settings.PersistenceEnabled = false; });
          AssertException(typeof(InvalidOperationException),
                          () => { customDb.Settings.CacheSizeBytes = 9876543; });

          // Test "getting" the values after verifying that setting throws an exception to ensure
          // that the values were not actually changed by the exception-throwing set operation.
          AssertEq<string>(customDb.Settings.Host, oldHost);
          AssertEq<bool>(customDb.Settings.SslEnabled, oldSslEnabled);
          AssertEq<bool>(customDb.Settings.PersistenceEnabled, oldPersistenceEnabled);
          AssertEq<long>(customDb.Settings.CacheSizeBytes, oldCacheSizeBytes);

          customApp.Dispose();
        }

        // Verify that FirebaseFirestoreSettings.PersistenceEnabled is respected.
        {
          FirebaseApp customApp = FirebaseApp.Create(db.App.Options, "settings-persistence-test");
          string docPath;
          {
            FirebaseFirestore customDb = FirebaseFirestore.GetInstance(customApp);
            customDb.Settings.PersistenceEnabled = true;
            DocumentReference doc = customDb.Collection("settings-persistence-test").Document();
            docPath = doc.Path;
            AssertTaskSucceeds(doc.SetAsync(TestData(1)));
            AssertTaskSucceeds(doc.GetSnapshotAsync(Source.Cache));
            AssertTaskSucceeds(customDb.TerminateAsync());
          }
          {
            FirebaseFirestore customDb = FirebaseFirestore.GetInstance(customApp);
            customDb.Settings.PersistenceEnabled = false;
            DocumentReference doc = customDb.Document(docPath);
            AssertTaskSucceeds(doc.SetAsync(TestData(1)));
            AssertTaskFaults(doc.GetSnapshotAsync(Source.Cache));
            AssertTaskSucceeds(customDb.TerminateAsync());
          }
          customApp.Dispose();
        }
      });
    }