public void GetRegisteredUserEventDefinitions_GetResults_Test()
        {
            int  expectedId = 10;
            bool called     = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetEventDefinitionsInt32 = registeredUserId =>
                {
                    Assert.AreEqual(expectedId, registeredUserId);
                    called = true;
                    return(new List <EventDefinition>()
                    {
                        new EventDefinition(), new EventDefinition()
                    });
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            IEnumerable <EventDefinition> result = target.GetRegisteredUserEventDefinitions(expectedId);

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count() == 2);
        }
        public void GetRegisteredUser_Called_NotFail_Test()
        {
            string expectedFacebookId = "10";
            bool   called             = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetString = facebookId =>
                {
                    Assert.AreEqual(expectedFacebookId, facebookId);
                    called = true;
                    return(new RegisteredUser()
                    {
                        FacebookId = expectedFacebookId
                    });
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            RegisteredUser result = target.GetRegisteredUser(expectedFacebookId);

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.AreEqual(expectedFacebookId, result.FacebookId);
        }
        public void DeleteRegisteredUserFromEvent_Call_NotFail_Test()
        {
            bool called = false;
            int  expectedRegisteredUserId = 10;
            int  expectedEventId          = 20;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                DeleteRegisteredUserFromEventInt32Int32 = (registeredUserId, eventId) =>
                {
                    Assert.AreEqual(expectedRegisteredUserId, registeredUserId);
                    Assert.AreEqual(expectedEventId, eventId);
                    called = true;
                }
            };

            using (ShimsContext.Create())
            {
                MyEvents.Api.Authentication.Fakes.ShimMyEventsToken myeventToken = new Authentication.Fakes.ShimMyEventsToken();
                myeventToken.RegisteredUserIdGet     = () => { return(expectedRegisteredUserId); };
                ShimMyEventsToken.GetTokenFromHeader = () => { return(myeventToken); };

                var target = new RegisteredUsersController(registeredUserService);

                target.DeleteRegisteredUserFromEvent(expectedRegisteredUserId, expectedEventId);

                Assert.IsTrue(called);
            }
        }
        public void PostRegisteredUserScore_Call_NotFail_Test()
        {
            bool called = false;
            int  expectedRegisteredUserId = 10;
            int  expectedSessionId        = 20;
            int  expectedScore            = 3;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                AddRegisteredUserScoreInt32Int32Double = (registeredUserId, sessionId, score) =>
                {
                    Assert.AreEqual(expectedRegisteredUserId, registeredUserId);
                    Assert.AreEqual(expectedSessionId, sessionId);
                    Assert.AreEqual(expectedScore, score);
                    called = true;
                }
            };

            using (ShimsContext.Create())
            {
                MyEvents.Api.Authentication.Fakes.ShimMyEventsToken myeventToken = new Authentication.Fakes.ShimMyEventsToken();
                myeventToken.RegisteredUserIdGet     = () => { return(expectedRegisteredUserId); };
                ShimMyEventsToken.GetTokenFromHeader = () => { return(myeventToken); };
                var target = new RegisteredUsersController(registeredUserService);

                target.PostRegisteredUserScore(expectedRegisteredUserId, expectedSessionId, expectedScore);

                Assert.IsTrue(called);
            }
        }
        public void LogOn_TokenNotValid_Test()
        {
            string token = "mytoken";

            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository()
            {
                GetString = (facebookId) =>
                {
                    Assert.Fail();
                    return(null);
                }
            };
            IFacebookService facebookService = new StubIFacebookService()
            {
                GetUserInformationString = (facebookToken) =>
                {
                    return(null);
                }
            };
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            MyEvents.Api.Authentication.AuthenticationResponse response = target.LogOn(token);

            Assert.IsNull(response);
        }
        public void AddRegisteredUserToEvent_Call_NotFail_Test()
        {
            bool called = false;
            int expectedRegisteredUserId = 10;
            int expectedEventId = 20;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                AddRegisteredUserToEventInt32Int32 = (registeredUserId, eventId) =>
                {
                    Assert.AreEqual(expectedRegisteredUserId, registeredUserId);
                    Assert.AreEqual(expectedEventId, eventId);
                    called = true;
                }
            };

            using (ShimsContext.Create())
            {
                MyEvents.Api.Authentication.Fakes.ShimMyEventsToken myeventToken = new Authentication.Fakes.ShimMyEventsToken();
                myeventToken.RegisteredUserIdGet = () => { return expectedRegisteredUserId; };
                ShimMyEventsToken.GetTokenFromHeader = () => { return myeventToken; };

                var target = new RegisteredUsersController(registeredUserService);

                target.PostRegisteredUserToEvent(expectedRegisteredUserId, expectedEventId);

                Assert.IsTrue(called);
            }
        }
        public void LogOn_Logged_Test()
        {
            string token = "mytoken";

            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository()
            {
                AddRegisteredUser = (user) =>
                {
                    Assert.AreEqual(user.FacebookId, "facebookId");
                    return(10);
                }
            };
            IFacebookService facebookService = new StubIFacebookService()
            {
                GetUserInformationString = (facebookToken) =>
                {
                    return(new Model.RegisteredUser()
                    {
                        FacebookId = "facebookId"
                    });
                }
            };
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            MyEvents.Api.Authentication.AuthenticationResponse response = target.LogOn(token);

            Assert.IsNotNull(response);
            Assert.IsNotNull(response.Token);
        }
        public void GetFakeRegisteredUser_Called_NotFail_Test()
        {
            int  expectedId = 10;
            bool called     = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetByIdInt32 = registerUserId =>
                {
                    int fakeUserId = Int32.Parse(WebConfigurationManager.AppSettings["fakeUserId"]);
                    Assert.AreEqual(fakeUserId, registerUserId);
                    called = true;
                    return(new RegisteredUser()
                    {
                        RegisteredUserId = expectedId
                    });
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            RegisteredUser result = target.GetFakeRegisteredUser();

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.AreEqual(expectedId, result.RegisteredUserId);
        }
        public void LogOn_Logged_Test()
        {
            string token = "mytoken";

            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository()
            {
                AddRegisteredUser = (user) =>
                    {
                        Assert.AreEqual(user.FacebookId, "facebookId");
                        return 10;
                    }
            };
            IFacebookService facebookService = new StubIFacebookService()
            {
                GetUserInformationString = (facebookToken) =>
                    {
                        return new Model.RegisteredUser() { FacebookId = "facebookId" };
                    }
            };
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            MyEvents.Api.Authentication.AuthenticationResponse response = target.LogOn(token);

            Assert.IsNotNull(response);
            Assert.IsNotNull(response.Token);
        }
        public void PostRegisteredUser_ArgumentNullException_Test()
        {
            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();
            var target = new RegisteredUsersController(registeredUserService);

            target.PostRegisteredUserCreateIfNotExists(null);
        }
        public void GetAllRegisteredUsersBySessionId_GetResults_Test()
        {
            int  expectedId = 10;
            bool called     = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetAllBySessionIdInt32 = sessionId =>
                {
                    Assert.AreEqual(expectedId, sessionId);
                    called = true;
                    return(new List <RegisteredUser>()
                    {
                        new RegisteredUser(), new RegisteredUser()
                    });
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            IEnumerable <RegisteredUser> result = target.GetAllRegisteredUsersBySessionId(expectedId);

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count() == 2);
        }
        public void LogOn_TokenException_Test()
        {
            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
            IFacebookService          facebookService        = new StubIFacebookService();
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            target.LogOn(string.Empty);
        }
        public void GetFakeAuthorization_Coverage_NotFail_Test()
        {
            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
            IFacebookService          facebookService        = new StubIFacebookService();
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            MyEvents.Api.Authentication.AuthenticationResponse response = target.GetFakeAuthorization();
            Assert.IsNotNull(response);
            Assert.IsNotNull(response.Token);
        }
        public void GetFakeAuthorization_Coverage_NotFail_Test()
        {
            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
            IFacebookService facebookService = new StubIFacebookService();
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            MyEvents.Api.Authentication.AuthenticationResponse response = target.GetFakeAuthorization();
            Assert.IsNotNull(response);
            Assert.IsNotNull(response.Token);
        }
        public void AddRegisteredUserToEvent_Call_UnauthorizedException_Test()
        {
            bool called = false;
            int  expectedRegisteredUserId = 10;
            int  expectedEventId          = 20;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();

            using (ShimsContext.Create())
            {
                MyEvents.Api.Authentication.Fakes.ShimMyEventsToken myeventToken = new Authentication.Fakes.ShimMyEventsToken();
                myeventToken.RegisteredUserIdGet     = () => { return(10000); };
                ShimMyEventsToken.GetTokenFromHeader = () => { return(myeventToken); };

                var target = new RegisteredUsersController(registeredUserService);

                target.PostRegisteredUserToEvent(expectedRegisteredUserId, expectedEventId);

                Assert.IsTrue(called);
            }
        }
        public void GetAllRegisteredUsersByEventId_GetNull_NotFail_Test()
        {
            int  expectedId = 10;
            bool called     = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetAllByEventIdInt32 = eventId =>
                {
                    Assert.AreEqual(expectedId, eventId);
                    called = true;
                    return(null);
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            IEnumerable <RegisteredUser> result = target.GetAllRegisteredUsersByEventId(expectedId);

            Assert.IsTrue(called);
            Assert.IsNull(result);
        }
        public void PostRegisteredUser_Call_NotFail_Test()
        {
            int            expected       = 1;
            bool           called         = false;
            RegisteredUser registeredUser = new RegisteredUser();

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                AddRegisteredUser = RegisteredUserParam =>
                {
                    called = true;
                    return(expected);
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            int actual = target.PostRegisteredUserCreateIfNotExists(registeredUser);

            Assert.IsTrue(called);
            Assert.AreEqual(expected, actual);
        }
        public void GetAllRegisteredUsersByEventId_GetNull_NotFail_Test()
        {
            int expectedId = 10;
            bool called = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetAllByEventIdInt32 = eventId =>
                                                    {
                                                        Assert.AreEqual(expectedId, eventId);
                                                        called = true;
                                                        return null;
                                                    }
            };

            var target = new RegisteredUsersController(registeredUserService);

            IEnumerable<RegisteredUser> result = target.GetAllRegisteredUsersByEventId(expectedId);

            Assert.IsTrue(called);
            Assert.IsNull(result);
        }
        public void PostRegisteredUser_ArgumentNullException_Test()
        {
            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();
            var target = new RegisteredUsersController(registeredUserService);

            target.PostRegisteredUserCreateIfNotExists(null);
        }
 public void EventDefinitionController_Contructor_IFacebookServiceIsNull_Test()
 {
     IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
     var target = new AuthenticationController(eventDefinitionService, null);
 }
 public void EventDefinitionController_Contructor_NotFail_Test()
 {
     IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
     IFacebookService facebookService = new StubIFacebookService();
     var target = new AuthenticationController(eventDefinitionService, facebookService);
 }
        public void GetRegisteredUser_Called_NotFail_Test()
        {
            string expectedFacebookId = "10";
            bool called = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetString = facebookId =>
                {
                    Assert.AreEqual(expectedFacebookId, facebookId);
                    called = true;
                    return new RegisteredUser() { FacebookId = expectedFacebookId };
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            RegisteredUser result = target.GetRegisteredUser(expectedFacebookId);

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.AreEqual(expectedFacebookId, result.FacebookId);
        }
 public void RegisteredUsersController_Contructor_NotFail_Test()
 {
     IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();
     var target = new RegisteredUsersController(registeredUserService);
 }
 public void EventDefinitionController_Contructor_NotFail_Test()
 {
     IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
     IFacebookService          facebookService        = new StubIFacebookService();
     var target = new AuthenticationController(eventDefinitionService, facebookService);
 }
 public void RegisteredUsersController_Contructor_NotFail_Test()
 {
     IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();
     var target = new RegisteredUsersController(registeredUserService);
 }
        public void PostRegisteredUser_Call_NotFail_Test()
        {
            int expected = 1;
            bool called = false;
            RegisteredUser registeredUser = new RegisteredUser();

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                AddRegisteredUser = RegisteredUserParam =>
                {
                    called = true;
                    return expected;
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            int actual = target.PostRegisteredUserCreateIfNotExists(registeredUser);

            Assert.IsTrue(called);
            Assert.AreEqual(expected, actual);
        }
        public void LogOn_TokenNotValid_Test()
        {
            string token = "mytoken";

            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository()
            {
                GetString = (facebookId) =>
                {
                    Assert.Fail();
                    return null;
                }
            };
            IFacebookService facebookService = new StubIFacebookService()
            {
                GetUserInformationString = (facebookToken) =>
                {
                    return null;
                }
            };
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            MyEvents.Api.Authentication.AuthenticationResponse response = target.LogOn(token);

            Assert.IsNull(response);
        }
 public void EventDefinitionController_Contructor_IFacebookServiceIsNull_Test()
 {
     IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
     var target = new AuthenticationController(eventDefinitionService, null);
 }
        public void GetRegisteredUserEventDefinitions_GetResults_Test()
        {
            int expectedId = 10;
            bool called = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetEventDefinitionsInt32 = registeredUserId =>
                {
                    Assert.AreEqual(expectedId, registeredUserId);
                    called = true;
                    return new List<EventDefinition>() { new EventDefinition(), new EventDefinition() };
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            IEnumerable<EventDefinition> result = target.GetRegisteredUserEventDefinitions(expectedId);

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count() == 2);
        }
        public void GetFakeRegisteredUser_Called_NotFail_Test()
        {
            int expectedId = 10;
            bool called = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetByIdInt32 = registerUserId =>
                {
                    int fakeUserId = Int32.Parse(WebConfigurationManager.AppSettings["fakeUserId"]);
                    Assert.AreEqual(fakeUserId, registerUserId);
                    called = true;
                    return new RegisteredUser() { RegisteredUserId = expectedId };
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            RegisteredUser result = target.GetFakeRegisteredUser();

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.AreEqual(expectedId, result.RegisteredUserId);
        }
        public void GetAllRegisteredUsersBySessionId_GetResults_Test()
        {
            int expectedId = 10;
            bool called = false;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository()
            {
                GetAllBySessionIdInt32 = sessionId =>
                {
                    Assert.AreEqual(expectedId, sessionId);
                    called = true;
                    return new List<RegisteredUser>() { new RegisteredUser(), new RegisteredUser() };
                }
            };

            var target = new RegisteredUsersController(registeredUserService);

            IEnumerable<RegisteredUser> result = target.GetAllRegisteredUsersBySessionId(expectedId);

            Assert.IsTrue(called);
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count() == 2);
        }
        public void LogOn_TokenException_Test()
        {
            IRegisteredUserRepository eventDefinitionService = new StubIRegisteredUserRepository();
            IFacebookService facebookService = new StubIFacebookService();
            var target = new AuthenticationController(eventDefinitionService, facebookService);

            target.LogOn(string.Empty);
        }
        public void PostRegisteredUserScore_Call_UnauthorizedException_Test()
        {
            bool called = false;
            int expectedRegisteredUserId = 10;
            int expectedSessionId = 20;
            int expectedScore = 3;

            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();
            using (ShimsContext.Create())
            {
                MyEvents.Api.Authentication.Fakes.ShimMyEventsToken myeventToken = new Authentication.Fakes.ShimMyEventsToken();
                myeventToken.RegisteredUserIdGet = () => { return 10000; };
                ShimMyEventsToken.GetTokenFromHeader = () => { return myeventToken; };
                var target = new RegisteredUsersController(registeredUserService);

                target.PostRegisteredUserScore(expectedRegisteredUserId, expectedSessionId, expectedScore);

                Assert.IsTrue(called);
            }
        }