Esempio n. 1
0
        public void Execute(UpdateStudentGradeMessage message)
        {
            var test = Thread.CurrentPrincipal.Identity.Name;

            if (test == "ofebres-cordero")
            {
                var student = _studentRepository.Read(message.StudentId); // pulls the appropriate student - given ID
                student.Grades = student.Grades
                                 .Select(t =>
                                         (t.Subject ?? string.Empty) == message.SubjectName
                            ? message.Grade
                            : t) // says for every grade with the same subjectname, replace the entire grade with new grade
                                 .ToList();

                var grade = new Dictionary <string, object>
                {
                    {
                        "Grades", student.Grades
                    }
                };
                _studentRepository.Update(message.StudentId, grade);
                var replyMessage = new UpdateStudentGradeReplyMessage(message.CorrelationId);
                //_studentRepository.Update(message.StudentId, message.UpdatedFields);

                Context.Reply(replyMessage);
            }
            else
            {
                Console.WriteLine("Request Failed - Invalid Token");
            }

            Context.Reply(new GetAllStudentsReplyMessage(message.CorrelationId));
        }
Esempio n. 2
0
        public void Execute(UpdateStudentGradeMessage message)
        {
            var username = _claimsHelper.GetClaims().UserClaims.Username;

            if (username == "ofebres-cordero")
            {
                var student    = _repository.Read(message.StudentId); // pulls the appropriate student - given ID
                var origGrade  = student.Grades.FirstOrDefault(_ => _.Subject == message.SubjectName);
                var newSubject = message.Grade.Subject;
                var newScore   = message.Grade.Score;

                if (newSubject != String.Empty)
                {
                    origGrade.Subject = newSubject;
                }
                if (newScore != 0)
                {
                    origGrade.Score = newScore;
                }


                _repository.UpdateGrade(message.StudentId, origGrade);
                var replyMessage = new UpdateStudentGradeReplyMessage(message.CorrelationId);
                //_studentRepository.Update(message.StudentId, message.UpdatedFields);

                Context.Reply(replyMessage);
            }
            else
            {
                Console.WriteLine("Request Failed - Invalid Token");
                Context.Reply(new GetAllStudentsReplyMessage(message.CorrelationId));
            }
        }
        public void GivenUpdateGradeMessage_WhenCallingUpgradeStudentGradeHandler_ThenCorrespondingReplyIsSend()
        {
            // Arrange
            var repositry = new Mock <ISqlRepository <IStudent> >(MockBehavior.Strict);
            var testGrade = new Grade {
                Subject = "TestGradeUpdated"
            };

            repositry.Setup(s => s.UpdateGrade(1, testGrade));
            repositry.Setup(s => s.Read(1)).Returns(new Student("test1", "1")
            {
                Id = 1, Grades = new List <Grade>
                {
                    testGrade,
                    new Grade {
                        Subject = "English"
                    }
                }
            });
            var claimsHelper = new Mock <IClaimsHelper>(MockBehavior.Strict);

            claimsHelper.Setup(h => h.GetClaims()).Returns(new Claims()
            {
                UserClaims = new UserClaim()
                {
                    Username = "******"
                }
            });

            var context = new Mock <IConsumeContext>(MockBehavior.Strict);

            context.Setup(c => c.Reply(It.IsAny <UpdateStudentGradeReplyMessage>()));

            var handler = new SqlUpdateStudentGradeHandler(repositry.Object, claimsHelper.Object)
            {
                Context = context.Object
            };

            UpdateStudentGradeMessage      request = new UpdateStudentGradeMessage(Guid.NewGuid(), 1, testGrade, "TestGradeUpdated");
            UpdateStudentGradeReplyMessage reply   = null;

            // Act
            handler.Execute(request);

            // Assert
            context.Verify(c => c.Reply(It.IsAny <UpdateStudentGradeReplyMessage>()), Times.Once);

            Assert.Equal("TestGradeUpdated", testGrade.Subject);
        }
        public void GivenUpdatingGrade_WhenPutting_ThenCorrespondingGradeIsUpdated()
        {
            // Arrange

            var testStudent = new Student("OliCreationTest", "test")
            {
                Id     = 1,
                Grades = new List <Grade>
                {
                    new Grade {
                        Subject = "Maths", Score = 10
                    }
                }
            };
            var testGrade = new Grade {
                Score = 100
            };
            UpdateStudentGradeMessage      request = null;
            UpdateStudentGradeReplyMessage reply   = null;

            var queryCountWrapper = new Mock <IQueryCountWrapper>();

            queryCountWrapper.SetupGet(qcw => qcw.QueryCount).Returns(0);

            var bus = new Mock <IBus>(MockBehavior.Strict);

            bus
            .Setup(b => b.SendRequest
                   <UpdateStudentGradeMessage, UpdateStudentGradeReplyMessage>
                       (It.IsAny <string>(), It.IsAny <UpdateStudentGradeMessage>(), null, It.IsAny <int>()))
            .Returns <string, UpdateStudentGradeMessage, Dictionary <string, string>, int>(
                (endpoint, message, headers, timeout) =>
            {
                request = message;
                reply   = new UpdateStudentGradeReplyMessage(message.CorrelationId);
                return(reply);
            });

            var claimsHelper = new Mock <IClaimsHelper>(MockBehavior.Strict);
            var controller   = new StudentController(bus.Object, claimsHelper.Object, queryCountWrapper.Object);

            // Act
            var result         = controller.UpdateGrade(testStudent.Id, testGrade, "Maths");
            var okObjectResult = result as AcceptedResult;

            // Assert

            Assert.NotNull(okObjectResult);
        }