public void CallFunction_WrongGeneric() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var ex = await TestHelpers.AssertThrows <Exception>(() => user.Functions.CallAsync <string>("sumFunc", 1, 2)); Assert.That(ex.Message, Does.Contain("Cannot deserialize")); }); }
public void CallFunction_NoArguments() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var result = await user.Functions.CallAsync <int>("sumFunc"); Assert.That(result, Is.EqualTo(0)); }); }
public void CallFunctionGeneric_ReturnsResult() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var result = await user.Functions.CallAsync <int>("sumFunc", 1, 2, 3); Assert.That(result, Is.EqualTo(6)); }); }
public void UserLogin_WhenAnonymous_LogsUserIn() { SyncTestHelpers.RunRosTestAsync(async() => { var credentials = Credentials.Anonymous(); var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri); Assert.That(user, Is.Not.Null); Assert.That(user.Identity, Is.Not.Null); }); }
public void UserLogin_WhenAnonymousAndDifferentCredentials_ShouldLoginDifferentUser() { SyncTestHelpers.RunRosTestAsync(async() => { var first = await User.LoginAsync(Credentials.Anonymous(), SyncTestHelpers.AuthServerUri); var second = await User.LoginAsync(Credentials.Anonymous(), SyncTestHelpers.AuthServerUri); Assert.That(first.Identity, Is.Not.EqualTo(second.Identity)); Assert.That(User.AllLoggedIn.Length, Is.EqualTo(2)); }); }
public void UserLogin_WhenNickname_LogsUserIn() { SyncTestHelpers.RunRosTestAsync(async() => { var credentials = Credentials.Nickname(Guid.NewGuid().ToString()); var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri); Assert.That(user, Is.Not.Null); Assert.That(user.Identity, Is.Not.Null); }); }
protected async Task <User> GetUserAsync(App app = null) { app ??= DefaultApp; var username = SyncTestHelpers.GetVerifiedUsername(); await app.EmailPasswordAuth.RegisterUserAsync(username, SyncTestHelpers.DefaultPassword); var credentials = Credentials.EmailPassword(username, SyncTestHelpers.DefaultPassword); return(await app.LogInAsync(credentials)); }
public void OpenRealm_Int64PK_Works() { SyncTestHelpers.RunBaasTestAsync(async() => { var partitionValue = TestHelpers.Random.Next(0, int.MaxValue); var config1 = await GetIntegrationConfigAsync(partitionValue); var config2 = await GetIntegrationConfigAsync(partitionValue); await RunPartitionKeyTestsCore(config1, config2); }); }
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 OpenRealm_GuidPK_Works() { SyncTestHelpers.RunBaasTestAsync(async() => { var partitionValue = Guid.NewGuid(); var config1 = await GetIntegrationConfigAsync(partitionValue); var config2 = await GetIntegrationConfigAsync(partitionValue); await RunPartitionKeyTestsCore(config1, config2); }); }
public void UserApiKeys_Fetch_WhenNoneExist_ReturnsNull() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var apiKey = await user.ApiKeys.FetchAsync(ObjectId.GenerateNewId()); Assert.That(apiKey, Is.Null); }); }
public void CallFunction_AndTestDeserialization_Null() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); string str = null; var result = await user.Functions.CallAsync <string>("mirror", str); Assert.That(result, Is.Null); }); }
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>()); }); }
public void DefaultConfiguration_WhenOneUserLoggedIn_ShouldWork(string userScheme, string realmScheme) { TestHelpers.RunAsyncTest(async() => { await SyncTestHelpers.GetFakeUserAsync(scheme: userScheme); var config = new QueryBasedSyncConfiguration(); Assert.That(!config.IsFullSync); Assert.That(config.ServerUri.Scheme, Is.EqualTo(realmScheme)); Assert.That(config.ServerUri.Segments, Is.EqualTo(new[] { "/", "default" })); }); }
public void UserAllLoggedIn_WhenThereIsOneUser_ShouldReturnThatUser() { TestHelpers.RunAsyncTest(async() => { var user = await SyncTestHelpers.GetFakeUserAsync(); var users = User.AllLoggedIn; Assert.That(users.Length, Is.EqualTo(1)); Assert.That(users[0], Is.EqualTo(user)); }); }
public void User_OfferPermissions_WhenExpired_ShouldThrow() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var realmUrl = SyncTestHelpers.RealmUri($"{alice.Identity}/testPermission").AbsoluteUri; await EnsureRealmExists(alice, realmUrl); await TestHelpers.AssertThrows <ArgumentException>(() => alice.OfferPermissionsAsync(realmUrl, AccessLevel.Write, DateTimeOffset.UtcNow.AddDays(-1))); }); }
public void User_OfferPermissions_WhenNoAccess_ShouldThrow() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var realmUrl = SyncTestHelpers.RealmUri($"{alice.Identity}/testPermission").AbsoluteUri; await EnsureRealmExists(alice, realmUrl); await TestHelpers.AssertThrows <ArgumentException>(() => alice.OfferPermissionsAsync(realmUrl, AccessLevel.None)); }); }
public void User_ApplyPermissions_WithEmail_GrantsAndRevokesPermissions() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var bobEmail = $"{Guid.NewGuid()}@foo.bar"; var bobCredentials = Credentials.UsernamePassword(bobEmail, "a", createUser: true); var bob = await User.LoginAsync(bobCredentials, SyncTestHelpers.AuthServerUri); await TestApplyPermissions(alice, bob, PermissionCondition.Email(bobEmail)).Timeout(20000); }); }
public void User_AcceptPermissionOffer_WhenTokenIsInvalid_ShouldGetError() { SyncTestHelpers.RunRosTestAsync(async() => { var user = await SyncTestHelpers.GetUserAsync(); await TestHelpers.AssertThrows <HttpException>(() => user.AcceptPermissionOfferAsync("some string"), ex => { Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCode.InvalidParameters)); }); }); }
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)); } }); }
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); }
public void UserLogin_WhenNicknameAfterLogout_LogsSameUserIn() { SyncTestHelpers.RunRosTestAsync(async() => { var nickname = Guid.NewGuid().ToString(); var first = await User.LoginAsync(Credentials.Nickname(nickname), SyncTestHelpers.AuthServerUri); await first.LogOutAsync(); var second = await User.LoginAsync(Credentials.Nickname(nickname), SyncTestHelpers.AuthServerUri); Assert.That(first.Identity, Is.EqualTo(second.Identity)); }); }
public void GetInstance_WhenDynamicAndDoesntExist_ReturnsEmptySchema() { TestHelpers.RunAsyncTest(async() => { var config = await SyncTestHelpers.GetFakeConfigAsync(); config.IsDynamic = true; using (var realm = GetRealm(config)) { Assert.That(realm.Schema, Is.Empty); } }); }
public void User_LinkCredentials_WhenAnonymous_Throws() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var ex = await TestHelpers.AssertThrows <AppException>(() => user.LinkCredentialsAsync(Credentials.Anonymous())); // TODO: this should be bad request when https://jira.mongodb.org/browse/REALMC-7028 is fixed Assert.That(ex.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError)); Assert.That(ex.Message, Does.Contain("linking an anonymous identity is not allowed")); }); }
public void UserApiKeys_Create_CreatesApiKeyAndRevealsValue() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var apiKey = await user.ApiKeys.CreateAsync("my-api-key"); Assert.That(apiKey.IsEnabled); Assert.That(apiKey.Name, Is.EqualTo("my-api-key")); Assert.That(apiKey.Value, Is.Not.Null); Assert.That(apiKey.Id, Is.Not.EqualTo(default(ObjectId))); }); }
public void UserApiKeys_Fetch_WhenIdMatches_ReturnsKey() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var key = await user.ApiKeys.CreateAsync("foo"); var fetched = await user.ApiKeys.FetchAsync(key.Id); Assert.That(fetched, Is.Not.Null); AssertKeysAreSame(key, fetched); }); }
/// <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 User_Facebook_LogsInAndReadsDataFromFacebook() { SyncTestHelpers.RunBaasTestAsync(async() => { const string fbToken = "EAAFYw2aZAL1EBAHBBH22XBDZAutJFQ65KxH0bZAexYul5KtsHcjhI722XYEr4jKlaNvlosFsdZCT8dGUQNy2euZB684mpvtIIJEWWYMoH66bbEbKIrHRWqZBC8KMpSscoyzhFTJMpDYsrIilZBRN1A6bicXGaUNXVz5A0ucyZB7WkmQ8uUmdRWel9q6S8BJH3ZBCZAzWtcZCYmgEwZDZD"; var credentials = Credentials.Facebook(fbToken); var user = await DefaultApp.LogInAsync(credentials); Assert.That(user.Id, Is.Not.Null); Assert.That(user.Profile.FirstName, Is.Not.Null); Assert.That(user.Profile.LastName, Is.Not.Null); }); }
public void UserApiKeys_FetchAll_WithOneKey() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var key1 = await user.ApiKeys.CreateAsync("foo"); var keys = await user.ApiKeys.FetchAllAsync(); Assert.That(keys.Count(), Is.EqualTo(1)); AssertKeysAreSame(key1, keys.Single()); }); }
public void UserApiKeys_Create_WithInvalidName_Throws() { SyncTestHelpers.RunBaasTestAsync(async() => { var user = await GetUserAsync(); var ex = await TestHelpers.AssertThrows <AppException>(() => user.ApiKeys.CreateAsync("My very cool key")); Assert.That(ex.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest)); Assert.That(ex.Message, Does.Contain("InvalidParameter")); Assert.That(ex.Message, Does.Contain("can only contain ASCII letters, numbers, underscores, and hyphens")); Assert.That(ex.HelpLink, Does.Contain("logs?co_id=")); }); }