public Task TestBecome() { IObjectState state = new MutableObjectState { ObjectId = "some0neTol4v4", ServerData = new Dictionary<string, object>() { { "sessionToken", "llaKcolnu" } } }; var mockController = new Mock<IAVUserController>(); mockController.Setup(obj => obj.GetUserAsync("llaKcolnu", It.IsAny<CancellationToken>())).Returns(Task.FromResult(state)); AVPlugins.Instance = new AVPlugins { UserController = mockController.Object }; AVObject.RegisterSubclass<AVUser>(); AVObject.RegisterSubclass<AVSession>(); return AVUser.BecomeAsync("llaKcolnu").ContinueWith(t => { Assert.False(t.IsFaulted); Assert.False(t.IsCanceled); mockController.Verify(obj => obj.GetUserAsync("llaKcolnu", It.IsAny<CancellationToken>()), Times.Exactly(1)); var user = t.Result; Assert.AreEqual("some0neTol4v4", user.ObjectId); Assert.AreEqual("llaKcolnu", user.SessionToken); }); }
public Task TestGetCurrentSession() { IObjectState sessionState = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "sessionToken", "newllaKcolnu" } } }; var mockController = new Mock<IParseSessionController>(); mockController.Setup(obj => obj.GetSessionAsync(It.IsAny<string>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(sessionState)); IObjectState userState = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "sessionToken", "llaKcolnu" } } }; ParseUser user = ParseObject.FromState<ParseUser>(userState, "_User"); var mockCurrentUserController = new Mock<IParseCurrentUserController>(); mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny<CancellationToken>())) .Returns(Task.FromResult(user)); ParseCorePlugins.Instance.SessionController = mockController.Object; ParseCorePlugins.Instance.CurrentUserController = mockCurrentUserController.Object; return ParseSession.GetCurrentSessionAsync().ContinueWith(t => { Assert.False(t.IsFaulted); Assert.False(t.IsCanceled); mockController.Verify(obj => obj.GetSessionAsync(It.Is<string>(sessionToken => sessionToken == "llaKcolnu"), It.IsAny<CancellationToken>()), Times.Exactly(1)); var session = t.Result; Assert.AreEqual("newllaKcolnu", session.SessionToken); }); }
public void TestApplyState() { var now = new DateTime(); IObjectState state = new MutableObjectState { ClassName = "Corgi", ObjectId = "abcd", ServerData = new Dictionary<string, object>() { { "exist", 2 }, { "change", "teletubies" } } }; IObjectState appliedState = new MutableObjectState { ClassName = "AnotherCorgi", ObjectId = "1234", CreatedAt = now, ServerData = new Dictionary<string, object>() { { "exist", 9 }, { "missing", "marasy" } } }; state = state.MutatedClone(mutableClone => { mutableClone.Apply(appliedState); }); Assert.AreEqual("Corgi", state.ClassName); Assert.AreEqual("1234", state.ObjectId); Assert.IsNotNull(state.CreatedAt); Assert.IsNull(state.UpdatedAt); Assert.AreEqual(3, state.Count()); Assert.AreEqual(9, state["exist"]); Assert.AreEqual("teletubies", state["change"]); Assert.AreEqual("marasy", state["missing"]); }
public void TestApplyOperation() { IAVFieldOperation op1 = new AVIncrementOperation(7); IAVFieldOperation op2 = new AVSetOperation("legendia"); IAVFieldOperation op3 = new AVSetOperation("vesperia"); var operations = new Dictionary<string, IAVFieldOperation>() { { "exist", op1 }, { "missing", op2 }, { "change", op3 } }; IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "exist", 2 }, { "change", "teletubies" } } }; Assert.AreEqual(2, state["exist"]); Assert.AreEqual("teletubies", state["change"]); state = state.MutatedClone(mutableClone => { mutableClone.Apply(operations); }); Assert.AreEqual(3, state.Count()); Assert.AreEqual(9, state["exist"]); Assert.AreEqual("legendia", state["missing"]); Assert.AreEqual("vesperia", state["change"]); }
public Task TestCurrentSessionToken() { var storageController = new Mock<IStorageController>(); var mockedStorage = new Mock<IStorageDictionary<string, object>>(); var controller = new AVCurrentUserController(storageController.Object); storageController.Setup(c => c.LoadAsync()).Returns(Task.FromResult(mockedStorage.Object)); return controller.GetCurrentSessionTokenAsync(CancellationToken.None).OnSuccess(t => { Assert.IsNull(t.Result); // We should probably mock this. var userState = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "sessionToken", "randomString" } } }; var user = AVObject.CreateWithoutData<AVUser>(null); user.HandleFetchResult(userState); return controller.SetAsync(user, CancellationToken.None); }).Unwrap() .OnSuccess(_ => controller.GetCurrentSessionTokenAsync(CancellationToken.None)).Unwrap() .OnSuccess(t => { Assert.AreEqual("randomString", t.Result); }); }
public void TestGetSessionToken() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "sessionToken", "llaKcolnu" } } }; ParseSession session = ParseObject.FromState<ParseSession>(state, "_Session"); Assert.NotNull(session); Assert.AreEqual("llaKcolnu", session.SessionToken); }
public void TestSessionTokenGetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "username", "kevin" }, { "sessionToken", "se551onT0k3n" } } }; ParseUser user = ParseObject.FromState<ParseUser>(state, "_User"); Assert.AreEqual("se551onT0k3n", user.SessionToken); }
public void TestUsernameGetterSetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "username", "kevin" }, } }; ParseUser user = ParseObject.FromState<ParseUser>(state, "_User"); Assert.AreEqual("kevin", user.Username); user.Username = "******"; Assert.AreEqual("ilya", user.Username); }
public void TestRemoveFields() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "username", "kevin" }, { "name", "andrew" } } }; ParseUser user = ParseObject.FromState<ParseUser>(state, "_User"); Assert.Throws<ArgumentException>(() => user.Remove("username")); Assert.DoesNotThrow(() => user.Remove("name")); Assert.False(user.ContainsKey("name")); }
public void TestPasswordGetterSetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "username", "kevin" }, { "password", "hurrah" }, } }; ParseUser user = ParseObject.FromState<ParseUser>(state, "_User"); Assert.AreEqual("hurrah", user.State["password"]); user.Password = "******"; Assert.NotNull(user.CurrentOperations["password"]); }
public void TestEmailGetterSetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "email", "*****@*****.**" }, { "name", "andrew" }, { "sessionToken", "se551onT0k3n" } } }; ParseUser user = ParseObjectExtensions.FromState<ParseUser>(state, "_User"); Assert.AreEqual("*****@*****.**", user.Email); user.Email = "*****@*****.**"; Assert.AreEqual("*****@*****.**", user.Email); }
public void TestDefault() { IObjectState state = new MutableObjectState(); Assert.IsNull(state.ClassName); Assert.IsNull(state.ObjectId); Assert.IsNull(state.CreatedAt); Assert.IsNull(state.UpdatedAt); Assert.DoesNotThrow(() => { foreach (var pair in state) { Assert.IsNotNull(pair); } }); }
public void TestAppVersionGetterSetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "appVersion", "1.2.3" } } }; ParseInstallation installation = ParseObjectExtensions.FromState<ParseInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual("1.2.3", installation.AppVersion); Assert.Throws<InvalidOperationException>(() => installation["appVersion"] = "1.2.4"); installation.SetIfDifferent("appVersion", "1.2.4"); Assert.AreEqual("1.2.4", installation.AppVersion); }
public void TestDeviceTypeGetterSetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "deviceType", "parseOS" } } }; ParseInstallation installation = ParseObjectExtensions.FromState<ParseInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual("parseOS", installation.DeviceType); Assert.Throws<InvalidOperationException>(() => installation["deviceType"] = "gogoOS"); installation.SetIfDifferent("deviceType", "gogoOS"); Assert.AreEqual("gogoOS", installation.DeviceType); }
public void TestAppNameGetterSetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "appName", "parseApp" } } }; ParseInstallation installation = ParseObject.FromState<ParseInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual("parseApp", installation.AppName); Assert.Throws<InvalidOperationException>(() => installation.AppName = "gogoApp"); installation.SetIfDifferent("appName", "gogoApp"); Assert.AreEqual("gogoApp", installation.AppName); }
public void TestCurrentUser() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "sessionToken", "llaKcolnu" } } }; ParseUser user = ParseObject.FromState<ParseUser>(state, "_User"); var mockCurrentUserController = new Mock<IParseCurrentUserController>(); mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny<CancellationToken>())) .Returns(Task.FromResult(user)); ParseCorePlugins.Instance.CurrentUserController = mockCurrentUserController.Object; Assert.AreEqual(user, ParseUser.CurrentUser); }
public void TestContainsKey() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "Len", "Kagamine" }, { "Rin", "Kagamine" }, { "3", "Halyosy" } } }; Assert.True(state.ContainsKey("Len")); Assert.True(state.ContainsKey("Rin")); Assert.True(state.ContainsKey("3")); Assert.False(state.ContainsKey("Halyosy")); Assert.False(state.ContainsKey("Kagamine")); }
public void TestAppIdentifierGetterSetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "appIdentifier", "com.parse.app" } } }; AVInstallation installation = AVObjectExtensions.FromState<AVInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual("com.parse.app", installation.AppIdentifier); Assert.Throws<InvalidOperationException>(() => installation["appIdentifier"] = "com.parse.newapp"); installation.SetIfDifferent("appIdentifier", "com.parse.newapp"); Assert.AreEqual("com.parse.newapp", installation.AppIdentifier); }
public void TestAuthDataGetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "email", "*****@*****.**" }, { "authData", new Dictionary<string, object>() { { "facebook", new Dictionary<string, object>() { { "sessionToken", "none" } }} }} } }; ParseUser user = ParseObject.FromState<ParseUser>(state, "_User"); Assert.AreEqual(1, user.AuthData.Count); Assert.IsInstanceOf<IDictionary<string, object>>(user.AuthData["facebook"]); }
public void TestInstallationIdGetterSetter() { var guid = Guid.NewGuid(); IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "installationId", guid.ToString() } } }; ParseInstallation installation = ParseObject.FromState<ParseInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual(guid, installation.InstallationId); var newGuid = Guid.NewGuid(); Assert.Throws<InvalidOperationException>(() => installation.InstallationId = newGuid); installation.SetIfDifferent<string>("installationId", newGuid.ToString()); Assert.AreEqual(newGuid, installation.InstallationId); }
public void TestAdd() { IObjectState state = new MutableObjectState { ObjectId = "waGiManPutr4Pet1r", ClassName = "Pagi", CreatedAt = new DateTime(), ServerData = new Dictionary<string, object>() { { "username", "kevin" }, { "sessionToken", "se551onT0k3n" } } }; AVObject obj = AVObjectExtensions.FromState<AVObject>(state, "Omitted"); Assert.Throws<ArgumentException>(() => obj.Add("username", "kevin")); obj.Add("zeus", "bewithyou"); Assert.AreEqual("bewithyou", obj["zeus"]); }
public void TestProperties() { var now = new DateTime(); IObjectState state = new MutableObjectState { ClassName = "Corgi", UpdatedAt = now, CreatedAt = now, ServerData = new Dictionary<string, object>() { { "1", "Choucho" }, { "2", "Miku" }, { "3", "Halyosy" } } }; Assert.AreEqual("Corgi", state.ClassName); Assert.AreEqual(now, state.UpdatedAt); Assert.AreEqual(now, state.CreatedAt); Assert.AreEqual(3, state.Count()); Assert.AreEqual("Choucho", state["1"]); Assert.AreEqual("Miku", state["2"]); Assert.AreEqual("Halyosy", state["3"]); }
public Task TestSave() { var state = new MutableObjectState { ClassName = "Corgi", ObjectId = "st4nl3yW", ServerData = new Dictionary<string, object>() { { "corgi", "isNotDoge" }, } }; var operations = new Dictionary<string, IParseFieldOperation>() { { "gogo", new Mock<IParseFieldOperation>().Object } }; var responseDict = new Dictionary<string, object>() { { "__type", "Object" }, { "className", "Corgi" }, { "objectId", "st4nl3yW" }, { "doge", "isShibaInu" }, { "createdAt", "2015-09-18T18:11:28.943Z" } }; var response = new Tuple<HttpStatusCode, IDictionary<string, object>>(HttpStatusCode.Accepted, responseDict); var mockRunner = CreateMockRunner(response); var controller = new ParseObjectController(mockRunner.Object); return controller.SaveAsync(state, operations, null, CancellationToken.None).ContinueWith(t => { Assert.IsFalse(t.IsFaulted); Assert.IsFalse(t.IsCanceled); mockRunner.Verify(obj => obj.RunCommandAsync(It.Is<ParseCommand>(command => command.Uri.AbsolutePath == "/1/classes/Corgi/st4nl3yW"), It.IsAny<IProgress<ParseUploadProgressEventArgs>>(), It.IsAny<IProgress<ParseDownloadProgressEventArgs>>(), It.IsAny<CancellationToken>()), Times.Exactly(1)); var newState = t.Result; Assert.AreEqual("isShibaInu", newState["doge"]); Assert.False(newState.ContainsKey("corgi")); Assert.False(newState.ContainsKey("gogo")); Assert.NotNull(newState.CreatedAt); Assert.NotNull(newState.UpdatedAt); }); }
public Task TestSignUp() { var state = new MutableObjectState { ClassName = "_User", ServerData = new Dictionary<string, object>() { { "username", "hallucinogen" }, { "password", "secret" } } }; var operations = new Dictionary<string, IParseFieldOperation>() { { "gogo", new Mock<IParseFieldOperation>().Object } }; var responseDict = new Dictionary<string, object>() { { "__type", "Object" }, { "className", "_User" }, { "objectId", "d3ImSh3ki" }, { "sessionToken", "s3ss10nt0k3n" }, { "createdAt", "2015-09-18T18:11:28.943Z" } }; var response = new Tuple<HttpStatusCode, IDictionary<string, object>>(HttpStatusCode.Accepted, responseDict); var mockRunner = CreateMockRunner(response); var controller = new ParseUserController(mockRunner.Object); return controller.SignUpAsync(state, operations, CancellationToken.None).ContinueWith(t => { Assert.IsFalse(t.IsFaulted); Assert.IsFalse(t.IsCanceled); mockRunner.Verify(obj => obj.RunCommandAsync(It.Is<ParseCommand>(command => command.Uri.AbsolutePath == "/1/classes/_User"), It.IsAny<IProgress<ParseUploadProgressEventArgs>>(), It.IsAny<IProgress<ParseDownloadProgressEventArgs>>(), It.IsAny<CancellationToken>()), Times.Exactly(1)); var newState = t.Result; Assert.AreEqual("s3ss10nt0k3n", newState["sessionToken"]); Assert.AreEqual("d3ImSh3ki", newState.ObjectId); Assert.NotNull(newState.CreatedAt); Assert.NotNull(newState.UpdatedAt); }); }
public void TestKeys() { IObjectState state = new MutableObjectState { ObjectId = "waGiManPutr4Pet1r", ClassName = "Pagi", CreatedAt = new DateTime(), ServerData = new Dictionary <string, object>() { { "username", "kevin" }, { "sessionToken", "se551onT0k3n" } } }; AVObject obj = AVObjectExtensions.FromState <AVObject>(state, "Omitted"); Assert.AreEqual(2, obj.Keys.Count); obj["additional"] = true; Assert.AreEqual(3, obj.Keys.Count); obj.Remove("username"); Assert.AreEqual(2, obj.Keys.Count); }
public void TestGetCurrentInstallation() { var guid = Guid.NewGuid(); IObjectState state = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "installationId", guid.ToString() } } }; ParseInstallation installation = ParseObjectExtensions.FromState <ParseInstallation>(state, "_Installation"); var mockController = new Mock <IParseCurrentInstallationController>(); mockController.Setup(obj => obj.GetAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(installation)); ParsePushPlugins.Instance = new ParsePushPlugins { CurrentInstallationController = mockController.Object }; var currentInstallation = ParseInstallation.CurrentInstallation; Assert.NotNull(currentInstallation); Assert.AreEqual(guid, currentInstallation.InstallationId); }
public void TestCurrentUser() { IObjectState state = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "llaKcolnu" } } }; ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User"); var mockCurrentUserController = new Mock <IParseCurrentUserController>(); mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <CancellationToken>())) .Returns(Task.FromResult(user)); ParseCorePlugins.Instance = new ParseCorePlugins { CurrentUserController = mockCurrentUserController.Object, }; ParseObject.RegisterSubclass <ParseUser>(); ParseObject.RegisterSubclass <ParseSession>(); Assert.AreEqual(user, ParseUser.CurrentUser); }
public void TestProperties() { var now = new DateTime(); IObjectState state = new MutableObjectState { ClassName = "Corgi", UpdatedAt = now, CreatedAt = now, ServerData = new Dictionary <string, object>() { { "1", "Choucho" }, { "2", "Miku" }, { "3", "Halyosy" } } }; Assert.AreEqual("Corgi", state.ClassName); Assert.AreEqual(now, state.UpdatedAt); Assert.AreEqual(now, state.CreatedAt); Assert.AreEqual(3, state.Count()); Assert.AreEqual("Choucho", state["1"]); Assert.AreEqual("Miku", state["2"]); Assert.AreEqual("Halyosy", state["3"]); }
public void TestPropertiesGetterSetter() { var now = new DateTime(); IObjectState state = new MutableObjectState { ObjectId = "waGiManPutr4Pet1r", ClassName = "Pagi", CreatedAt = now, ServerData = new Dictionary <string, object>() { { "username", "kevin" }, { "sessionToken", "se551onT0k3n" } } }; ParseObject obj = ParseObjectExtensions.FromState <ParseObject>(state, "Omitted"); Assert.AreEqual("Pagi", obj.ClassName); Assert.AreEqual(now, obj.CreatedAt); Assert.Null(obj.UpdatedAt); Assert.AreEqual("waGiManPutr4Pet1r", obj.ObjectId); Assert.AreEqual(2, obj.Keys.Count()); Assert.False(obj.IsNew); Assert.Null(obj.ACL); }
public void TestApplyState() { DateTime now = new DateTime(); IObjectState state = new MutableObjectState { ClassName = "Corgi", ObjectId = "abcd", ServerData = new Dictionary <string, object>() { { "exist", 2 }, { "change", "teletubies" } } }; IObjectState appliedState = new MutableObjectState { ClassName = "AnotherCorgi", ObjectId = "1234", CreatedAt = now, ServerData = new Dictionary <string, object>() { { "exist", 9 }, { "missing", "marasy" } } }; state = state.MutatedClone(mutableClone => mutableClone.Apply(appliedState)); Assert.AreEqual("Corgi", state.ClassName); Assert.AreEqual("1234", state.ObjectId); Assert.IsNotNull(state.CreatedAt); Assert.IsNull(state.UpdatedAt); Assert.AreEqual(3, state.Count()); Assert.AreEqual(9, state["exist"]); Assert.AreEqual("teletubies", state["change"]); Assert.AreEqual("marasy", state["missing"]); }
public Task TestRevocableSession() { IObjectState state = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "llaKcolnu" } } }; IObjectState newState = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "r:llaKcolnu" } } }; AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User"); var mockSessionController = new Mock <IAVSessionController>(); mockSessionController.Setup(obj => obj.UpgradeToRevocableSessionAsync("llaKcolnu", It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState)); AVPlugins.Instance = new AVPlugins { SessionController = mockSessionController.Object }; AVObject.RegisterSubclass <AVUser>(); AVObject.RegisterSubclass <AVSession>(); return(user.UpgradeToRevocableSessionAsync(CancellationToken.None).ContinueWith(t => { Assert.False(t.IsFaulted); Assert.False(t.IsCanceled); mockSessionController.Verify(obj => obj.UpgradeToRevocableSessionAsync("llaKcolnu", It.IsAny <CancellationToken>()), Times.Exactly(1)); Assert.AreEqual("r:llaKcolnu", user.SessionToken); })); }
public Task TestLogIn() { IObjectState state = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "llaKcolnu" }, { "username", "ihave" }, { "password", "adream" } } }; IObjectState newState = new MutableObjectState { ObjectId = "some0neTol4v4" }; var mockController = new Mock <IParseUserController>(); mockController.Setup(obj => obj.LogInAsync("ihave", "adream", It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState)); ParseCorePlugins.Instance = new ParseCorePlugins { UserController = mockController.Object }; ParseObject.RegisterSubclass <ParseUser>(); ParseObject.RegisterSubclass <ParseSession>(); return(ParseUser.LogInAsync("ihave", "adream").ContinueWith(t => { Assert.False(t.IsFaulted); Assert.False(t.IsCanceled); mockController.Verify(obj => obj.LogInAsync("ihave", "adream", It.IsAny <CancellationToken>()), Times.Exactly(1)); var user = t.Result; Assert.False(user.IsDirty); Assert.Null(user.Username); Assert.AreEqual("some0neTol4v4", user.ObjectId); })); }
public Task TestUpgradeToRevocableSession() { IObjectState state = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "llaKcolnu" } } }; var mockController = new Mock <IParseSessionController>(); mockController.Setup(obj => obj.UpgradeToRevocableSessionAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(state)); var mockCurrentUserController = new Mock <IParseCurrentUserController>(); ParseCorePlugins.Instance = new ParseCorePlugins { SessionController = mockController.Object, CurrentUserController = mockCurrentUserController.Object, }; ParseObject.RegisterSubclass <ParseUser>(); ParseObject.RegisterSubclass <ParseSession>(); CancellationTokenSource source = new CancellationTokenSource(); return(ParseSessionExtensions.UpgradeToRevocableSessionAsync("someSession", source.Token).ContinueWith(t => { Assert.False(t.IsFaulted); Assert.False(t.IsCanceled); mockController.Verify(obj => obj.UpgradeToRevocableSessionAsync( It.Is <string>(sessionToken => sessionToken == "someSession"), source.Token), Times.Exactly(1)); Assert.AreEqual("llaKcolnu", t.Result); })); }
public Task TestLogInWith() { IObjectState state = new MutableObjectState { ObjectId = "some0neTol4v4", ServerData = new Dictionary <string, object>() { { "sessionToken", "llaKcolnu" } } }; var mockController = new Mock <IAVUserController>(); mockController.Setup(obj => obj.LogInAsync("parse", It.IsAny <IDictionary <string, object> >(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(state)); AVPlugins.Instance = new AVPlugins { UserController = mockController.Object }; AVObject.RegisterSubclass <AVUser>(); AVObject.RegisterSubclass <AVSession>(); return(AVUserExtensions.LogInWithAsync("parse", new Dictionary <string, object>(), CancellationToken.None).ContinueWith(t => { Assert.False(t.IsFaulted); Assert.False(t.IsCanceled); mockController.Verify(obj => obj.LogInAsync("parse", It.IsAny <IDictionary <string, object> >(), It.IsAny <CancellationToken>()), Times.Exactly(1)); var user = t.Result; Assert.NotNull(user.GetAuthData()); Assert.NotNull(user.GetAuthData()["parse"]); Assert.AreEqual("some0neTol4v4", user.ObjectId); })); }
public Task TestSignUp() { IObjectState state = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "llaKcolnu" }, { "username", "ihave" }, { "password", "adream" } } }; IObjectState newState = new MutableObjectState { ObjectId = "some0neTol4v4" }; ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User"); var mockController = new Mock <IParseUserController>(); mockController.Setup(obj => obj.SignUpAsync(It.IsAny <IObjectState>(), It.IsAny <IDictionary <string, IParseFieldOperation> >(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState)); ParseCorePlugins.Instance = new ParseCorePlugins { UserController = mockController.Object }; ParseObject.RegisterSubclass <ParseUser>(); ParseObject.RegisterSubclass <ParseSession>(); return(user.SignUpAsync().ContinueWith(t => { Assert.False(t.IsFaulted); Assert.False(t.IsCanceled); mockController.Verify(obj => obj.SignUpAsync(It.IsAny <IObjectState>(), It.IsAny <IDictionary <string, IParseFieldOperation> >(), It.IsAny <CancellationToken>()), Times.Exactly(1)); Assert.False(user.IsDirty); Assert.AreEqual("ihave", user.Username); Assert.False(user.GetState().ContainsKey("password")); Assert.AreEqual("some0neTol4v4", user.ObjectId); })); }
public void TestFromState() { IObjectState state = new MutableObjectState { ObjectId = "waGiManPutr4Pet1r", ClassName = "Pagi", CreatedAt = new DateTime { }, ServerData = new Dictionary <string, object> { ["username"] = "******", ["sessionToken"] = "se551onT0k3n" } }; ParseObject obj = Client.GenerateObjectFromState <ParseObject>(state, "Omitted"); Assert.AreEqual("waGiManPutr4Pet1r", obj.ObjectId); Assert.AreEqual("Pagi", obj.ClassName); Assert.IsNotNull(obj.CreatedAt); Assert.IsNull(obj.UpdatedAt); Assert.AreEqual("kevin", obj["username"]); Assert.AreEqual("se551onT0k3n", obj["sessionToken"]); }
public Task TestCurrentSessionToken() { var controller = new ParseCurrentUserController(); return(controller.GetCurrentSessionTokenAsync(CancellationToken.None).OnSuccess(t => { Assert.IsNull(t.Result); // We should probably mock this. var userState = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "randomString" } } }; var user = ParseObject.CreateWithoutData <ParseUser>(null); user.HandleFetchResult(userState); return controller.SetAsync(user, CancellationToken.None); }).Unwrap() .OnSuccess(_ => controller.GetCurrentSessionTokenAsync(CancellationToken.None)).Unwrap() .OnSuccess(t => { Assert.AreEqual("randomString", t.Result); })); }
public void TestTryGetValue() { IObjectState state = new MutableObjectState { ObjectId = "waGiManPutr4Pet1r", ClassName = "Pagi", CreatedAt = new DateTime(), ServerData = new Dictionary <string, object>() { { "username", "kevin" }, { "sessionToken", "se551onT0k3n" } } }; ParseObject obj = ParseObjectExtensions.FromState <ParseObject>(state, "Omitted"); obj.TryGetValue("username", out string res); Assert.AreEqual("kevin", res); obj.TryGetValue("username", out ParseObject resObj); Assert.IsNull(resObj); obj.TryGetValue("missingItem", out res); Assert.IsNull(res); }
public void TestIsAuthenticated() { IObjectState state = new MutableObjectState { ObjectId = "wagimanPutraPetir", ServerData = new Dictionary <string, object>() { { "sessionToken", "llaKcolnu" } } }; AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User"); var mockCurrentUserController = new Mock <IAVCurrentUserController>(); mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <CancellationToken>())) .Returns(Task.FromResult(user)); AVPlugins.Instance = new AVPlugins { CurrentUserController = mockCurrentUserController.Object }; AVObject.RegisterSubclass <AVUser>(); AVObject.RegisterSubclass <AVSession>(); Assert.True(user.IsAuthenticated); }
public void TestKeys() { IObjectState state = new MutableObjectState { ObjectId = "waGiManPutr4Pet1r", ClassName = "Pagi", CreatedAt = new DateTime { }, ServerData = new Dictionary <string, object>() { ["username"] = "******", ["sessionToken"] = "se551onT0k3n" } }; ParseObject obj = Client.GenerateObjectFromState <ParseObject>(state, "Omitted"); Assert.AreEqual(2, obj.Keys.Count); obj["additional"] = true; Assert.AreEqual(3, obj.Keys.Count); obj.Remove("username"); Assert.AreEqual(2, obj.Keys.Count); }
public Task TestLogOut() { IObjectState state = new MutableObjectState { ServerData = new Dictionary <string, object>() { { "sessionToken", "r:llaKcolnu" } } }; var user = ParseObjectExtensions.FromState <ParseUser>(state, "_User"); var mockCurrentUserController = new Mock <IParseCurrentUserController>(); mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <CancellationToken>())) .Returns(Task.FromResult(user)); var mockSessionController = new Mock <IParseSessionController>(); mockSessionController.Setup(c => c.IsRevocableSessionToken(It.IsAny <string>())).Returns(true); ParseCorePlugins.Instance = new ParseCorePlugins { CurrentUserController = mockCurrentUserController.Object, SessionController = mockSessionController.Object }; ParseObject.RegisterSubclass <ParseUser>(); ParseObject.RegisterSubclass <ParseSession>(); return(ParseUser.LogOutAsync().ContinueWith(t => { False(t.IsFaulted); False(t.IsCanceled); mockCurrentUserController.Verify(obj => obj.LogOutAsync(It.IsAny <CancellationToken>()), Times.Exactly(1)); mockSessionController.Verify(obj => obj.RevokeAsync("r:llaKcolnu", It.IsAny <CancellationToken>()), Times.Exactly(1)); })); }
public Task TestDelete() { var state = new MutableObjectState { ClassName = "Corgi", ObjectId = "st4nl3yW", ServerData = new Dictionary<string, object>() { { "corgi", "isNotDoge" }, } }; var response = new Tuple<HttpStatusCode, IDictionary<string, object>>(HttpStatusCode.OK, new Dictionary<string, object>()); var mockRunner = CreateMockRunner(response); var controller = new AVObjectController(mockRunner.Object); return controller.DeleteAsync(state, null, CancellationToken.None).ContinueWith(t => { Assert.IsFalse(t.IsFaulted); Assert.IsFalse(t.IsCanceled); mockRunner.Verify(obj => obj.RunCommandAsync(It.Is<AVCommand>(command => command.Uri.AbsolutePath == "/1/classes/Corgi/st4nl3yW"), It.IsAny<IProgress<AVUploadProgressEventArgs>>(), It.IsAny<IProgress<AVDownloadProgressEventArgs>>(), It.IsAny<CancellationToken>()), Times.Exactly(1)); }); }
public void TestGetCurrentInstallation() { var guid = Guid.NewGuid(); IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "installationId", guid.ToString() } } }; ParseInstallation installation = ParseObject.FromState<ParseInstallation>(state, "_Installation"); var mockController = new Mock<IParseCurrentInstallationController>(); mockController.Setup(obj => obj.GetAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(installation)); ParseCorePlugins.Instance.CurrentInstallationController = mockController.Object; var currentInstallation = ParseInstallation.CurrentInstallation; Assert.NotNull(currentInstallation); Assert.AreEqual(guid, currentInstallation.InstallationId); }
public void TestChannelGetterSetter() { var channels = new List<string>() { "the", "richard" }; IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "channels", channels } } }; ParseInstallation installation = ParseObject.FromState<ParseInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual("the", installation.Channels[0]); Assert.AreEqual("richard", installation.Channels[1]); installation.Channels = new List<string>() { "mr", "kevin" }; Assert.AreEqual("mr", installation.Channels[0]); Assert.AreEqual("kevin", installation.Channels[1]); }
public void TestLocaleIdentifierGetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "localeIdentifier", "en-US" } } }; ParseInstallation installation = ParseObject.FromState<ParseInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual("en-US", installation.LocaleIdentifier); }
public void TestTimeZoneGetter() { IObjectState state = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "timeZone", "America/Los_Angeles" } } }; ParseInstallation installation = ParseObject.FromState<ParseInstallation>(state, "_Installation"); Assert.NotNull(installation); Assert.AreEqual("America/Los_Angeles", installation.TimeZone); }
public Task TestCurrentSessionToken() { var controller = new ParseCurrentUserController(); return controller.GetCurrentSessionTokenAsync(CancellationToken.None).OnSuccess(t => { Assert.IsNull(t.Result); // We should probably mock this. var userState = new MutableObjectState { ServerData = new Dictionary<string, object>() { { "sessionToken", "randomString" } } }; var user = ParseObject.CreateWithoutData<ParseUser>(null); user.HandleFetchResult(userState); return controller.SetAsync(user, CancellationToken.None); }).Unwrap() .OnSuccess(_ => controller.GetCurrentSessionTokenAsync(CancellationToken.None)).Unwrap() .OnSuccess(t => { Assert.AreEqual("randomString", t.Result); }); }