Ejemplo n.º 1
0
        public void PassQuestionForUser_ShouldPassQuestionsThatAreUnanswered()
        {
            var shouldPass = new PendingQuestion { Status = null, Question = new Question() { ID = 1 } };
            var shouldPass2 = new PendingQuestion { Status = true, Question = new Question() { ID = 1 } };
            var shouldNotPass = new PendingQuestion { Status = true, Answer = new Answer(), Question = new Question() { ID = 1 } };
            var shouldNotPass2 = new PendingQuestion { Status = false, Question = new Question() { ID = 1 } };

            var user = new User
            {
                PendingQuestions = new Collection<PendingQuestion>
                        {
                            shouldPass,
                            shouldPass2,
                            shouldNotPass,
                            shouldNotPass2
                        }
            };

            _dataFactory.Setup(x => x.UserRepository.GetUserByEmail(It.IsAny<string>())).Returns(user);
            _dataFactory.Setup(x => x.PendingQuestionRepository).Returns(new Mock<IPendingQuestionRepository>().Object);
            _advisorLocator.Setup(x => x.GetNextInLine(It.IsAny<int>())).Returns(new User());
            _adviseManager.PassQuestionForUser("email");

            Assert.That(shouldPass.Status, Is.False);
            Assert.That(shouldPass2.Status, Is.False);
            Assert.That(shouldNotPass.Status, Is.True);
            Assert.That(shouldNotPass2.Status, Is.False);
        }
Ejemplo n.º 2
0
 public void QuestionAssigned(PendingQuestion pendingQuestion)
 {
     var client = _socketManager.GetClient(pendingQuestion.User.Email);
     if (client != null)
     {
         client.Send(SocketEvent.QuestionAssigned(pendingQuestion));
     }
 }
Ejemplo n.º 3
0
        public void QuestionAssigned_ShouldReturnCorrectJson()
        {
            //Arrange
             const string expectedJson = "[\"QuestionAssigned\",{\"ID\":1}]";
             var pendingQuestion = new PendingQuestion {ID = 1};

             //Act
             var result = SocketEvent.QuestionAssigned(pendingQuestion);

             //Assert
             Assert.That(result, Is.EqualTo(expectedJson));
        }
Ejemplo n.º 4
0
        public void StartAnswer_ShouldReturnTrue_WhenSuccessfull()
        {
            //Arrange
            var pending = new PendingQuestion
            {
                TimeStamp = DateTime.Now.AddSeconds(-Configuration.Timeout.Respond + 5) //5 seconds to spare
            };
            var pendingQuestionRepository = new Mock<IPendingQuestionRepository>();
            pendingQuestionRepository.Setup(x => x.GetByID(It.IsAny<int>())).Returns(pending);
            _dataFactory.Setup(x => x.PendingQuestionRepository).Returns(pendingQuestionRepository.Object);

            //Act
            var result = _adviseManager.StartAnswer(pending);

            //Assert
            Assert.That(result, Is.True);
        }
Ejemplo n.º 5
0
        public void StartAnswer_ShouldNotifyEventManager_WhenSuccessfull()
        {
            //Arrange
            var pending = new PendingQuestion
            {
                TimeStamp = DateTime.Now.AddSeconds(-Configuration.Timeout.Respond + 5) //5 seconds to spare
            };
            var pendingQuestionRepository = new Mock<IPendingQuestionRepository>();
            pendingQuestionRepository.Setup(x => x.GetByID(It.IsAny<int>())).Returns(pending);
            _dataFactory.Setup(x => x.PendingQuestionRepository).Returns(pendingQuestionRepository.Object);

            //Act
            _adviseManager.StartAnswer(pending);

            //Assert
            _eventManager.Verify(x => x.AnswerStarted(pending), Times.Once);
        }
Ejemplo n.º 6
0
        public void GetDeadLine_ShouldReturnCorrectDateTime_ForRespond()
        {
            //Arrange
            var now = DateTime.Now;
            var expected = now.AddSeconds(Configuration.Timeout.Respond);

            var pending = new PendingQuestion
            {
                Status = null,
                TimeStamp = now
            };

            //Act
            var result = _adviseManager.GetDeadline(pending);

            //Arrange
            Assert.That(result, Is.EqualTo(expected));
        }
