public void TestDeepTraversal()
{
AVObject obj = AVObject.Create("Corgi");
IDictionary <string, object> someDict = new Dictionary <string, object>()
{
{ "someList", new List <object>() }
};
obj["obj"] = AVObject.Create("Pug");
obj["obj2"] = AVObject.Create("Pug");
obj["list"] = new List <object>();
obj["dict"] = someDict;
obj["someBool"] = true;
obj["someInt"] = 23;
IEnumerable <object> traverseResult = AVObjectExtensions.DeepTraversal(obj, true, true);
Assert.AreEqual(8, traverseResult.Count());
// Don't traverse beyond the root (since root is AVObject)
traverseResult = AVObjectExtensions.DeepTraversal(obj, false, true);
Assert.AreEqual(1, traverseResult.Count());
traverseResult = AVObjectExtensions.DeepTraversal(someDict, false, true);
Assert.AreEqual(2, traverseResult.Count());
// Should ignore root
traverseResult = AVObjectExtensions.DeepTraversal(obj, true, false);
Assert.AreEqual(7, traverseResult.Count());
}
public void TestEnumerator()
{
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");
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 TestChannelGetterSetter()
{
var channels = new List <string>()
{
"the", "richard"
};
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "channels", channels }
}
};
AVInstallation installation = AVObjectExtensions.FromState <AVInstallation>(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 TestTryGetValue()
{
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");
string res = null;
obj.TryGetValue <string>("username", out res);
Assert.AreEqual("kevin", res);
AVObject resObj = null;
obj.TryGetValue <AVObject>("username", out resObj);
Assert.Null(resObj);
obj.TryGetValue <string>("missingItem", out res);
Assert.Null(res);
}
public void TestRemove()
{
AVObject obj = AVObject.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 = AVObjectExtensions.FromState <AVObject>(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 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" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
AVUser user2 = AVObjectExtensions.FromState <AVUser>(state2, "_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.False(user2.IsAuthenticated);
}
public Task TestLogOut()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "r: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));
var mockSessionController = new Mock <IAVSessionController>();
mockSessionController.Setup(c => c.IsRevocableSessionToken(It.IsAny <string>())).Returns(true);
AVPlugins.Instance = new AVPlugins
{
CurrentUserController = mockCurrentUserController.Object,
SessionController = mockSessionController.Object
};
AVObject.RegisterSubclass <AVUser>();
AVObject.RegisterSubclass <AVSession>();
return(AVUser.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 TestUnlink()
{
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" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
var mockObjectController = new Mock <IAVObjectController>();
mockObjectController.Setup(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IAVFieldOperation> >(),
It.IsAny <string>(),
It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
var mockCurrentUserController = new Mock <IAVCurrentUserController>();
mockCurrentUserController.Setup(obj => obj.IsCurrent(user)).Returns(true);
AVPlugins.Instance = new AVPlugins
{
ObjectController = mockObjectController.Object,
CurrentUserController = mockCurrentUserController.Object,
};
AVObject.RegisterSubclass <AVUser>();
AVObject.RegisterSubclass <AVSession>();
return(user.UnlinkFromAsync("parse", CancellationToken.None).ContinueWith(t =>
{
Assert.False(t.IsFaulted);
Assert.False(t.IsCanceled);
mockObjectController.Verify(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IAVFieldOperation> >(),
It.IsAny <string>(),
It.IsAny <CancellationToken>()), Times.Exactly(1));
Assert.False(user.IsDirty);
Assert.NotNull(user.GetAuthData());
Assert.False(user.GetAuthData().ContainsKey("parse"));
Assert.AreEqual("some0neTol4v4", user.ObjectId);
Assert.AreEqual("ofWords", user["garden"]);
}));
}
public void TestGetSessionToken()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "llaKcolnu" }
}
};
AVSession session = AVObjectExtensions.FromState <AVSession>(state, "_Session");
Assert.NotNull(session);
Assert.AreEqual("llaKcolnu", session.SessionToken);
}
public void TestTimeZoneGetter()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "timeZone", "America/Los_Angeles" }
}
};
AVInstallation installation = AVObjectExtensions.FromState <AVInstallation>(state, "_Installation");
Assert.NotNull(installation);
Assert.AreEqual("America/Los_Angeles", installation.TimeZone);
}
public void TestLocaleIdentifierGetter()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "localeIdentifier", "en-US" }
}
};
AVInstallation installation = AVObjectExtensions.FromState <AVInstallation>(state, "_Installation");
Assert.NotNull(installation);
Assert.AreEqual("en-US", installation.LocaleIdentifier);
}
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" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
var mockObjectController = new Mock <IAVObjectController>();
mockObjectController.Setup(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IAVFieldOperation> >(),
It.IsAny <string>(),
It.IsAny <CancellationToken>())).Returns(Task.FromResult(newState));
AVPlugins.Instance = new AVPlugins
{
ObjectController = mockObjectController.Object,
CurrentUserController = new Mock <IAVCurrentUserController>().Object
};
AVObject.RegisterSubclass <AVUser>();
AVObject.RegisterSubclass <AVSession>();
user["Alliance"] = "rekt";
return(user.SaveAsync().ContinueWith(t =>
{
Assert.False(t.IsFaulted);
Assert.False(t.IsCanceled);
mockObjectController.Verify(obj => obj.SaveAsync(It.IsAny <IObjectState>(),
It.IsAny <IDictionary <string, IAVFieldOperation> >(),
It.IsAny <string>(),
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);
Assert.AreEqual("rekt", user["Alliance"]);
}));
}
public void TestSessionTokenGetter()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
{ "sessionToken", "se551onT0k3n" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
Assert.AreEqual("se551onT0k3n", user.SessionToken);
}
public void TestUsernameGetterSetter()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
Assert.AreEqual("kevin", user.Username);
user.Username = "******";
Assert.AreEqual("ilya", user.Username);
}
public void TestPasswordGetterSetter()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
{ "password", "hurrah" },
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
Assert.AreEqual("hurrah", user.GetState()["password"]);
user.Password = "******";
Assert.NotNull(user.GetCurrentOperations()["password"]);
}
public void TestRemoveFields()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "username", "kevin" },
{ "name", "andrew" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
Assert.Throws <ArgumentException>(() => user.Remove("username"));
Assert.DoesNotThrow(() => user.Remove("name"));
Assert.False(user.ContainsKey("name"));
}
public void TestEmailGetterSetter()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "email", "*****@*****.**" },
{ "name", "andrew" },
{ "sessionToken", "se551onT0k3n" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
Assert.AreEqual("*****@*****.**", user.Email);
user.Email = "*****@*****.**";
Assert.AreEqual("*****@*****.**", user.Email);
}
public Task TestSignUpWithInvalidServerData()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "llaKcolnu" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
return(user.SignUpAsync().ContinueWith(t =>
{
Assert.True(t.IsFaulted);
Assert.IsInstanceOf <InvalidOperationException>(t.Exception.InnerException);
}));
}
public void TestAppVersionGetterSetter()
{
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "appVersion", "1.2.3" }
}
};
AVInstallation installation = AVObjectExtensions.FromState <AVInstallation>(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" }
}
};
AVInstallation installation = AVObjectExtensions.FromState <AVInstallation>(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 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 TestGet()
{
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("kevin", obj.Get <string>("username"));
Assert.Throws <InvalidCastException>(() => obj.Get <AVObject>("username"));
Assert.Throws <KeyNotFoundException>(() => obj.Get <string>("missingItem"));
}
public void TestInstallationIdGetterSetter()
{
var guid = Guid.NewGuid();
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "installationId", guid.ToString() }
}
};
AVInstallation installation = AVObjectExtensions.FromState <AVInstallation>(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 TestAuthDataGetter()
{
IObjectState state = new MutableObjectState
{
ServerData = new Dictionary <string, object>()
{
{ "email", "*****@*****.**" },
{ "authData", new Dictionary <string, object>()
{
{ "facebook", new Dictionary <string, object>()
{
{ "sessionToken", "none" }
} }
} }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(state, "_User");
Assert.AreEqual(1, user.GetAuthData().Count);
Assert.IsInstanceOf <IDictionary <string, object> >(user.GetAuthData()["facebook"]);
}
public Task TestGetCurrentSession()
{
IObjectState sessionState = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "sessionToken", "newllaKcolnu" }
}
};
var mockController = new Mock <IAVSessionController>();
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" }
}
};
AVUser user = AVObjectExtensions.FromState <AVUser>(userState, "_User");
var mockCurrentUserController = new Mock <IAVCurrentUserController>();
mockCurrentUserController.Setup(obj => obj.GetAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(user));
AVPlugins.Instance = new AVPlugins {
SessionController = mockController.Object,
CurrentUserController = mockCurrentUserController.Object,
};
AVObject.RegisterSubclass <AVSession>();
return(AVSession.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 TestFromState()
{
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("waGiManPutr4Pet1r", obj.ObjectId);
Assert.AreEqual("Pagi", obj.ClassName);
Assert.NotNull(obj.CreatedAt);
Assert.Null(obj.UpdatedAt);
Assert.AreEqual("kevin", obj["username"]);
Assert.AreEqual("se551onT0k3n", obj["sessionToken"]);
}
public void TestGetCurrentInstallation()
{
var guid = Guid.NewGuid();
IObjectState state = new MutableObjectState {
ServerData = new Dictionary <string, object>()
{
{ "installationId", guid.ToString() }
}
};
AVInstallation installation = AVObjectExtensions.FromState <AVInstallation>(state, "_Installation");
var mockController = new Mock <IAVCurrentInstallationController>();
mockController.Setup(obj => obj.GetAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(installation));
AVPushPlugins.Instance = new AVPushPlugins {
CurrentInstallationController = mockController.Object
};
var currentInstallation = AVInstallation.CurrentInstallation;
Assert.NotNull(currentInstallation);
Assert.AreEqual(guid, currentInstallation.InstallationId);
}
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 TestCurrentUser()
{
IObjectState state = new MutableObjectState
{
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.AreEqual(user, AVUser.CurrentUser);
}
