public void TestDeepTraversal()
{
ParseObject obj = ParseObject.Create("Corgi");
IDictionary <string, object> someDict = new Dictionary <string, object>()
{
{ "someList", new List <object>() }
};
obj["obj"] = ParseObject.Create("Pug");
obj["obj2"] = ParseObject.Create("Pug");
obj["list"] = new List <object>();
obj["dict"] = someDict;
obj["someBool"] = true;
obj["someInt"] = 23;
IEnumerable <object> traverseResult = ParseObjectExtensions.DeepTraversal(obj, true, true);
Assert.AreEqual(8, traverseResult.Count());
// Don't traverse beyond the root (since root is ParseObject)
traverseResult = ParseObjectExtensions.DeepTraversal(obj, false, true);
Assert.AreEqual(1, traverseResult.Count());
traverseResult = ParseObjectExtensions.DeepTraversal(someDict, false, true);
Assert.AreEqual(2, traverseResult.Count());
// Should ignore root
traverseResult = ParseObjectExtensions.DeepTraversal(obj, true, false);
Assert.AreEqual(7, traverseResult.Count());
}
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");
string res = null;
obj.TryGetValue <string>("username", out res);
Assert.AreEqual("kevin", res);
ParseObject resObj = null;
obj.TryGetValue <ParseObject>("username", out resObj);
Assert.Null(resObj);
obj.TryGetValue <string>("missingItem", out res);
Assert.Null(res);
}
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" }
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
var mockSessionController = new Mock <IParseSessionController>();
mockSessionController.Setup(obj => obj.UpgradeToRevocableSessionAsync("llaKcolnu",
It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
ParseCorePlugins.Instance = new ParseCorePlugins {
SessionController = mockSessionController.Object
};
ParseObject.RegisterSubclass <ParseUser>();
ParseObject.RegisterSubclass <ParseSession>();
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 void TestRemove()
{
ParseObject obj = ParseObject.Create("Corgi");
obj["gogo"] = true;
Assert.True(obj.ContainsKey("gogo"));
obj.Remove("gogo");
Assert.False(obj.ContainsKey("gogo"));
IObjectState state = new MutableObjectState {
ObjectId = "waGiManPutr4Pet1r",
ClassName = "Pagi",
CreatedAt = new DateTime(),
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
{ "sessionToken", "se551onT0k3n" }
}
};
obj = ParseObjectExtensions.FromState <ParseObject>(state, "Corgi");
Assert.True(obj.ContainsKey("username"));
Assert.True(obj.ContainsKey("sessionToken"));
obj.Remove("username");
Assert.False(obj.ContainsKey("username"));
Assert.True(obj.ContainsKey("sessionToken"));
}
public void TestEnumerator()
{
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");
int count = 0;
foreach (var key in obj)
{
count++;
}
Assert.AreEqual(2, count);
obj["newDirtyItem"] = "newItem";
count = 0;
foreach (var key in obj)
{
count++;
}
Assert.AreEqual(3, count);
}
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" }
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
ParseUser user2 = ParseObjectExtensions.FromState <ParseUser>(state2, "_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.False(user2.IsAuthenticated);
}
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" }
}
}
}
}
}
};
var user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
AreEqual(1, user.GetAuthData().Count);
IsInstanceOf <IDictionary <string, object> >(user.GetAuthData()["facebook"]);
}
public Task TestSignUp()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["sessionToken"] = "llaKcolnu",
["username"] = "******",
["password"] = "******"
}
};
IObjectState newState = new MutableObjectState {
ObjectId = "some0neTol4v4"
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
Mock <IParseUserController> 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.IsFalse(t.IsFaulted);
Assert.IsFalse(t.IsCanceled);
mockController.Verify(obj => obj.SignUpAsync(It.IsAny <IObjectState>(), It.IsAny <IDictionary <string, IParseFieldOperation> >(), It.IsAny <CancellationToken>()), Times.Exactly(1));
Assert.IsFalse(user.IsDirty);
Assert.AreEqual("ihave", user.Username);
Assert.IsFalse(user.GetState().ContainsKey("password"));
Assert.AreEqual("some0neTol4v4", user.ObjectId);
}));
}
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.IsNotNull(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 = ParseObjectExtensions.FromState <ParseInstallation>(state, "_Installation");
Assert.IsNotNull(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 Task TestLogOut()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "r: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));
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 => {
Assert.False(t.IsFaulted);
Assert.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 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" }
}
};
var user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
var mockObjectController = new Mock <IParseObjectController>();
mockObjectController.Setup(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IParseFieldOperation> >(),
It.IsAny <string>(),
It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
var mockCurrentUserController = new Mock <IParseCurrentUserController>();
mockCurrentUserController.Setup(obj => obj.IsCurrent(user)).Returns(false);
ParseCorePlugins.Instance = new ParseCorePlugins
{
ObjectController = mockObjectController.Object,
CurrentUserController = mockCurrentUserController.Object,
};
ParseObject.RegisterSubclass <ParseUser>();
ParseObject.RegisterSubclass <ParseSession>();
return(user.UnlinkFromAsync("parse", CancellationToken.None).ContinueWith(t =>
{
False(t.IsFaulted);
False(t.IsCanceled);
mockObjectController.Verify(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IParseFieldOperation> >(),
It.IsAny <string>(),
It.IsAny <CancellationToken>()), Times.Exactly(1));
False(user.IsDirty);
NotNull(user.GetAuthData());
True(user.GetAuthData().ContainsKey("parse"));
Null(user.GetAuthData()["parse"]);
AreEqual("some0neTol4v4", user.ObjectId);
AreEqual("ofWords", user["garden"]);
}));
}
internal override void DidReceive(object queryObj, Event objEvent, IObjectState objState)
{
ParseQuery <T> query = (ParseQuery <T>)queryObj;
T obj = ParseObjectExtensions.FromState <T>(objState, query.GetClassName());
foreach (EventsCallback <T> eventsCallback in _eventsCallbacks)
{
eventsCallback(query, objEvent, obj);
}
}
public void TestTimeZoneGetter()
{
ParseInstallation installation = ParseObjectExtensions.FromState <ParseInstallation>(new MutableObjectState {
ServerData = new Dictionary <string, object> {
["timeZone"] = "America/Los_Angeles"
}
}, "_Installation");
Assert.IsNotNull(installation);
Assert.AreEqual("America/Los_Angeles", installation.TimeZone);
}
public void TestLocaleIdentifierGetter()
{
ParseInstallation installation = ParseObjectExtensions.FromState <ParseInstallation>(new MutableObjectState {
ServerData = new Dictionary <string, object> {
["localeIdentifier"] = "en-US"
}
}, "_Installation");
Assert.IsNotNull(installation);
Assert.AreEqual("en-US", installation.LocaleIdentifier);
}
public void TestGetSessionToken()
{
ParseSession session = ParseObjectExtensions.FromState <ParseSession>(new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "llaKcolnu" }
}
}, "_Session");
Assert.IsNotNull(session);
Assert.AreEqual("llaKcolnu", session.SessionToken);
}
public void TestSessionTokenGetter()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
{ "sessionToken", "se551onT0k3n" }
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
Assert.AreEqual("se551onT0k3n", user.SessionToken);
}
public Task TestUserSave()
{
IObjectState state = new MutableObjectState
{
ObjectId = "some0neTol4v4",
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "llaKcolnu" },
{ "username", "ihave" },
{ "password", "adream" }
}
};
IObjectState newState = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "Alliance", "rekt" }
}
};
var user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
var mockObjectController = new Mock <IParseObjectController>();
mockObjectController.Setup(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IParseFieldOperation> >(),
It.IsAny <string>(),
It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
ParseCorePlugins.Instance = new ParseCorePlugins
{
ObjectController = mockObjectController.Object,
CurrentUserController = new Mock <IParseCurrentUserController>().Object
};
ParseObject.RegisterSubclass <ParseUser>();
ParseObject.RegisterSubclass <ParseSession>();
user["Alliance"] = "rekt";
return(user.SaveAsync().ContinueWith(t =>
{
False(t.IsFaulted);
False(t.IsCanceled);
mockObjectController.Verify(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IParseFieldOperation> >(),
It.IsAny <string>(),
It.IsAny <CancellationToken>()), Times.Exactly(1));
False(user.IsDirty);
AreEqual("ihave", user.Username);
False(user.GetState().ContainsKey("password"));
AreEqual("some0neTol4v4", user.ObjectId);
AreEqual("rekt", user["Alliance"]);
}));
}
public void TestUsernameGetterSetter()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
Assert.AreEqual("kevin", user.Username);
user.Username = "******";
Assert.AreEqual("ilya", user.Username);
}
public void TestAppIdentifierGetterSetter()
{
ParseInstallation installation = ParseObjectExtensions.FromState <ParseInstallation>(new MutableObjectState {
ServerData = new Dictionary <string, object> {
["appIdentifier"] = "com.parse.app"
}
}, "_Installation");
Assert.IsNotNull(installation);
Assert.AreEqual("com.parse.app", installation.AppIdentifier);
Assert.ThrowsException <InvalidOperationException>(() => installation["appIdentifier"] = "com.parse.newapp");
installation.SetIfDifferent("appIdentifier", "com.parse.newapp");
Assert.AreEqual("com.parse.newapp", installation.AppIdentifier);
}
public void TestRemoveFields()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
{ "name", "andrew" }
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
Assert.Throws <ArgumentException>(() => user.Remove("username"));
Assert.DoesNotThrow(() => user.Remove("name"));
Assert.False(user.ContainsKey("name"));
}
public Task TestSignUpWithInvalidServerData()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "llaKcolnu" }
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
return(user.SignUpAsync().ContinueWith(t => {
Assert.True(t.IsFaulted);
Assert.IsInstanceOf <InvalidOperationException>(t.Exception.InnerException);
}));
}
public void TestPasswordGetterSetter()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
{ "password", "hurrah" },
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
Assert.AreEqual("hurrah", user.GetState()["password"]);
user.Password = "******";
Assert.NotNull(user.GetCurrentOperations()["password"]);
}
public void TestDeviceTypeGetterSetter()
{
ParseInstallation installation = ParseObjectExtensions.FromState <ParseInstallation>(new MutableObjectState {
ServerData = new Dictionary <string, object> {
["deviceType"] = "parseOS"
}
}, "_Installation");
Assert.IsNotNull(installation);
Assert.AreEqual("parseOS", installation.DeviceType);
Assert.ThrowsException <InvalidOperationException>(() => installation["deviceType"] = "gogoOS");
installation.SetIfDifferent("deviceType", "gogoOS");
Assert.AreEqual("gogoOS", installation.DeviceType);
}
public void TestAppVersionGetterSetter()
{
ParseInstallation installation = ParseObjectExtensions.FromState <ParseInstallation>(new MutableObjectState {
ServerData = new Dictionary <string, object> {
["appVersion"] = "1.2.3"
}
}, "_Installation");
Assert.IsNotNull(installation);
Assert.AreEqual("1.2.3", installation.AppVersion);
Assert.ThrowsException <InvalidOperationException>(() => installation["appVersion"] = "1.2.4");
installation.SetIfDifferent("appVersion", "1.2.4");
Assert.AreEqual("1.2.4", installation.AppVersion);
}
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 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" }
}
};
var user = ParseObjectExtensions.FromState <ParseUser>(userState, "_User");
var mockCurrentUserController = new Mock <IParseCurrentUserController>();
mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(user));
ParseCorePlugins.Instance = new ParseCorePlugins
{
SessionController = mockController.Object,
CurrentUserController = mockCurrentUserController.Object,
};
ParseObject.RegisterSubclass <ParseSession>();
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 TestAppNameGetterSetter()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "appName", "parseApp" }
}
};
ParseInstallation installation = ParseObjectExtensions.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 TestRemoveFields()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>
{
["username"] = "******",
["name"] = "andrew"
}
};
ParseUser user = ParseObjectExtensions.FromState <ParseUser>(state, "_User");
Assert.ThrowsException <ArgumentException>(() => user.Remove("username"));
try { user.Remove("name"); }
catch { Assert.Fail(); }
Assert.IsFalse(user.ContainsKey("name"));
}
public void TestGet()
{
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");
Assert.AreEqual("kevin", obj.Get <string>("username"));
Assert.Throws <InvalidCastException>(() => obj.Get <ParseObject>("username"));
Assert.Throws <KeyNotFoundException>(() => obj.Get <string>("missingItem"));
}
