public void TestCurrentUser()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu"
}
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
ParseUser user = client.GenerateObjectFromState <ParseUser>(state, "_User");
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController> {
};
mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(user));
hub.CurrentUserController = mockCurrentUserController.Object;
Assert.AreEqual(user, client.GetCurrentUser());
}
public Task TestTrackEventWithDimension()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Mock <IParseAnalyticsController> mockController = new Mock <IParseAnalyticsController> {
};
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController> {
};
mockCurrentUserController.Setup(controller => controller.GetCurrentSessionTokenAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult("sessionToken"));
hub.AnalyticsController = mockController.Object;
hub.CurrentUserController = mockCurrentUserController.Object;
return(client.TrackAnalyticsEventAsync("SomeEvent", new Dictionary <string, string> {
["facebook"] = "hq"
}).ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.TrackEventAsync(It.Is <string>(eventName => eventName == "SomeEvent"), It.Is <IDictionary <string, string> >(dict => dict != null && dict.Count == 1), It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
}));
}
public Task TestBecome()
{
IObjectState state = new MutableObjectState
{
ObjectId = "some0neTol4v4",
ServerData = new Dictionary <string, object> {
["sessionToken"] = "llaKcolnu"
}
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Mock <IParseUserController> mockController = new Mock <IParseUserController> {
};
mockController.Setup(obj => obj.GetUserAsync("llaKcolnu", It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(state));
hub.UserController = mockController.Object;
return(client.BecomeAsync("llaKcolnu").ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.GetUserAsync("llaKcolnu", It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
ParseUser user = task.Result;
Assert.AreEqual("some0neTol4v4", user.ObjectId);
Assert.AreEqual("llaKcolnu", user.SessionToken);
}));
}
public Task TestTrackAppOpened()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Mock <IParseAnalyticsController> mockController = new Mock <IParseAnalyticsController> {
};
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController> {
};
mockCurrentUserController.Setup(controller => controller.GetCurrentSessionTokenAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult("sessionToken"));
hub.AnalyticsController = mockController.Object;
hub.CurrentUserController = mockCurrentUserController.Object;
return(client.TrackLaunchAsync().ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.TrackAppOpenedAsync(It.Is <string>(pushHash => pushHash == null), It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
}));
}
public Task TestRevoke()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Mock <IParseSessionController> mockController = new Mock <IParseSessionController>();
mockController.Setup(sessionController => sessionController.IsRevocableSessionToken(It.IsAny <string>())).Returns(true);
hub.SessionController = mockController.Object;
CancellationTokenSource source = new CancellationTokenSource {
};
return(client.RevokeSessionAsync("r:someSession", source.Token).ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.RevokeAsync(It.Is <string>(sessionToken => sessionToken == "r:someSession"), source.Token), Times.Exactly(1));
}));
}
public void TestGetCurrentInstallation()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Guid guid = Guid.NewGuid();
ParseInstallation installation = client.GenerateObjectFromState <ParseInstallation>(new MutableObjectState {
ServerData = new Dictionary <string, object> {
["installationId"] = guid.ToString()
}
}, "_Installation");
Mock <IParseCurrentInstallationController> mockController = new Mock <IParseCurrentInstallationController>();
mockController.Setup(obj => obj.GetAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(installation));
hub.CurrentInstallationController = mockController.Object;
ParseInstallation currentInstallation = client.GetCurrentInstallation();
Assert.IsNotNull(currentInstallation);
Assert.AreEqual(guid, currentInstallation.InstallationId);
}
public Task TestUnlinkNonCurrentUser()
{
IObjectState state = new MutableObjectState
{
ObjectId = "some0neTol4v4",
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu",
["authData"] = new Dictionary <string, object>
{
["parse"] = new Dictionary <string, object> {
}
}
}
};
IObjectState newState = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["garden"] = "ofWords"
}
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
ParseUser user = client.GenerateObjectFromState <ParseUser>(state, "_User");
Mock <IParseObjectController> mockObjectController = new Mock <IParseObjectController>();
mockObjectController.Setup(obj => obj.SaveAsync(It.IsAny <IObjectState>(), It.IsAny <IDictionary <string, IParseFieldOperation> >(), It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController> {
};
mockCurrentUserController.Setup(obj => obj.IsCurrent(user)).Returns(false);
hub.ObjectController = mockObjectController.Object;
hub.CurrentUserController = mockCurrentUserController.Object;
return(user.UnlinkFromAsync("parse", CancellationToken.None).ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockObjectController.Verify(obj => obj.SaveAsync(It.IsAny <IObjectState>(), It.IsAny <IDictionary <string, IParseFieldOperation> >(), It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
Assert.IsFalse(user.IsDirty);
Assert.IsNotNull(user.AuthData);
Assert.IsTrue(user.AuthData.ContainsKey("parse"));
Assert.IsNull(user.AuthData["parse"]);
Assert.AreEqual("some0neTol4v4", user.ObjectId);
Assert.AreEqual("ofWords", user["garden"]);
}));
}
public Task TestUserFetch()
{
IObjectState state = new MutableObjectState
{
ObjectId = "some0neTol4v4",
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu",
["username"] = "******",
["password"] = "******"
}
};
IObjectState newState = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["Alliance"] = "rekt"
}
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
ParseUser user = client.GenerateObjectFromState <ParseUser>(state, "_User");
Mock <IParseObjectController> mockObjectController = new Mock <IParseObjectController>();
mockObjectController.Setup(obj => obj.FetchAsync(It.IsAny <IObjectState>(), It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
hub.ObjectController = mockObjectController.Object;
hub.CurrentUserController = new Mock <IParseCurrentUserController> {
}.Object;
user["Alliance"] = "rekt";
return(user.FetchAsync().ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockObjectController.Verify(obj => obj.FetchAsync(It.IsAny <IObjectState>(), It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
Assert.IsTrue(user.IsDirty);
Assert.AreEqual("ihave", user.Username);
Assert.IsTrue(user.State.ContainsKey("password"));
Assert.AreEqual("some0neTol4v4", user.ObjectId);
Assert.AreEqual("rekt", user["Alliance"]);
}));
}
public Task TestSendPush()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
MutablePushState state = new MutablePushState
{
Query = Client.GetInstallationQuery()
};
ParsePush thePush = new ParsePush(client);
hub.PushController = GetMockedPushController(state);
thePush.Alert = "Alert";
state.Alert = "Alert";
return(thePush.SendAsync().ContinueWith(task =>
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
thePush.Channels = new List <string> {
{ "channel" }
};
state.Channels = new List <string> {
{ "channel" }
};
return thePush.SendAsync();
}).Unwrap().ContinueWith(task =>
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
ParseQuery <ParseInstallation> query = new ParseQuery <ParseInstallation>(client, "aClass");
thePush.Query = query;
state.Query = query;
return thePush.SendAsync();
}).Unwrap().ContinueWith(task =>
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
}));
}
public Task TestGetCurrentSession()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
IObjectState sessionState = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "newllaKcolnu"
}
};
Mock <IParseSessionController> mockController = new Mock <IParseSessionController>();
mockController.Setup(obj => obj.GetSessionAsync(It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(sessionState));
IObjectState userState = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu"
}
};
ParseUser user = client.GenerateObjectFromState <ParseUser>(userState, "_User");
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController>();
mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(user));
hub.SessionController = mockController.Object;
hub.CurrentUserController = mockCurrentUserController.Object;
return(client.GetCurrentSessionAsync().ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.GetSessionAsync(It.Is <string>(sessionToken => sessionToken == "llaKcolnu"), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
ParseSession session = task.Result;
Assert.AreEqual("newllaKcolnu", session.SessionToken);
}));
}
public Task TestLogIn()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu",
["username"] = "******",
["password"] = "******"
}
};
IObjectState newState = new MutableObjectState
{
ObjectId = "some0neTol4v4"
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Mock <IParseUserController> mockController = new Mock <IParseUserController> {
};
mockController.Setup(obj => obj.LogInAsync("ihave", "adream", It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
hub.UserController = mockController.Object;
return(client.LogInAsync("ihave", "adream").ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.LogInAsync("ihave", "adream", It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
ParseUser user = task.Result;
Assert.IsFalse(user.IsDirty);
Assert.IsNull(user.Username);
Assert.AreEqual("some0neTol4v4", user.ObjectId);
}));
}
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"
}
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
ParseUser user = client.GenerateObjectFromState <ParseUser>(state, "_User");
Mock <IParseSessionController> mockSessionController = new Mock <IParseSessionController>();
mockSessionController.Setup(obj => obj.UpgradeToRevocableSessionAsync("llaKcolnu", It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
hub.SessionController = mockSessionController.Object;
return(user.UpgradeToRevocableSessionAsync(CancellationToken.None).ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockSessionController.Verify(obj => obj.UpgradeToRevocableSessionAsync("llaKcolnu", It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
Assert.AreEqual("r:llaKcolnu", user.SessionToken);
}));
}
public Task TestCloudFunctions()
{
MutableServiceHub hub = new MutableServiceHub { };
ParseClient client = new ParseClient(new ServerConnectionData { Test = true }, hub);
Mock<IParseCloudCodeController> mockController = new Mock<IParseCloudCodeController>();
mockController.Setup(obj => obj.CallFunctionAsync<IDictionary<string, object>>(It.IsAny<string>(), It.IsAny<IDictionary<string, object>>(), It.IsAny<string>(), It.IsAny<IServiceHub>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult<IDictionary<string, object>>(new Dictionary<string, object> { ["fosco"] = "ben", ["list"] = new List<object> { 1, 2, 3 } }));
hub.CloudCodeController = mockController.Object;
hub.CurrentUserController = new Mock<IParseCurrentUserController> { }.Object;
return client.CallCloudCodeFunctionAsync<IDictionary<string, object>>("someFunction", null, CancellationToken.None).ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
Assert.IsInstanceOfType(task.Result, typeof(IDictionary<string, object>));
Assert.AreEqual("ben", task.Result["fosco"]);
Assert.IsInstanceOfType(task.Result["list"], typeof(IList<object>));
});
}
public Task TestGetCurrentSessionWithNoCurrentUser()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Mock <IParseSessionController> mockController = new Mock <IParseSessionController>();
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController>();
hub.SessionController = mockController.Object;
hub.CurrentUserController = mockCurrentUserController.Object;
return(client.GetCurrentSessionAsync().ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
Assert.IsNull(task.Result);
}));
}
public Task TestRequestPasswordReset()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
Mock <IParseUserController> mockController = new Mock <IParseUserController> {
};
hub.UserController = mockController.Object;
return(client.RequestPasswordResetAsync("*****@*****.**").ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.RequestPasswordResetAsync("*****@*****.**", It.IsAny <CancellationToken>()), Times.Exactly(1));
}));
}
public Task TestUnsubscribe()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
List <string> channels = new List <string> {
};
hub.PushChannelsController = GetMockedPushChannelsController(channels);
channels.Add("test");
return(client.UnsubscribeToPushChannelAsync("test").ContinueWith(task =>
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
return client.UnsubscribeToPushChannelsAsync(new List <string> {
{ "test" }
});
}).ContinueWith(task =>
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource {
};
return client.UnsubscribeToPushChannelsAsync(new List <string> {
{ "test" }
}, cancellationTokenSource.Token);
}).ContinueWith(task =>
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
}));
}
public Task TestLogOut()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "r:llaKcolnu"
}
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
ParseUser user = client.GenerateObjectFromState <ParseUser>(state, "_User");
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController> {
};
mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(user));
Mock <IParseSessionController> mockSessionController = new Mock <IParseSessionController>();
mockSessionController.Setup(c => c.IsRevocableSessionToken(It.IsAny <string>())).Returns(true);
hub.CurrentUserController = mockCurrentUserController.Object;
hub.SessionController = mockSessionController.Object;
return(client.LogOutAsync().ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockCurrentUserController.Verify(obj => obj.LogOutAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>()), Times.Exactly(1));
mockSessionController.Verify(obj => obj.RevokeAsync("r:llaKcolnu", It.IsAny <CancellationToken>()), Times.Exactly(1));
}));
}
public Task TestUpgradeToRevocableSession()
{
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
["sessionToken"] = "llaKcolnu"
}
};
Mock <IParseSessionController> mockController = new Mock <IParseSessionController>();
mockController.Setup(obj => obj.UpgradeToRevocableSessionAsync(It.IsAny <string>(), It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(state));
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController>();
hub.SessionController = mockController.Object;
hub.CurrentUserController = mockCurrentUserController.Object;
CancellationTokenSource source = new CancellationTokenSource {
};
return(client.UpgradeToRevocableSessionAsync("someSession", source.Token).ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted);
Assert.IsFalse(task.IsCanceled);
mockController.Verify(obj => obj.UpgradeToRevocableSessionAsync(It.Is <string>(sessionToken => sessionToken == "someSession"), It.IsAny <IServiceHub>(), source.Token), Times.Exactly(1));
Assert.AreEqual("llaKcolnu", task.Result);
}));
}
public void TestIsAuthenticatedWithOtherParseUser()
{
IObjectState state = new MutableObjectState
{
ObjectId = "wagimanPutraPetir",
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu"
}
};
IObjectState state2 = new MutableObjectState
{
ObjectId = "wagimanPutraPetir2",
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu"
}
};
MutableServiceHub hub = new MutableServiceHub {
};
ParseClient client = new ParseClient(new ServerConnectionData {
Test = true
}, hub);
ParseUser user = client.GenerateObjectFromState <ParseUser>(state, "_User");
ParseUser user2 = client.GenerateObjectFromState <ParseUser>(state2, "_User");
Mock <IParseCurrentUserController> mockCurrentUserController = new Mock <IParseCurrentUserController> {
};
mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <IServiceHub>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(user));
hub.CurrentUserController = mockCurrentUserController.Object;
Assert.IsFalse(user2.IsAuthenticated);
}
