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)); } }); }