public void GetInstance_WhenDynamic_ReadsSchemaFromDisk() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); config.ObjectClasses = new[] { typeof(AllTypesObject) }; // Create the realm and add some objects using (var realm = GetRealm(config)) { realm.Write(() => realm.Add(new AllTypesObject { Int32Property = 42, RequiredStringProperty = "This is required!" })); } config.IsDynamic = true; using (var dynamicRealm = GetRealm(config)) { Assert.That(dynamicRealm.Schema.Count == 1); var objectSchema = dynamicRealm.Schema.Find(nameof(AllTypesObject)); Assert.That(objectSchema, Is.Not.Null); var hasExpectedProp = objectSchema.TryFindProperty(nameof(AllTypesObject.RequiredStringProperty), out var requiredStringProp); Assert.That(hasExpectedProp); Assert.That(requiredStringProp.Type, Is.EqualTo(PropertyType.String)); var ato = dynamicRealm.All(nameof(AllTypesObject)).Single(); Assert.That(ato.RequiredStringProperty, Is.EqualTo("This is required!")); } }); }
public void Session_ProgressObservable_WhenModeIsForOutstandingWork_CallsOnCompleted() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); var realm = GetRealm(config); var session = GetSession(realm); session.SimulateProgress(0, 100, 0, 0); var observable = session.GetProgressObservable(ProgressDirection.Download, ProgressMode.ForCurrentlyOutstandingWork); var task = Task.Run(() => { return(observable.Wait()); }); session.SimulateProgress(50, 100, 0, 0); await Task.Delay(50); session.SimulateProgress(100, 100, 0, 0); var progress = await task.Timeout(500); Assert.That(progress.TransferredBytes, Is.EqualTo(100)); Assert.That(progress.TransferableBytes, Is.EqualTo(100)); }); }
public void Session_Error_WhenInvalidAccessToken() { AsyncContext.Run(async() => { var errors = new List <Exception>(); var config = await SyncTestHelpers.GetFakeConfigAsync(); using (var realm = GetRealm(config)) { EventHandler <Realms.ErrorEventArgs> handler = null; handler = new EventHandler <Realms.ErrorEventArgs>((sender, e) => { errors.Add(e.Exception); CleanupOnTearDown((Session)sender); }); Session.Error += handler; while (!errors.Any()) { await Task.Yield(); } Session.Error -= handler; var sessionErrors = errors.OfType <SessionException>().ToArray(); Assert.That(sessionErrors.Count, Is.EqualTo(1)); Assert.That(sessionErrors[0].ErrorCode, Is.EqualTo(ErrorCode.BadUserAuthentication)); } }); }
public void Session_DivergingHistories_ShouldRaiseClientResetException() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); ClientResetException error = null; using (var realm = GetRealm(config)) { var session = GetSession(realm); var result = await SyncTestHelpers.SimulateSessionErrorAsync <ClientResetException>(session, ErrorCode.DivergingHistories, "Fake client reset is required"); CleanupOnTearDown(result.Item1); error = result.Item2; } Assert.That(error.BackupFilePath, Is.Not.Null); Assert.That(error.BackupFilePath, Does.Contain(Path.Combine("io.realm.object-server-recovered-realms", "recovered_realm"))); Assert.That(File.Exists(error.BackupFilePath), Is.False); var clientResetSuccess = error.InitiateClientReset(); Assert.That(clientResetSuccess, Is.True); Assert.That(File.Exists(error.BackupFilePath), Is.True); }); }
public void Session_RXThrottleTests() { AsyncContext.Run(async() => { const int ThrottleInterval = 100; // In ms const int SafeDelay = 2 * ThrottleInterval; var config = await SyncTestHelpers.GetFakeConfigAsync(); var realm = GetRealm(config); var session = GetSession(realm); var callbacksInvoked = 0; var uploadProgress = session.GetProgressObservable(ProgressDirection.Download, ProgressMode.ReportIndefinitely); session.SimulateProgress(0, 100, 0, 0); var token = uploadProgress.Throttle(TimeSpan.FromMilliseconds(ThrottleInterval)) .Subscribe(p => { callbacksInvoked++; }); using (token) { await Task.Delay(SafeDelay); Assert.That(callbacksInvoked, Is.EqualTo(1)); for (ulong i = 0; i < 10; i++) { session.SimulateProgress(i, 100, 0, 0); } await Task.Delay(SafeDelay); Assert.That(callbacksInvoked, Is.EqualTo(2)); for (ulong i = 10; i < 20; i++) { session.SimulateProgress(i, 100, 0, 0); await Task.Delay(ThrottleInterval / 10); } Assert.That(callbacksInvoked, Is.EqualTo(2)); await Task.Delay(SafeDelay); Assert.That(callbacksInvoked, Is.EqualTo(3)); for (ulong i = 20; i < 25; i++) { session.SimulateProgress(i, 100, 0, 0); await Task.Delay(SafeDelay); } Assert.That(callbacksInvoked, Is.EqualTo(8)); } }); }
public void Session_RXCombineLatestTests() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); var realm = GetRealm(config); var session = GetSession(realm); var callbacksInvoked = 0; var completionTCS = new TaskCompletionSource <ulong>(); var uploadProgress = session.GetProgressObservable(ProgressDirection.Upload, ProgressMode.ReportIndefinitely); var downloadProgress = session.GetProgressObservable(ProgressDirection.Download, ProgressMode.ReportIndefinitely); session.SimulateProgress(0, 100, 0, 100); var token = uploadProgress.CombineLatest(downloadProgress, (upload, download) => { return(new { TotalTransferred = upload.TransferredBytes + download.TransferredBytes, TotalTransferable = upload.TransferableBytes + download.TransferableBytes }); }) .Subscribe(progress => { callbacksInvoked++; if (progress.TotalTransferred == progress.TotalTransferable) { completionTCS.TrySetResult(progress.TotalTransferred); } }); using (token) { await Task.Delay(50); session.SimulateProgress(50, 100, 0, 100); await Task.Delay(50); session.SimulateProgress(100, 100, 0, 100); await Task.Delay(50); session.SimulateProgress(100, 150, 0, 100); await Task.Delay(50); session.SimulateProgress(100, 150, 100, 100); await Task.Delay(50); session.SimulateProgress(150, 150, 100, 100); var totalTransferred = await completionTCS.Task; Assert.That(callbacksInvoked, Is.GreaterThanOrEqualTo(6)); Assert.That(totalTransferred, Is.EqualTo(250)); } }); }
public void Realm_WhenCreatedWithSync1_ThrowsIncompatibleSyncedFileException(bool async, bool encrypt) { AsyncContext.Run(async() => { var legacyRealmName = $"sync-1.x{(encrypt ? "-encrypted" : string.Empty)}.realm"; var legacyRealmPath = TestHelpers.CopyBundledDatabaseToDocuments(legacyRealmName, Guid.NewGuid().ToString()); var config = await SyncTestHelpers.GetFakeConfigAsync("a@a", legacyRealmPath); if (encrypt) { config.EncryptionKey = _sync1xEncryptionKey; } try { if (async) { await GetRealmAsync(config); } else { GetRealm(config); } Assert.Fail("Expected IncompatibleSyncedFileException"); } catch (IncompatibleSyncedFileException ex) { var backupConfig = ex.GetBackupRealmConfig(encrypt ? _sync1xEncryptionKey : null); using (var backupRealm = Realm.GetInstance(backupConfig)) using (var newRealm = GetRealm(config)) { Assert.That(newRealm.All <Person>(), Is.Empty); var backupPeopleQuery = backupRealm.All(nameof(Person)); Assert.That(backupPeopleQuery, Is.Not.Empty); var backupPerson = backupPeopleQuery.First(); Assert.That(backupPerson.FirstName, Is.EqualTo("John")); Assert.That(backupPerson.LastName, Is.EqualTo("Smith")); newRealm.Write(() => { newRealm.Add(new Person { FirstName = backupPerson.FirstName, LastName = backupPerson.LastName }); }); } } }); }
public void GetInstance_WhenDynamicAndDoesntExist_ReturnsEmptySchema() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); config.IsDynamic = true; using (var realm = GetRealm(config)) { Assert.That(realm.Schema, Is.Empty); } }); }
/// <summary> /// Opens a random realm and calls session.Stop(). It will assert state changes /// to Inactive. /// </summary> /// <returns>The stopped session.</returns> private async Task <Session> OpenRealmAndStopSession() { var config = await SyncTestHelpers.GetFakeConfigAsync(); var realm = GetRealm(config); var session = GetSession(realm); Assert.That(session.State, Is.EqualTo(SessionState.Active)); session.Stop(); Assert.That(session.State, Is.EqualTo(SessionState.Inactive)); return(session); }
public void Realm_GetSession_ShouldReturnSameObject() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); using (var realm = GetRealm(config)) { var session1 = GetSession(realm); var session2 = GetSession(realm); Assert.That(session1, Is.EqualTo(session2)); Assert.That(session1.GetHashCode(), Is.EqualTo(session2.GetHashCode())); } }); }
public void Session_GetUser_WhenInvalidSession_ShouldNotThrow() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); using (var realm = GetRealm(config)) { var session = GetSession(realm); session.SimulateError(ErrorCode.BadUserAuthentication, "some error", isFatal: true); var counter = 0; while (session.State != SessionState.Invalid) { await Task.Delay(100); Assert.That(counter++ < 5); } Assert.That(() => session.User, Is.Null); } }); }
public void Session_Error_ShouldPassCorrectSession() { AsyncContext.Run(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); using (var realm = GetRealm(config)) { var session = GetSession(realm); const ErrorCode code = (ErrorCode)102; const string message = "Some fake error has occurred"; var result = await SyncTestHelpers.SimulateSessionErrorAsync <SessionException>(session, code, message); CleanupOnTearDown(result.Item1); var error = result.Item2; Assert.That(error.Message, Is.EqualTo(message)); Assert.That(error.ErrorCode, Is.EqualTo(code)); var errorSession = result.Item1; Assert.That(errorSession.ServerUri, Is.EqualTo(((SyncConfigurationBase)realm.Config).ServerUri)); } }); }
public void Session_ProgressObservable_UnitTests(ProgressDirection direction, ProgressMode mode) { AsyncContext.Run(async() => { var callbacksInvoked = 0; var completionTCS = new TaskCompletionSource <ulong>(); var config = await SyncTestHelpers.GetFakeConfigAsync(); var realm = GetRealm(config); var session = GetSession(realm); session.SimulateProgress(0, 100, 0, 100); var observable = session.GetProgressObservable(direction, mode); var token = observable.Subscribe(p => { try { callbacksInvoked++; // .NET Core dislikes asserts in the callback so much it crashes. if (p.TransferredBytes > p.TransferableBytes) { throw new Exception("TransferredBytes must be less than or equal to TransferableBytes"); } if (mode == ProgressMode.ForCurrentlyOutstandingWork) { if (p.TransferableBytes != 100) { throw new Exception("TransferableBytes must be equal to 100"); } } } catch (Exception e) { completionTCS.TrySetException(e); } if (p.TransferredBytes == p.TransferableBytes) { completionTCS.TrySetResult(p.TransferredBytes); } }); using (token) { session.SimulateProgress(50, 150, 50, 150); await Task.Delay(50); session.SimulateProgress(100, 200, 100, 200); await Task.Delay(50); session.SimulateProgress(150, 200, 150, 200); await Task.Delay(50); session.SimulateProgress(200, 200, 200, 200); await Task.Delay(50); var totalTransferred = await completionTCS.Task; if (mode == ProgressMode.ForCurrentlyOutstandingWork) { Assert.That(totalTransferred, Is.EqualTo(100)); Assert.That(callbacksInvoked, Is.EqualTo(3)); } else { Assert.That(totalTransferred, Is.EqualTo(200)); Assert.That(callbacksInvoked, Is.EqualTo(5)); } } }); }