public void Session_ProgressObservable_WhenModeIsForOutstandingWork_CallsOnCompleted()
{
AsyncContext.Run(async() =>
{
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true);
var session = realm.GetSession();
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>();
using (var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true))
{
EventHandler <Realms.ErrorEventArgs> handler = null;
handler = new EventHandler <Realms.ErrorEventArgs>((sender, e) =>
{
errors.Add(e.Exception);
});
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_RXThrottleTests()
{
AsyncContext.Run(async() =>
{
const int ThrottleInterval = 100; // In ms
const int SafeDelay = 2 * ThrottleInterval;
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true);
var session = realm.GetSession();
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++;
Console.WriteLine(p.TransferableBytes);
});
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));
token.Dispose();
realm.Dispose();
Realm.DeleteRealm(realm.Config);
});
}
public void Session_RXCombineLatestTests()
{
AsyncContext.Run(async() =>
{
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true);
var session = realm.GetSession();
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);
}
});
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));
token.Dispose();
realm.Dispose();
Realm.DeleteRealm(realm.Config);
});
}
public void Realm_GetSession_ShouldReturnSameObject()
{
AsyncContext.Run(async() =>
{
using (var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true))
{
var session1 = realm.GetSession();
var session2 = realm.GetSession();
Assert.That(session1, Is.EqualTo(session2));
Assert.That(session1.GetHashCode(), Is.EqualTo(session2.GetHashCode()));
}
});
}
public void Session_GetUser_WhenInvalidSession_ShouldNotThrow()
{
AsyncContext.Run(async() =>
{
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: false);
var session = realm.GetSession();
session.SimulateError(ErrorCode.BadUserAuthentication, "some error", isFatal: true);
while (session.State != SessionState.Invalid)
{
await Task.Delay(100);
}
Assert.That(() => session.User, Is.Null);
});
}
public void Session_Error_ShouldPassCorrectSession()
{
AsyncContext.Run(async() =>
{
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true);
var session = realm.GetSession();
const ErrorCode code = (ErrorCode)102;
const string message = "Some fake error has occurred";
var result = await SyncTestHelpers.SimulateSessionError <SessionException>(session, code, message);
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(((SyncConfiguration)realm.Config).ServerUri));
realm.Dispose();
Realm.DeleteRealm(realm.Config);
});
}
public void Session_DivergingHistories_ShouldRaiseClientResetException()
{
AsyncContext.Run(async() =>
{
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true);
var session = realm.GetSession();
var result = await SyncTestHelpers.SimulateSessionError <ClientResetException>(session,
ErrorCode.DivergingHistories,
"Fake client reset is required");
var error = result.Item2;
Assert.That(error.BackupFilePath, Is.Not.Null);
Assert.That(error.BackupFilePath, Does.Contain("io.realm.object-server-recovered-realms/recovered_realm"));
Assert.That(File.Exists(error.BackupFilePath), Is.False);
realm.Dispose();
var clientResetSuccess = error.InitiateClientReset();
Assert.That(clientResetSuccess, Is.True);
Assert.That(File.Exists(error.BackupFilePath), Is.True);
});
}
public void Session_ProgressObservable_UnitTests(ProgressDirection direction, ProgressMode mode)
{
AsyncContext.Run(async() =>
{
var callbacksInvoked = 0;
var completionTCS = new TaskCompletionSource <ulong>();
var realm = await SyncTestHelpers.GetFakeRealm(isUserAdmin: true);
var session = realm.GetSession();
session.SimulateProgress(0, 100, 0, 100);
var observable = session.GetProgressObservable(direction, mode);
var token = observable.Subscribe(p =>
{
try
{
callbacksInvoked++;
Assert.That(p.TransferredBytes, Is.LessThanOrEqualTo(p.TransferableBytes));
if (mode == ProgressMode.ForCurrentlyOutstandingWork)
{
Assert.That(p.TransferableBytes, Is.EqualTo(100));
}
}
catch (Exception e)
{
completionTCS.TrySetException(e);
}
if (p.TransferredBytes == p.TransferableBytes)
{
completionTCS.TrySetResult(p.TransferredBytes);
}
});
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));
}
token.Dispose();
realm.Dispose();
Realm.DeleteRealm(realm.Config);
});
}