public Task TestIsCurrent()
        {
            var storageController = new Mock <IStorageController>(MockBehavior.Strict);
            var mockedStorage     = new Mock <IStorageDictionary <string, object> >();
            var controller        = new AVCurrentUserController(storageController.Object);
            var user  = new AVUser();
            var user2 = new AVUser();

            storageController.Setup(s => s.LoadAsync()).Returns(Task.FromResult(mockedStorage.Object));

            return(controller.SetAsync(user, CancellationToken.None).OnSuccess(t => {
                Assert.IsTrue(controller.IsCurrent(user));
                Assert.IsFalse(controller.IsCurrent(user2));

                controller.ClearFromMemory();

                Assert.IsFalse(controller.IsCurrent(user));

                return controller.SetAsync(user, CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.IsTrue(controller.IsCurrent(user));
                Assert.IsFalse(controller.IsCurrent(user2));

                controller.ClearFromDisk();

                Assert.IsFalse(controller.IsCurrent(user));

                return controller.SetAsync(user2, CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.IsFalse(controller.IsCurrent(user));
                Assert.IsTrue(controller.IsCurrent(user2));
            }));
        }
        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 Task TestExistsAsync()
        {
            var storageController = new Mock <IStorageController>();
            var mockedStorage     = new Mock <IStorageDictionary <string, object> >();
            var controller        = new AVCurrentUserController(storageController.Object);
            var user = new AVUser();

            storageController.Setup(c => c.LoadAsync()).Returns(Task.FromResult(mockedStorage.Object));

            bool contains = false;

            mockedStorage.Setup(s => s.AddAsync("CurrentUser", It.IsAny <object>())).Callback(() => {
                contains = true;
            }).Returns(Task.FromResult <object>(null)).Verifiable();

            mockedStorage.Setup(s => s.RemoveAsync("CurrentUser")).Callback(() => {
                contains = false;
            }).Returns(Task.FromResult <object>(null)).Verifiable();

            mockedStorage.Setup(s => s.ContainsKey("CurrentUser")).Returns(() => contains);

            return(controller.SetAsync(user, CancellationToken.None).OnSuccess(_ => {
                Assert.AreEqual(user, controller.CurrentUser);

                return controller.ExistsAsync(CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.IsTrue(t.Result);

                controller.ClearFromMemory();
                return controller.ExistsAsync(CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.IsTrue(t.Result);

                controller.ClearFromDisk();
                return controller.ExistsAsync(CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.IsFalse(t.Result);
                mockedStorage.Verify();
            }));
        }
        public Task TestGetSetAsync()
        {
            var storageController = new Mock <IStorageController>(MockBehavior.Strict);
            var mockedStorage     = new Mock <IStorageDictionary <string, object> >();
            var controller        = new AVCurrentUserController(storageController.Object);
            var user = new AVUser();

            storageController.Setup(s => s.LoadAsync()).Returns(Task.FromResult(mockedStorage.Object));

            return(controller.SetAsync(user, CancellationToken.None).OnSuccess(_ => {
                Assert.AreEqual(user, controller.CurrentUser);

                object jsonObject = null;
                Predicate <object> predicate = o => {
                    jsonObject = o;
                    return true;
                };

                mockedStorage.Verify(s => s.AddAsync("CurrentUser", Match.Create <object>(predicate)));
                mockedStorage.Setup(s => s.TryGetValue("CurrentUser", out jsonObject)).Returns(true);

                return controller.GetAsync(CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.AreEqual(user, controller.CurrentUser);

                controller.ClearFromMemory();
                Assert.AreNotEqual(user, controller.CurrentUser);

                return controller.GetAsync(CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.AreNotSame(user, controller.CurrentUser);
                Assert.IsNotNull(controller.CurrentUser);
            }));
        }
        public Task TestLogOut()
        {
            var storageController = new Mock <IStorageController>(MockBehavior.Strict);
            var controller        = new AVCurrentUserController(storageController.Object);
            var user = new AVUser();

            return(controller.SetAsync(user, CancellationToken.None).OnSuccess(_ => {
                Assert.AreEqual(user, controller.CurrentUser);
                return controller.ExistsAsync(CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.IsTrue(t.Result);

                return controller.LogOutAsync(CancellationToken.None);
            }).Unwrap().OnSuccess(_ => controller.GetAsync(CancellationToken.None)).Unwrap()
                   .OnSuccess(t => {
                Assert.IsNull(t.Result);

                return controller.ExistsAsync(CancellationToken.None);
            }).Unwrap()
                   .OnSuccess(t => {
                Assert.IsFalse(t.Result);
            }));
        }