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 RegisteredUsersController_Contructor_NotFail_Test()
 {
     IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();
     var target = new RegisteredUsersController(registeredUserService);
 }
 public void RegisteredUsersController_ContructorWithNullDependency_Fail_Test()
 {
     var target = new RegisteredUsersController(null);
 }
        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 PostRegisteredUser_ArgumentNullException_Test()
        {
            IRegisteredUserRepository registeredUserService = new StubIRegisteredUserRepository();
            var target = new RegisteredUsersController(registeredUserService);

            target.PostRegisteredUserCreateIfNotExists(null);
        }
        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);
            }
        }
        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 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 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);
        }