public void Test_ObjectDelete()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
var reader = PermissionRole.Get(r, "reader");
reader.Users.Add(userA);
reader.Users.Add(userB);
var writer = PermissionRole.Get(r, "writer");
writer.Users.Add(userA);
var obj1 = r.Add(new ObjectWithPermissions
{
Id = 1,
StringValue = "Value 1"
});
CreatePermissions(obj1.Permissions);
}, addObjects: false);
using (var realmA = GetRealm(userA, realmUri))
using (var realmB = GetRealm(userB, realmUri))
{
var subscriptionB = await SubscribeToObjectsAsync(realmB);
var objB = subscriptionB.Results.Single();
realmB.Write(() =>
{
realmB.Remove(objB);
});
Assert.That(subscriptionB.Results.Count(), Is.Zero);
await SyncTestHelpers.WaitForSyncAsync(realmB);
Assert.That(subscriptionB.Results.Count(), Is.EqualTo(1));
objB = subscriptionB.Results.Single();
var subscriptionA = await SubscribeToObjectsAsync(realmA);
var objA = subscriptionA.Results.Single();
realmA.Write(() =>
{
realmA.Remove(objA);
});
await SyncTestHelpers.WaitForSyncAsync(realmA);
await SyncTestHelpers.WaitForSyncAsync(realmB);
Assert.That(subscriptionA.Results.Count(), Is.Zero);
Assert.That(subscriptionB.Results.Count(), Is.Zero);
Assert.That(objA.IsValid, Is.False);
Assert.That(objB.IsValid, Is.False);
}
});
}
public void Test_ClassUpdate()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
CreatePermissions(ClassPermission.Get <ObjectWithPermissions>(r).Permissions);
var reader = PermissionRole.Get(r, "reader");
reader.Users.Add(userA);
reader.Users.Add(userB);
var writer = PermissionRole.Get(r, "writer");
writer.Users.Add(userA);
});
using (var realm = GetRealm(userA, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe | ClassPrivileges.Update | ClassPrivileges.Create);
AssertObjectPrivileges(realm, ObjectPrivileges.Read | ObjectPrivileges.Update | ObjectPrivileges.Delete | ObjectPrivileges.SetPermissions);
var obj = realm.Find <ObjectWithPermissions>(1);
realm.Write(() =>
{
obj.StringValue = "New value";
});
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(obj.StringValue, Is.EqualTo("New value"));
}
using (var realm = GetRealm(userB, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe);
AssertObjectPrivileges(realm, ObjectPrivileges.Read);
var obj = realm.Find <ObjectWithPermissions>(1);
realm.Write(() =>
{
obj.StringValue = "New value 2";
});
Assert.That(obj.StringValue, Is.EqualTo("New value 2"));
await SyncTestHelpers.WaitForSyncAsync(realm);
// Change is reverted
Assert.That(obj.StringValue, Is.EqualTo("New value"));
}
});
}
public void Test_ObjectUpdate()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
var reader = PermissionRole.Get(r, "reader");
reader.Users.Add(userA);
reader.Users.Add(userB);
var writer = PermissionRole.Get(r, "writer");
writer.Users.Add(userA);
var obj1 = r.Add(new ObjectWithPermissions
{
Id = 1,
StringValue = "Value 1"
});
CreatePermissions(obj1.Permissions);
}, addObjects: false);
using (var realm = GetRealm(userA, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
var obj1 = subscription.Results.Single();
realm.Write(() =>
{
obj1.StringValue = "New value";
});
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(obj1.StringValue, Is.EqualTo("New value"));
}
using (var realm = GetRealm(userB, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
var obj1 = subscription.Results.Single();
realm.Write(() =>
{
obj1.StringValue = "New value #2";
});
Assert.That(obj1.StringValue, Is.EqualTo("New value #2"));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(obj1.StringValue, Is.EqualTo("New value"));
}
});
}
public void Test_RealmUpdate()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
CreatePermissions(RealmPermission.Get(r).Permissions);
var reader = PermissionRole.Get(r, "reader");
reader.Users.Add(userA);
reader.Users.Add(userB);
var writer = PermissionRole.Get(r, "writer");
writer.Users.Add(userA);
});
using (var realm = GetRealm(userA, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe | ClassPrivileges.Create | ClassPrivileges.SetPermissions | ClassPrivileges.Update);
AssertObjectPrivileges(realm, ObjectPrivileges.Read | ObjectPrivileges.Delete | ObjectPrivileges.SetPermissions | ObjectPrivileges.Update);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
AddObjectsToRealm(realm, new[] { 4, 5, 6 });
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
}
using (var realm = GetRealm(userB, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe);
AssertObjectPrivileges(realm, ObjectPrivileges.Read);
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
AddObjectsToRealm(realm, new[] { 7, 8, 9 });
Assert.That(subscription.Results.Count(), Is.EqualTo(9));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
}
});
}
public void Test_RealmRead()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
CreatePermissions(RealmPermission.Get(r).Permissions);
var role = PermissionRole.Get(r, "reader");
role.Users.Add(userA);
});
using (var realm = GetRealm(userA, realmUri))
{
var query = realm.All <ObjectWithPermissions>();
var subscription = query.Subscribe();
await subscription.WaitForSynchronizationAsync().Timeout(2000);
AssertRealmPrivileges(realm, RealmPrivileges.Read);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe);
AssertObjectPrivileges(realm, ObjectPrivileges.Read);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
AddObjectsToRealm(realm, new[] { 4, 5, 6 });
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
}
using (var realm = GetRealm(userB, realmUri))
{
var query = realm.All <ObjectWithPermissions>();
var subscription = query.Subscribe();
await subscription.WaitForSynchronizationAsync().Timeout(2000);
AssertRealmPrivileges(realm, 0);
AssertClassPrivileges(realm, 0);
Assert.That(subscription.Results.Count(), Is.Zero);
}
});
}
public void GetInstanceAsync_ReportsProgress()
{
SyncTestHelpers.RunRosTestAsync(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 SyncTestHelpers.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 Test_ClassRead()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
CreatePermissions(ClassPermission.Get <ObjectWithPermissions>(r).Permissions);
var reader = PermissionRole.Get(r, "reader");
reader.Users.Add(userA);
});
using (var realm = GetRealm(userA, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe);
AssertObjectPrivileges(realm, ObjectPrivileges.Read);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
AddObjectsToRealm(realm, new[] { 4, 5, 6 });
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
}
using (var realm = GetRealm(userB, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, 0);
Assert.That(subscription.Results.Count(), Is.EqualTo(0));
}
});
}
public void Test_ObjectSetPermissions()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(assignRoles: null, addObjects: false);
using (var realm = GetRealm(userA, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
realm.Write(() =>
{
var obj1 = realm.Add(new ObjectWithPermissions
{
Id = 1,
StringValue = "1"
});
var foo = PermissionRole.Get(realm, "foo");
var permission = Permission.Get(foo, obj1);
permission.CanRead = true;
foo.Users.Add(userB);
});
Assert.That(subscription.Results.Count(), Is.EqualTo(1));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(0));
}
using (var realm = GetRealm(userB, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(1));
}
});
}
private async Task <Uri> CreateRealm(Action <Realm> assignRoles = null, bool addObjects = true)
{
var uri = SyncTestHelpers.RealmUri(Guid.NewGuid().ToString());
var admin = await SyncTestHelpers.GetAdminUserAsync();
var config = new QueryBasedSyncConfiguration(uri, admin)
{
ObjectClasses = new[] { typeof(ObjectWithPermissions) }
};
using (var realm = GetRealm(config))
{
var objects = realm.All <ObjectWithPermissions>();
var subscription = await SubscribeToObjectsAsync(realm);
if (addObjects)
{
Assert.That(subscription.Results.Count(), Is.EqualTo(0));
AddObjectsToRealm(realm, new[] { 1, 2, 3 });
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
}
if (assignRoles != null)
{
realm.Write(() =>
{
assignRoles(realm);
});
}
await SyncTestHelpers.WaitForSyncAsync(realm);
}
return(uri);
}
public void Test_ClassSetPermissions()
{
SyncTestHelpers.RunRosTestAsync(async() =>
{
var userA = await SyncTestHelpers.GetUserAsync();
var userB = await SyncTestHelpers.GetUserAsync();
var userC = await SyncTestHelpers.GetUserAsync();
var realmUri = await CreateRealm(r =>
{
CreatePermissions(ClassPermission.Get <ObjectWithPermissions>(r).Permissions);
var reader = PermissionRole.Get(r, "reader");
reader.Users.Add(userA);
reader.Users.Add(userB);
reader.Users.Add(userC);
var writer = PermissionRole.Get(r, "writer");
writer.Users.Add(userA);
writer.Users.Add(userB);
var admin = PermissionRole.Get(r, "admin");
admin.Users.Add(userA);
});
using (var realm = GetRealm(userB, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
// B is 'writer' - shouldn't be able to update the role access level
realm.Write(() =>
{
var readerPermission = Permission.Get <ObjectWithPermissions>("reader", realm);
readerPermission.CanUpdate = true;
readerPermission.CanCreate = true;
});
await SyncTestHelpers.WaitForSyncAsync(realm);
}
using (var realm = GetRealm(userC, realmUri))
{
// C shouldn't be able to create objects
var subscription = await SubscribeToObjectsAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe);
AssertObjectPrivileges(realm, ObjectPrivileges.Read);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
AddObjectsToRealm(realm, new[] { 4, 5, 6 });
Assert.That(subscription.Results.Count(), Is.EqualTo(6));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(subscription.Results.Count(), Is.EqualTo(3));
}
using (var realm = GetRealm(userA, realmUri))
{
var subscription = await SubscribeToObjectsAsync(realm);
// A should be able to update role access level
realm.Write(() =>
{
var readerPermission = Permission.Get <ObjectWithPermissions>("reader", realm);
readerPermission.CanUpdate = true;
readerPermission.CanCreate = true;
});
await SyncTestHelpers.WaitForSyncAsync(realm);
}
using (var realm = GetRealm(userC, realmUri))
{
// C should now be able to create objects
// Why does my subscription timeout?
// var subscription = await SubscribeToObjectsAsync(realm);
await SyncTestHelpers.WaitForSyncAsync(realm);
AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions);
AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe | ClassPrivileges.Update | ClassPrivileges.Create);
AssertObjectPrivileges(realm, ObjectPrivileges.Read | ObjectPrivileges.Update | ObjectPrivileges.Delete | ObjectPrivileges.SetPermissions);
var objects = realm.All <ObjectWithPermissions>();
Assert.That(objects.Count(), Is.EqualTo(3));
AddObjectsToRealm(realm, new[] { 4, 5, 6 });
Assert.That(objects.Count(), Is.EqualTo(6));
await SyncTestHelpers.WaitForSyncAsync(realm);
Assert.That(objects.Count(), Is.EqualTo(6));
}
});
}