Ejemplo n.º 7
0
        public void StartAnswer_ShouldNotNotifyEventManagerOrUpdateStatus_AndReturnFalse_IfUserWasTooLate()
        {
            var pending = new PendingQuestion
            {
                TimeStamp = DateTime.Now.AddSeconds(-Configuration.Timeout.Respond - 5) //5 seconds too late
            };
            var pendingQuestionRepository = new Mock<IPendingQuestionRepository>();
            pendingQuestionRepository.Setup(x => x.GetByID(It.IsAny<int>())).Returns(pending);
            _dataFactory.Setup(x => x.PendingQuestionRepository).Returns(pendingQuestionRepository.Object);

            //Act
            var result = _adviseManager.StartAnswer(pending);

            //Assert
            Assert.That(result, Is.False);
            pendingQuestionRepository.Verify(x => x.Update(pending), Times.Never);
            _dataFactory.Verify(x => x.Commit(), Times.Never);
            _eventManager.Verify(x => x.AnswerStarted(pending), Times.Never);
        }
Ejemplo n.º 8
0
        public void GetAvailableUsers_ShouldNotReturnUsers_WhoHasAcceptedToAnswer_ButHasNotCompletedIt()
        {
            //Arrange
            var dbMock = new Mock<IRadvillContext>();

            var userOne = new User
            {
                ID = 1,
                Connected = true
            };

            var userDbSet = new FakeDbSet<User>
                 {
                     userOne
                 };

            dbMock.Setup(x => x.Users).Returns(userDbSet);

            var pendingQuestion = new PendingQuestion
            {
                ID = 1,
                User = userOne,
                Answer = null,
                Status = true
            };

            var pendingQuestionDbSet = new FakeDbSet<PendingQuestion>
                 {
                     pendingQuestion
                 };

            dbMock.Setup(x => x.PendingQuestions).Returns(pendingQuestionDbSet);
            dbMock.Setup(x => x.Set<User>()).Returns(userDbSet);

            var userRepository = new UserRepository(dbMock.Object);

            //Act
            var result = userRepository.GetAvailableUsers();

            //Assert
            Assert.That(result, Is.Not.Null);
            Assert.That(result.Count(), Is.EqualTo(0));
        }
Ejemplo n.º 9
0
        public void PassQuestion_ShouldAddNewPendingQuestion_IfAdvisorIsAvailable()
        {
            var pending = new PendingQuestion { Question = new Question() };
            //Arrange
            var pendingQuestionRepository = new Mock<IPendingQuestionRepository>();
            pendingQuestionRepository.Setup(x => x.GetByID(It.IsAny<int>())).Returns(pending);
            _dataFactory.Setup(x => x.PendingQuestionRepository).Returns(pendingQuestionRepository.Object);
            _dataFactory.Setup(x => x.QuestionRepository.GetByID(It.IsAny<int>())).Returns(new Question());
            _advisorLocator.Setup(x => x.GetNextInLine(It.IsAny<int>())).Returns(new User());

            //Act
            _adviseManager.PassQuestion(pending);

            //Assert
            pendingQuestionRepository.Verify(x => x.Update(pending), Times.Once);
            pendingQuestionRepository.Verify(x => x.Insert(It.IsAny<PendingQuestion>()), Times.Once);
            _dataFactory.Verify(x => x.Commit(), Times.Exactly(2));
            _eventManager.Verify(x => x.QuestionAssigned(It.IsAny<PendingQuestion>()), Times.Once);
        }
Ejemplo n.º 10
0
        public void SubmitAnswer_ShouldReturnFalse_WhenDeadlineHasPassed()
        {
            //Arrange
            var pending = new PendingQuestion
            {
                TimeStamp = DateTime.Now.AddSeconds(-Configuration.Timeout.Respond - 5) //5 seconds over due
            };
            const string answer = "Answer";
            var answerRepo = new Mock<IAnswerRepository>();
            _dataFactory.Setup(x => x.AnswerRepository).Returns(answerRepo.Object);

            //Act
            var result = _adviseManager.SubmitAnswer(pending, answer);

            //Assert
            Assert.That(result, Is.False);
            answerRepo.Verify(x => x.Insert(It.IsAny<Answer>()), Times.Never);
            _dataFactory.Verify(x => x.Commit(), Times.Never);
            _eventManager.Verify(x => x.AnswerSubmitted(It.IsAny<Answer>()), Times.Never);
        }
