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);
});
}
