Beispiel #1
0
        public void GetByIdGotDataFromDao()
        {
            const int userId = 1;

            Internship.Cashe.Models.User user          = new Internship.Cashe.Models.User();
            Mock <IUserCache>            userCacheMock = new Mock <IUserCache>();

            userCacheMock.Setup(x => x.GetUserById(userId))
            .Verifiable();
            Mock <IUserDAO> userDaoMock = new Mock <IUserDAO>();

            userDaoMock.Setup(x => x.GetById(userId))
            .Returns(user)
            .Verifiable();
            userCacheMock.Setup(x => x.Set(user))
            .Verifiable();

            IUserDAO userDao = new CachedUserDAO(userDaoMock.Object, userCacheMock.Object);

            Internship.Cashe.Models.User result = userDao.GetById(userId);
            Assert.That(result, Is.Not.Null);
            userCacheMock.Verify(x => x.GetUserById(userId), Times.Once);
            userDaoMock.Verify(x => x.GetById(userId), Times.Once);
            userCacheMock.Verify(x => x.Set(user), Times.Once);
        }
        public void GetByIdGotDataFromCache()
        {
            const int         userId        = 1;
            Mock <IUserCache> userCacheMock = new Mock <IUserCache>();

            userCacheMock.Setup(x => x.GetUserById(userId))
            .Returns(new User())
            .Verifiable();

            Mock <IUserDAO> userDaoMock = new Mock <IUserDAO>();

            userDaoMock.Setup(x => x.GetById(userId))
            .Verifiable();

            IUserDAO userDao = new CachedUserDAO(userDaoMock.Object, userCacheMock.Object);
            User     user    = userDao.GetById(userId);

            Assert.That(user, Is.Not.Null);
            userCacheMock.Verify(x => x.GetUserById(userId), Times.Once);
            userDaoMock.Verify(x => x.GetById(userId), Times.Never);
        }
Beispiel #3
0
        public void GetByRoleGotDataFromDao()
        {
            const string usersRole = "Mentor";
            IList <Internship.Cashe.Models.User> users = new List <Internship.Cashe.Models.User>();
            Mock <IUserDAO>   userDaoMock   = new Mock <IUserDAO>();
            Mock <IUserCache> userCacheMock = new Mock <IUserCache>();

            userCacheMock.Setup(x => x.GetUsersByRole(usersRole))
            .Verifiable();
            userDaoMock.Setup(x => x.GetUsersByRole(usersRole))
            .Returns(users)
            .Verifiable();
            userCacheMock.Setup(x => x.Set(usersRole, users))
            .Verifiable();
            IUserDAO userDao = new CachedUserDAO(userDaoMock.Object, userCacheMock.Object);
            IList <Internship.Cashe.Models.User> result = userDao.GetUsersByRole(usersRole);

            Assert.That(result, Is.Not.Null);
            userCacheMock.Verify(x => x.GetUsersByRole(usersRole), Times.Once);
            userDaoMock.Verify(x => x.GetUsersByRole(usersRole), Times.Once);
            userCacheMock.Verify(x => x.Set(usersRole, result), Times.Once);
        }
        public void GetByRoleGotDataFromCache()
        {
            const string      usersRole     = "Mentor";
            Mock <IUserCache> userCacheMock = new Mock <IUserCache>();

            userCacheMock.Setup(x => x.GetUsersByRole(usersRole))
            .Returns(new List <User> {
                new User()
            })
            .Verifiable();

            Mock <IUserDAO> userDaoMock = new Mock <IUserDAO>();

            userDaoMock.Setup(x => x.GetUsersByRole(usersRole))
            .Verifiable();

            IUserDAO     userDao = new CachedUserDAO(userDaoMock.Object, userCacheMock.Object);
            IList <User> users   = userDao.GetUsersByRole(usersRole);

            Assert.That(users, Is.Not.Null);
            userCacheMock.Verify(x => x.GetUsersByRole(usersRole), Times.Once);
            userDaoMock.Verify(x => x.GetUsersByRole(usersRole), Times.Never);
        }