Ejemplo n.º 11
0
        public void GetNextInLine_ShouldNotReturnUser_WhoHavePassedTheQuestionBefore()
        {
            //Arrange
            var question = new Question{ID = 1};
            var question2 = new Question{ID = 2};
            var user = new User { Answers = new Collection<Answer>(), Questions = new Collection<Question>(),Connected = true};
            var pending = new PendingQuestion {Question = question, Status = false, User = user};
            var pending2 = new PendingQuestion {Question = question2, Status = false, User = user};
            user.PendingQuestions = new Collection<PendingQuestion>{pending, pending2};

            var users = new List<User> {user};
            _userRepositoryMock.Setup(x => x.GetAvailableUsers()).Returns(users);
            _dataFactoryMock.Setup(x => x.UserRepository).Returns(_userRepositoryMock.Object);
            _advisorLocator = new AdvisorLocator(_dataFactoryMock.Object);

            //Act
            var result = _advisorLocator.GetNextInLine(question2.ID);

            //Assert
            Assert.That(result, Is.Null);
        }
Ejemplo n.º 12
0
        public void PassQuestion(PendingQuestion pendingQuestion)
        {
            try
            {
                //Set pass status
                pendingQuestion.Status = false;
                _dataFactory.PendingQuestionRepository.Update(pendingQuestion);
                _dataFactory.Commit();

                var reciever = _advisorLocator.GetNextInLine(pendingQuestion.Question.ID);
                if (reciever == null)
                {
                    AllRecipientsPassed(pendingQuestion.Question);
                    return;
                }

                SendQuestionToNewUser(pendingQuestion.Question);
            }
            catch (Exception e)
            {
                Logger.Log.Fatal("Exception during Pass Question", e);
                throw;
            }
        }
Ejemplo n.º 13
0
 public AnswerStartedEvent(PendingQuestion pendingQuestion)
 {
     ID = pendingQuestion.Question.ID;
 }
Ejemplo n.º 14
0
 public bool StartAnswer(PendingQuestion pending)
 {
     try
     {
         if (DateTime.Now > GetDeadline(pending))
         {
             return false;
         }
         pending.Status = true;
         _dataFactory.PendingQuestionRepository.Update(pending);
         _dataFactory.Commit();
         _eventManager.AnswerStarted(pending);
         return true;
     }
     catch (Exception e)
     {
         Logger.Log.Fatal("Exception during start answer", e);
         throw;
     }
 }
Ejemplo n.º 15
0
 public DateTime GetDeadline(PendingQuestion pending)
 {
     return pending.Status == true
         ? pending.TimeStamp.AddSeconds(Configuration.Timeout.Respond + Configuration.Timeout.Answer)
         : pending.TimeStamp.AddSeconds(Configuration.Timeout.Respond);
 }
Ejemplo n.º 16
0
        private bool SendQuestionToNewUser(Question question)
        {
            var reciever = _advisorLocator.GetNextInLine(question.ID);
            if (reciever == null)
            {
                AllRecipientsPassed(question);
                return false;
            }

            var newPending = new PendingQuestion
            {
                Question = question,
                Status = null,
                TimeStamp = DateTime.Now,
                User = reciever
            };

            _dataFactory.PendingQuestionRepository.Insert(newPending);
            _dataFactory.Commit();
            _eventManager.QuestionAssigned(newPending);
            return true;
        }
Ejemplo n.º 17
0
        public void PassQuestion_ShouldSetPassStatus_ToPendingQuestion()
        {
            //Arrange

            var pending = new PendingQuestion
            {
                Question = new Question(),
                Status = null
            };

            _dataFactory.Setup(x => x.PendingQuestionRepository.GetByID(It.IsAny<int>())).Returns(pending);
            _dataFactory.Setup(x => x.QuestionRepository).Returns(new Mock<IQuestionRepository>().Object);

            //Act
            _adviseManager.PassQuestion(pending);

            //Assert
            Assert.That(pending.Status, Is.False);
            _dataFactory.Verify(x => x.PendingQuestionRepository.Update(pending), Times.Once);
            _dataFactory.Verify(x => x.Commit(), Times.Exactly(2));
        }
Ejemplo n.º 18
0
 public QuestionAssignedEvent(PendingQuestion pendingQuestion)
 {
     ID = pendingQuestion.ID;
 }
