public void Compact_ShouldReduceSize(bool encrypt, bool populate)
{
AsyncContext.Run(async() =>
{
var user = await SyncTestHelpers.GetFakeUserAsync();
var serverUri = new Uri($"realm://localhost:9080/~/compactrealm_{encrypt}_{populate}.realm");
var config = new FullSyncConfiguration(serverUri, user);
if (encrypt)
{
config.EncryptionKey = TestHelpers.GetEncryptionKey(5);
}
using (var realm = GetRealm(config))
{
if (populate)
{
AddDummyData(realm, singleTransaction: false);
}
}
var initialSize = new FileInfo(config.DatabasePath).Length;
Assert.That(Realm.Compact(config));
var finalSize = new FileInfo(config.DatabasePath).Length;
Assert.That(initialSize >= finalSize);
using (var realm = GetRealm(config))
{
Assert.That(realm.All <IntPrimaryKeyWithValueObject>().Count(), Is.EqualTo(populate ? 500 : 0));
}
});
}
public void GetInstanceAsync_ShouldDownloadRealm(bool singleTransaction)
{
SyncTestHelpers.RequiresRos();
AsyncContext.Run(async() =>
{
var user = await SyncTestHelpers.GetUserAsync();
var realmUri = SyncTestHelpers.RealmUri("~/GetInstanceAsync_ShouldDownloadRealm");
var config = new FullSyncConfiguration(realmUri, user, Guid.NewGuid().ToString());
var asyncConfig = new FullSyncConfiguration(realmUri, user, config.DatabasePath + "_async");
using (var realm = GetRealm(config))
{
AddDummyData(realm, singleTransaction);
await GetSession(realm).WaitForUploadAsync();
}
using (var asyncRealm = await GetRealmAsync(asyncConfig))
{
Assert.That(asyncRealm.All <IntPrimaryKeyWithValueObject>().Count(), Is.EqualTo(500));
}
});
}
public void PermissionResponse_WhenOfferIsValid_ShouldSetRealmUrl()
{
SyncTestHelpers.RequiresRos();
AsyncContext.Run(async() =>
{
var alice = await SyncTestHelpers.GetUserAsync();
var bob = await SyncTestHelpers.GetUserAsync();
// Opening a synced realm with just read permission fails.
// OS issue: https://github.com/realm/realm-object-store/issues/312
var realmUrl = await GrantPermissions(alice, bob);
var syncConfig = new FullSyncConfiguration(new Uri(realmUrl), bob, Guid.NewGuid().ToString());
Assert.That(() => GetRealm(syncConfig), Throws.Nothing);
var handler = new EventHandler <ErrorEventArgs>((sender, e) =>
{
Assert.Fail("Opening the realm should not cause an error.", e.Exception);
});
Session.Error += handler;
await Task.Delay(2000);
Session.Error -= handler;
});
}
public void GetInstanceAsync_Cancel_ShouldCancelWait()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var config = await SyncTestHelpers.GetIntegrationConfigAsync("foo");
await PopulateData(config);
// Update config to make sure we're not opening the same Realm file.
config = new FullSyncConfiguration(config.ServerUri, config.User, config.DatabasePath + "1");
using (var cts = new CancellationTokenSource())
{
var _ = Task.Run(async() =>
{
await Task.Delay(1);
cts.Cancel();
});
try
{
var realm = await Realm.GetInstanceAsync(config, cts.Token);
CleanupOnTearDown(realm);
Assert.Fail("Expected task to be cancelled.");
}
catch (Exception ex)
{
Assert.That(ex, Is.InstanceOf <TaskCanceledException>());
}
}
});
}
private static async Task <Realm> GetRealm(Uri realmUrl, User user)
{
var tempRealmFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
var syncConfiguration = new FullSyncConfiguration(realmUrl, user, tempRealmFile);
return(await Realm.GetInstanceAsync(syncConfiguration));
}
private static void DeleteOnlineRealm(Uri realmDatabaseUri)
{
try
{
Console.WriteLine("Try to remove cloud realm");
var users = User.AllLoggedIn;
if (users.Any())
{
var syncConfiguration = new FullSyncConfiguration(realmDatabaseUri, users.First());
Realm.DeleteRealm(syncConfiguration);
}
}
catch (Exception e)
{
Crashes.TrackError(e, new Dictionary <string, string>
{
{ "Realm fatal error", "true" },
{ "Error description", $"Error on deleting cloud realm. See {e.Message}" }
});
}
finally
{
OnlineRealm = null;
Settings.IsOnlineRealmCreated = false;
}
}
public void GetInstanceAsync_ReportsProgress()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var config = await SyncTestHelpers.GetIntegrationConfigAsync("foo");
await PopulateData(config);
var callbacksInvoked = 0;
var lastProgress = default(SyncProgress);
config = new FullSyncConfiguration(config.ServerUri, config.User, config.DatabasePath + "1")
{
OnProgress = (progress) =>
{
callbacksInvoked++;
lastProgress = progress;
}
};
using (var realm = await GetRealmAsync(config))
{
Assert.That(realm.All <HugeSyncObject>().Count(), Is.EqualTo(NumberOfObjects));
Assert.That(callbacksInvoked, Is.GreaterThan(0));
Assert.That(lastProgress.TransferableBytes, Is.EqualTo(lastProgress.TransferredBytes));
}
});
}
public static Book Create()
{
var user = User.Current;
if (user != null)
{
var configuration = new FullSyncConfiguration(new Uri(Constants.RealmPath, UriKind.Relative), user);
Book NewBook()
{
var q = Realm.GetInstance(configuration).All <Book>();
return(new Book(q.Any() ? q.Last().Id + 1 : 0));
}
if (Realm.GetInstance(configuration).IsInTransaction)
{
return(NewBook());
}
using (var trans = Realm.GetInstance(configuration).BeginWrite())
return(NewBook());
}
return(null);
}
private void EnsureRealmExists(User user, string realmUrl)
{
var syncConfig = new FullSyncConfiguration(new Uri(realmUrl), user, Guid.NewGuid().ToString());
using (var realm = GetRealm(syncConfig))
{
// Make sure the realm exists
}
}
public void SyncConfiguration_WithRelativeUri_ResolvesCorrectly(string path, string expected)
{
TestHelpers.RunAsyncTest(async() =>
{
var user = await SyncTestHelpers.GetFakeUserAsync();
var syncConfiguration = new FullSyncConfiguration(new Uri(path, UriKind.Relative), user);
Assert.That(syncConfiguration.ServerUri.AbsoluteUri, Is.EqualTo($"realm://{SyncTestHelpers.FakeRosUrl}{expected}"));
});
}
private async Task <Realm> OpenRealm()
{
var user = User.Current;
if (user != null)
{
var configuration = new FullSyncConfiguration(new Uri(Constants.RealmPath, UriKind.Relative), user);
// User has already logged in, so we can just load the existing data in the Realm.
return(Realm.GetInstance(configuration));
}
// When that is called in the page constructor, we need to allow the UI operation
// to complete before we can display a dialog prompt.
await Task.Yield();
var response = await UserDialogs.Instance.PromptAsync(new PromptConfig
{
Title = "Login",
Message = "Please enter your nickname",
OkText = "Login",
IsCancellable = false,
});
var credentials = Credentials.Nickname(response.Value, isAdmin: true);
try
{
UserDialogs.Instance.ShowLoading("Logging in...");
user = await User.LoginAsync(credentials, new Uri(Constants.AuthUrl));
UserDialogs.Instance.ShowLoading("Loading data");
var configuration = new FullSyncConfiguration(new Uri(Constants.RealmPath, UriKind.Relative), user);
// First time the user logs in, let's use GetInstanceAsync so we fully download the Realm
// before letting them interract with the UI.
var realm = await Realm.GetInstanceAsync(configuration);
UserDialogs.Instance.HideLoading();
return(realm);
}
catch (Exception ex)
{
await UserDialogs.Instance.AlertAsync(new AlertConfig
{
Title = "An error has occurred",
Message = $"An error occurred while trying to open the Realm: {ex.Message}"
});
// Try again
return(await OpenRealm());
}
}
public ItemEntriesViewModel()
{
var credentials = Credentials.Nickname("ian", isAdmin: true);
var user = Task.Run(() => User.LoginAsync(credentials, new Uri(Constants.AUTH_URL))).Result;
var configuration = new FullSyncConfiguration(new Uri(Constants.REALM_URL), user);
realm = Realm.GetInstance(configuration);
Entries = realm.All <Item>();
DeleteEntryCommand = new Command <Item>(DeleteEntry);
}
private async Task EnsureRealmExists(User user, string realmUrl)
{
var syncConfig = new FullSyncConfiguration(new Uri(realmUrl), user, Guid.NewGuid().ToString());
using (var realm = GetRealm(syncConfig))
{
// Make sure the realm exists
await GetSession(realm).WaitForUploadAsync();
}
}
public void TrustedCA_WhenFileDoesntExist_Throws()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var user = await SyncTestHelpers.GetUserAsync();
var config = new FullSyncConfiguration(SyncTestHelpers.RealmUri("~/TrustedCA_WhenFileDoesntExist_Throws"), user)
{
TrustedCAPath = "something.pem"
};
Assert.That(() => GetRealm(config), Throws.TypeOf <FileNotFoundException>());
});
}
protected async Task <(Realm Realm, string UserId)> CreateRandomRealmAsync(string path)
{
var user = await SyncTestHelpers.GetUserAsync();
var location = Path.Combine(UserRealmFolder, user.Identity, path);
Directory.CreateDirectory(Path.GetDirectoryName(location));
var config = new FullSyncConfiguration(new Uri($"~/{path}", UriKind.Relative), user, location);
var realm = GetRealm(config);
await SyncTestHelpers.WaitForUploadAsync(realm);
return(realm, user.Identity);
}
private async Task<Realm> GetSyncedRealm(Type objectType)
{
var credentials = Credentials.UsernamePassword(Constants.AdminUsername, Constants.AdminPassword, false);
var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri);
var configuration = new FullSyncConfiguration(SyncTestHelpers.RealmUri($"~/merge_by_pk_{objectType.Name}"), user, Guid.NewGuid().ToString())
{
ObjectClasses = new[] { objectType }
};
Realm.DeleteRealm(configuration);
return GetRealm(configuration);
}
private static async Task <Realm> OpenCloudRealm(FullSyncConfiguration syncConfiguration)
{
if (Settings.IsOnlineRealmCreated)
{
return(Realm.GetInstance(syncConfiguration));
}
var realm = await Realm.GetInstanceAsync(syncConfiguration);
Settings.IsOnlineRealmCreated = true;
return(realm);
}
private async Task PopulateData(FullSyncConfiguration config)
{
using (var realm = GetRealm(config))
{
realm.Write(() =>
{
for (var i = 0; i < NumberOfObjects; i++)
{
realm.Add(new HugeSyncObject(OneMegabyte));
}
});
await GetSession(realm).WaitForUploadAsync();
}
}
public void SyncConfiguration_WithEncryptionKey_DoesntThrow()
{
TestHelpers.RunAsyncTest(async() =>
{
var user = await SyncTestHelpers.GetFakeUserAsync();
var key = Enumerable.Range(0, 63).Select(i => (byte)i).ToArray();
var config = new FullSyncConfiguration(new Uri("realm://foobar"), user)
{
EncryptionKey = TestHelpers.GetEncryptionKey(key)
};
Assert.That(() => GetRealm(config), Throws.Nothing);
});
}
public void WriteToReadOnlyRealm_ThrowsPermissionDenied()
{
SyncTestHelpers.RequiresRos();
AsyncContext.Run(async() =>
{
var alice = await SyncTestHelpers.GetUserAsync();
var bob = await SyncTestHelpers.GetUserAsync();
var realmPath = $"/{alice.Identity}/willBeReadonly";
var realmUrl = SyncTestHelpers.RealmUri(realmPath).AbsoluteUri;
EnsureRealmExists(alice, realmUrl);
// Give Bob just read permissions
await alice.ApplyPermissionsAsync(PermissionCondition.UserId(bob.Identity), realmUrl, AccessLevel.Read);
var config = new FullSyncConfiguration(new Uri(realmUrl), bob, Guid.NewGuid().ToString());
var sessionErrorTask = TestHelpers.EventToTask <ErrorEventArgs>(h => Session.Error += h, h => Session.Error -= h);
using (var realm = GetRealm(config))
{
realm.Write(() => realm.Add(new Person()));
try
{
// Sometimes PermissionDenied will be thrown too fast moving the session to an error state
await GetSession(realm).WaitForUploadAsync();
}
catch
{
}
}
var sessionError = await sessionErrorTask.Timeout(1000);
Assert.That(sessionError.Exception, Is.TypeOf <PermissionDeniedException>());
var pde = (PermissionDeniedException)sessionError.Exception;
Assert.That(pde.ErrorCode, Is.EqualTo(ErrorCode.PermissionDenied));
Assert.That(File.Exists(config.DatabasePath), Is.True);
var result = pde.DeleteRealmUserInfo(deleteRealm: true);
Assert.That(result, Is.True);
Assert.That(File.Exists(config.DatabasePath), Is.False);
});
}
public void GetInstanceAsync_OpensReadonlyRealm(bool singleTransaction)
{
SyncTestHelpers.RequiresRos();
AsyncContext.Run(async() =>
{
var alice = await SyncTestHelpers.GetUserAsync();
var bob = await SyncTestHelpers.GetUserAsync();
var realmUri = SyncTestHelpers.RealmUri($"{alice.Identity}/GetInstanceAsync_OpensReadonlyRealm");
var aliceConfig = new FullSyncConfiguration(realmUri, alice, Guid.NewGuid().ToString());
var aliceRealm = GetRealm(aliceConfig);
await alice.ApplyPermissionsAsync(PermissionCondition.UserId(bob.Identity), realmUri.AbsoluteUri, AccessLevel.Read).Timeout(1000);
AddDummyData(aliceRealm, singleTransaction);
var bobConfig = new FullSyncConfiguration(realmUri, bob, Guid.NewGuid().ToString());
var bobRealm = await GetRealmAsync(bobConfig);
var bobsObjects = bobRealm.All <IntPrimaryKeyWithValueObject>();
var alicesObjects = aliceRealm.All <IntPrimaryKeyWithValueObject>();
Assert.That(bobsObjects.Count(), Is.EqualTo(alicesObjects.Count()));
var bobTcs = new TaskCompletionSource <object>();
bobsObjects.AsRealmCollection().CollectionChanged += (sender, e) =>
{
bobTcs.TrySetResult(null);
};
aliceRealm.Write(() =>
{
aliceRealm.Add(new IntPrimaryKeyWithValueObject
{
Id = 9999,
StringValue = "Some value"
});
});
await bobTcs.Task.Timeout(1000);
Assert.That(bobsObjects.Count(), Is.EqualTo(alicesObjects.Count()));
var bobObject = bobRealm.Find <IntPrimaryKeyWithValueObject>(9999);
Assert.That(bobObject, Is.Not.Null);
Assert.That(bobObject.StringValue, Is.EqualTo("Some value"));
});
}
private async Task OpenRealm()
{
await Task.Yield();
var dialog = new ProgressDialog(new ProgressDialogConfig
{
IsDeterministic = true,
Title = "Downloading Realm...",
AutoShow = true,
MaskType = MaskType.Black,
});
try
{
dialog.Show();
var user = await User.LoginAsync(Constants.Credentials, Constants.AuthUri);
var config = new FullSyncConfiguration(Constants.RealmUri, user)
{
OnProgress = (progress) =>
{
dialog.PercentComplete = (int)(progress.TransferredBytes * 100 / progress.TransferableBytes);
}
};
_realm = await Realm.GetInstanceAsync(config);
var feedItems = _realm.All <FeedItem>().OrderByDescending(f => f.Date);
var tvSource = FeedTableView.Source as FeedDataSource;
tvSource.SetSource(feedItems);
dialog.Hide();
FeedTableView.ReloadData();
}
catch (Exception ex)
{
Console.WriteLine(ex);
dialog.Hide();
await UserDialogs.Instance.AlertAsync("An error occurred", ex.ToString());
}
finally
{
await Task.Delay(10);
dialog.Hide();
}
}
public void Realm_GetSession_WhenSyncedRealm()
{
TestHelpers.RunAsyncTest(async() =>
{
var user = await SyncTestHelpers.GetFakeUserAsync();
var serverUri = new Uri("realm://localhost:9080/foobar");
var config = new FullSyncConfiguration(serverUri, user);
using (var realm = GetRealm(config))
{
var session = GetSession(realm);
Assert.That(session.User, Is.EqualTo(user));
Assert.That(session.ServerUri, Is.EqualTo(serverUri));
}
});
}
static void Main(string[] args)
{
var basePath = Path.Combine(Directory.GetCurrentDirectory(), "Realms");
Directory.CreateDirectory(basePath);
FullSyncConfiguration.Initialize(UserPersistenceMode.Disabled, basePath: basePath);
var credentials = new BasicAWSCredentials("access", "secret");
FileManager.Initialize(new FileManagerOptions
{
PersistenceLocation = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
RemoteManagerFactory = () => new S3FileManager(credentials, RegionEndpoint.EUNorth1)
});
AsyncContext.Run(MainAsync);
}
private void EnsureRealmIsInitialized()
{
if (_realm == null)
{
try
{
var loginTask = Task.Run <User>
(
async() =>
await User.LoginAsync
(
Credentials.UsernamePassword
(
"*****@*****.**",
"welcome@1",
false
),
new Uri(AuthServerURL)
)
);
loginTask.Wait();
var user = loginTask.Result;
var syncConfig = new FullSyncConfiguration(new Uri(ServerURL), user)
{
ObjectClasses = new[]
{
typeof(AuditData),
typeof(BirthInfo),
typeof(EmailAddress),
typeof(PhoneNumber),
typeof(StreetAddress),
typeof(Contact)
}
};
_realm = Realm.GetInstance(syncConfig);
}
catch (Exception ex)
{
// FYI this is here just so that the XAML Designer doesn't freak out
Console.WriteLine(ex);
}
}
}
public void User_WhenCustomRefreshToken_CanUpdateToken()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTYiLCJuYW1lIjoiSm9obiBEb2UiLCJhZG1pbiI6dHJ1ZSwiaWF0IjoxNTE2MjM5MDIyLCJhdWQiOiJteUFwcCIsImlzcyI6Im15aXNzdWVyIn0.FmRf5n3o83vduCIShxmXOTWBegJwQqZKWNakIjQN3OAxfjJBK2tkSJGBqBBARN7nkEAWypGQzk1VkjuIKAZfGC1QpSSyv3RBw3D85hNs_aRvHgh2PXIiWbxMvRdZF6N5gN4Zi_47TsL67FqthQV6btOvrwqUuY5EY3vqW8LJT9D-966j6xmLOG7ZeEpWjNVvFx9nR5DmOYIXvamWGLCND_cqYhWcgrSs0I0FMZ6IxfjoiUZST5vc_c18XIbuszongqDUMJEIPbvjmN31tCuLXDuorf3eOpALIIsfR1Dt-RnkoOYAJrPTUjg_NnVqbIj0RzPzdbx7lClP1gZbE3HAjw";
var credentials = Credentials.CustomRefreshToken(token);
var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri);
Assert.That(token, Is.EqualTo(user.RefreshToken));
var config = new FullSyncConfiguration(new Uri($"/~/{Guid.NewGuid()}", UriKind.Relative), user);
// Can't use the async version as out token is expired
using (var expiredRealm = Realm.GetInstance(config))
{
expiredRealm.Write(() =>
{
expiredRealm.Add(new PrimaryKeyInt32Object
{
Int32Property = 456
});
});
}
var newToken = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTYiLCJuYW1lIjoiSm9obiBEb2UiLCJhZG1pbiI6dHJ1ZSwiaWF0IjoxNTE2MjM5MDIyLCJhdWQiOiJteUFwcCIsImlzcyI6Im15aXNzdWVyIiwic29tZXRoaW5nIjoiZWxzZSJ9.PnfTPoeLmfbjuuKDDzLyZ6BgLVjOmx8qazVdEkVxbjy5jtJnGIyyl77y71E4Auf4sIOqLzqs6Tve4JnrZIltXSzLBnmC76JPW9t3LT0-t09UGG7K0eTYaySlXgzjTZ1bEyc3plnr2Vw4y3g4uonmsU6fliaKoqpWnW-UHDMsPdRJR3BzQYIBkj3SSwCCb-uDRsZWQhyx2CyVvsJgAow_jae5oi38QO5UC6kqCMflUxMHDR5MmSRuhTvtA3Uk0rYMTnh4LzWhmL5yH_uSgBwluTcTJxnxU_jf_S9HqnbuBnyWbwlDVsd-ABffF-LkWhj1uSCW9OpSVBJyF5ekTYDqNQ";
user.RefreshToken = newToken;
Assert.That(newToken, Is.EqualTo(user.RefreshToken));
// Ensure we can still sync
using (var realm = await GetRealmAsync(config))
{
realm.Write(() =>
{
realm.Add(new PrimaryKeyInt32Object
{
Int32Property = 123
});
});
await GetSession(realm).WaitForUploadAsync();
// Ensure we have both objects
Assert.That(realm.All <PrimaryKeyInt32Object>().Count(), Is.EqualTo(2));
}
});
}
public void GetInstanceAsync_OpensReadonlyRealm(bool singleTransaction)
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var alice = await SyncTestHelpers.GetUserAsync();
var bob = await SyncTestHelpers.GetUserAsync();
var realmUri = SyncTestHelpers.RealmUri($"{alice.Identity}/GetInstanceAsync_OpensReadonlyRealm");
var aliceConfig = new FullSyncConfiguration(realmUri, alice, Guid.NewGuid().ToString());
var aliceRealm = GetRealm(aliceConfig);
await alice.ApplyPermissionsAsync(PermissionCondition.UserId(bob.Identity), realmUri.AbsoluteUri, AccessLevel.Read).Timeout(1000);
AddDummyData(aliceRealm, singleTransaction);
await WaitForUploadAsync(aliceRealm);
var bobConfig = new FullSyncConfiguration(realmUri, bob, Guid.NewGuid().ToString());
var bobRealm = await GetRealmAsync(bobConfig);
var bobsObjects = bobRealm.All <IntPrimaryKeyWithValueObject>();
var alicesObjects = aliceRealm.All <IntPrimaryKeyWithValueObject>();
Assert.That(bobsObjects.Count(), Is.EqualTo(alicesObjects.Count()));
aliceRealm.Write(() =>
{
aliceRealm.Add(new IntPrimaryKeyWithValueObject
{
Id = 9999,
StringValue = "Some value"
});
});
await WaitForUploadAsync(aliceRealm);
await WaitForDownloadAsync(bobRealm);
await bobRealm.RefreshAsync();
Assert.That(bobsObjects.Count(), Is.EqualTo(alicesObjects.Count()));
var bobObject = bobRealm.Find <IntPrimaryKeyWithValueObject>(9999);
Assert.That(bobObject, Is.Not.Null);
Assert.That(bobObject.StringValue, Is.EqualTo("Some value"));
});
}
async public static Task <Realm> GetRealm1(bool async = false, bool compact = false)
{
if (AppConfig && Realm != null)
{
return(Realm);
}
if (SRealmUri == null)
{
//SRealmUri = await RealmURI();
//SRealmPath = await RealmPath();
SRealmUri = Settings.RealmUri;
SRealmPath = Settings.RealmPath;
}
if (User == null || async)
{
User = await User.LoginAsync(Credentials.UsernamePassword(Settings.RealmUser, Settings.RealmPassword, false), new Uri(SRealmUri));
}
var realmUrl = new Uri(SRealmPath);
var config = new FullSyncConfiguration(realmUrl, User);
//config.SchemaVersion = 6;
Realm realm = null;
if (async)
{
if (compact)
{
Realm.Compact(config);
}
realm = await Realm.GetInstanceAsync(config);
}
else
{
realm = Realm.GetInstance(config);
}
if (AppConfig)
{
Realm = realm;
}
return(realm);
}
public void GetInstanceAsync_ReportsProgress()
{
SyncTestHelpers.RequiresRos();
AsyncContext.Run(async() =>
{
var realmPath = Guid.NewGuid().ToString();
var user = await SyncTestHelpers.GetUserAsync();
var config = new FullSyncConfiguration(new Uri($"/~/{realmPath}", UriKind.Relative), user, Guid.NewGuid().ToString());
const int ObjectSize = 1000000;
const int ObjectsToRecord = 20;
using (var realm = GetRealm(config))
{
for (var i = 0; i < ObjectsToRecord; i++)
{
realm.Write(() =>
{
realm.Add(new HugeSyncObject(ObjectSize));
});
}
await WaitForSyncAsync(realm);
}
var callbacksInvoked = 0;
var lastProgress = default(SyncProgress);
config = new FullSyncConfiguration(new Uri($"/~/{realmPath}", UriKind.Relative), user, Guid.NewGuid().ToString())
{
OnProgress = (progress) =>
{
callbacksInvoked++;
lastProgress = progress;
}
};
using (var realm = await GetRealmAsync(config))
{
Assert.That(realm.All <HugeSyncObject>().Count(), Is.EqualTo(ObjectsToRecord));
Assert.That(callbacksInvoked, Is.GreaterThan(0));
Assert.That(lastProgress.TransferableBytes, Is.EqualTo(lastProgress.TransferredBytes));
}
});
}
public void UserLogin_WhenCustomRefreshToken_LogsUserIn()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJuYW1lIjoiSm9obiBEb2UiLCJhZG1pbiI6dHJ1ZSwiaWF0IjoxNTE2MjM5MDIyLCJhdWQiOiJteUFwcCIsImlzcyI6Im15aXNzdWVyIn0.Xhl39nnVXIgTUqDKEfz2mDiHcfH8vZGDC4gJxAHZmQ_usf-uXTXfDxkjME2W5ynKeWUQrzIhOliHaouJq-XJpzqKPvQ4d70LwtijNC53O4SUaHHaTkhh98OLOZif0md7xHeeEJAI9sixNK4GDzA88a2K5dZ9dmv3XJJ3url481CNK5mSCMgTcN5dzChbewmJ327J7mDsHF74Nvdazevk7UyShLz0YfJaPr2ny9feUXcG7yMRTfg3XoSHGUZ1IDDyvjjslfelTZWIR3ccmiua2wyN1EKAQE0o1Ft89VFHDxIHVvfgdXr9aQvtEaPR7-GChL8rx1WiqujSMJ0DZC80gQ";
var credentials = Credentials.CustomRefreshToken(token);
var realmPath = Guid.NewGuid().ToString();
var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri);
var config = new FullSyncConfiguration(new Uri($"/~/{realmPath}", UriKind.Relative), user);
using (var realm = await GetRealmAsync(config))
{
realm.Write(() =>
{
realm.Add(new PrimaryKeyInt32Object
{
Int32Property = 123
});
});
await GetSession(realm).WaitForUploadAsync();
}
var token2 = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0NTYiLCJuYW1lIjoiSm9obiBEb2UiLCJhZG1pbiI6dHJ1ZSwiaWF0IjoxNTE2MjM5MDIyLCJhdWQiOiJteUFwcCIsImlzcyI6Im15aXNzdWVyIn0.Hum9NA5KfBqKNsRN6hckbijSAME4LfH2xwmqwPrfjVEBlHRg6HIOnV4gxjY_KUhaazjsExNjAGEhxAamTiefHgvTryVlXwgLjaVs2DpR7F2t1JkpB9b7bU8fo0XV1ZhQ40s9_s3_t6Gdaf8cewSr2ADe0q71c09kP4VtxHQlzXkKuDjkwVXhaXFKglaJNy2Lhk04ybKJn0g_H-sWv2keTW1-J1RhZCzkB_o1Xv-SqoB_n5lahZ3rSUvbQalcQn20mOetTlfAkYfi3Eee4bYzc0iykDdG124uUnQVXXiQR67qlB4zqJ1LuG84KBYcO7W5g_kIBq7YzNaP68xT_x2YBw";
var credentials2 = Credentials.CustomRefreshToken(token2);
var user2 = await User.LoginAsync(credentials2, SyncTestHelpers.AuthServerUri);
await user.ApplyPermissionsAsync(PermissionCondition.UserId(user2.Identity), $"/~/{realmPath}", AccessLevel.Write);
var permissions = await user2.GetGrantedPermissionsAsync(Recipient.CurrentUser);
var userFooPermission = permissions.SingleOrDefault(p => p.Path.EndsWith($"/{realmPath}"));
Assert.That(userFooPermission, Is.Not.Null);
var config2 = new FullSyncConfiguration(new Uri(userFooPermission.Path, UriKind.Relative), user2);
using (var realm = await GetRealmAsync(config2))
{
var objects = realm.All <PrimaryKeyInt32Object>();
Assert.That(objects.Count(), Is.EqualTo(1));
Assert.That(objects.Single().Int32Property, Is.EqualTo(123));
}
});
}