Ejemplo n.º 19
0
        public void SubmitAnswer_ShouldReturnTrue_WhenSuccessfull()
        {
            //Arrange
            var pending = new PendingQuestion
            {
                TimeStamp = DateTime.Now.AddSeconds(-Configuration.Timeout.Respond + 5), //5 seconds to spare
            };
            const string answer = "Answer";
            var answerRepo = new Mock<IAnswerRepository>();
            var pendingQuestionRepo = new Mock<IPendingQuestionRepository>();
            _dataFactory.Setup(x => x.AnswerRepository).Returns(answerRepo.Object);
            _dataFactory.Setup(x => x.PendingQuestionRepository).Returns(pendingQuestionRepo.Object);

            //Act
            var result = _adviseManager.SubmitAnswer(pending, answer);

            //Assert
            Assert.That(result, Is.True);
            Assert.That(pending.Answer, Is.Not.Null);
            answerRepo.Verify(x => x.Insert(It.IsAny<Answer>()), Times.Once);
            pendingQuestionRepo.Verify(x => x.Update(pending), Times.Once);
            _dataFactory.Verify(x => x.Commit(), Times.Once);
            _eventManager.Verify(x => x.AnswerSubmitted(It.IsAny<Answer>()), Times.Once);
        }
Ejemplo n.º 20
0
        public bool SubmitAnswer(PendingQuestion pending, string answer)
        {
            try
            {
                var now = DateTime.Now;
                if (now > GetDeadline(pending) || pending.Answer != null)
                {
                    return false;
                }

                var answerEntity = new Answer
                    {
                        Accepted = null,
                        Question = pending.Question,
                        Text = answer,
                        User = pending.User,
                        TimeStamp = now
                    };
                pending.Answer = answerEntity;
                _dataFactory.PendingQuestionRepository.Update(pending);
                _dataFactory.AnswerRepository.Insert(answerEntity);
                _dataFactory.Commit();
                _eventManager.AnswerSubmitted(answerEntity);
                return true;
            }
            catch (Exception e)
            {
                Logger.Log.Fatal("Exception during submit answer", e);
                throw;

            }
        }
Ejemplo n.º 21
0
        public bool SubmitQuestion(int userid, int categoryId, string question)
        {
            try
            {
                var user = _dataFactory.UserRepository.GetByID(userid);
                var category = _dataFactory.CategoryRepository.GetByID(categoryId);
                var timeStamp = DateTime.Now;

                var questionEntity = new Question
                {
                    Text = question,
                    Category = category,
                    User = user,
                    TimeStamp = timeStamp
                };

                _dataFactory.QuestionRepository.Insert(questionEntity);
                _dataFactory.Commit();

                var reciever = _advisorLocator.GetNextInLine(questionEntity.ID);

                if (reciever == null)
                {
                    _dataFactory.QuestionRepository.Delete(questionEntity);
                    _dataFactory.Commit();
                    return false;
                }

                var pendingEntity = new PendingQuestion
                {
                    Question = questionEntity,
                    Status = null,
                    User = reciever,
                    TimeStamp = timeStamp
                };

                _dataFactory.PendingQuestionRepository.Insert(pendingEntity);
                _dataFactory.Commit();
                _eventManager.QuestionAssigned(pendingEntity);
                return true;
            }
            catch (Exception e)
            {
                Logger.Log.Fatal("Exception during Submit Question", e);
                throw;
            }
        }
Ejemplo n.º 22
0
 public static string QuestionAssigned(PendingQuestion pendingQuestion)
 {
     var eventData = new QuestionAssignedEvent(pendingQuestion);
     var json = string.Format(JsonBody, "QuestionAssigned", JsonConvert.SerializeObject(eventData));
     return json;
 }
Ejemplo n.º 23
0
        public void GetAvailableUsers_ShouldReturnUsers_WhoIsntAnswereringAQuestion()
        {
            //Arrange
             var dbMock = new Mock<IRadvillContext>();

             var userOne = new User
                 {
                     ID = 1,
                     Connected = true
                 };

             var userTwo = new User
                 {
                     ID = 2,
                     Connected = true
                 };

             var userDbSet = new FakeDbSet<User>
                 {
                     userOne,
                     userTwo
                 };

             dbMock.Setup(x => x.Users).Returns(userDbSet);

             var pendingQuestion = new PendingQuestion
                 {
                     ID = 1,
                     User = userOne
                 };

             var pendingQuestionDbSet = new FakeDbSet<PendingQuestion>
                 {
                     pendingQuestion
                 };

             dbMock.Setup(x => x.PendingQuestions).Returns(pendingQuestionDbSet);
            dbMock.Setup(x => x.Set<User>()).Returns(userDbSet);

             var userRepository = new UserRepository(dbMock.Object);

             //Act
             var result = userRepository.GetAvailableUsers();

             //Assert
             Assert.That(result, Is.Not.Null);
             Assert.That(result.Count(), Is.EqualTo(1));
             Assert.That(result.First().ID, Is.EqualTo(userTwo.ID));
        }