public async Task HandleGet_ShouldCallGetOnServiceAndReplyOnContext()
        {
            // Data
            var calendarEventModel = new CalendarEventModel {
                Name = "test_name"
            };
            var getCalendarEventCommand = new GetCalendarEventCommand {
                Model = calendarEventModel
            };
            IEnumerable <CalendarEventModel> calendarEvents = new List <CalendarEventModel>
            {
                calendarEventModel
            };

            //Setup
            _mockCalendarService.Setup(x => x.GetEvent(It.Is <CalendarEventModel>(y => y.Name == getCalendarEventCommand.Model.Name)))
            .Returns(Task.FromResult(calendarEvents)).Verifiable();
            _mockMessageHandlerContext.Setup(x => x.Reply(It.Is <GetResponse>(y => y.Models == calendarEvents), It.IsAny <ReplyOptions>()))
            .Returns(Task.CompletedTask).Verifiable();

            //Test
            var handler = new CalendarEventHandler(_mockCalendarService.Object);
            await handler.Handle(getCalendarEventCommand, _mockMessageHandlerContext.Object);

            //Analysis
            _mockCalendarService.Verify();
            _mockMessageHandlerContext.Verify();
        }
        public async Task HandleGetAll_ShouldCallGetAll()
        {
            //Data
            var userId        = "test";
            var getAllCommand = new GetAllCalendarEventsCommand {
                UserId = userId
            };
            IEnumerable <CalendarEventModel> calendarEvents = new List <CalendarEventModel>
            {
                new CalendarEventModel {
                    Name = "test_name"
                }
            };

            //Setup
            _mockCalendarService.Setup(x => x.GetAllEvents(userId)).Returns(Task.FromResult(calendarEvents))
            .Verifiable();
            _mockMessageHandlerContext.Setup(x => x.Reply(It.Is <GetResponse>(y => y.Models == calendarEvents), It.IsAny <ReplyOptions>()))
            .Returns(Task.CompletedTask).Verifiable();

            //Test
            var handler = new CalendarEventHandler(_mockCalendarService.Object);
            await handler.Handle(getAllCommand, _mockMessageHandlerContext.Object);

            //Analysis
            _mockCalendarService.Verify();
            _mockMessageHandlerContext.Verify();
        }
        public async Task HandleDelete_ShouldCallDeleteOnService()
        {
            // Data
            var deleteCalendarEventCommand = new DeleteCalendarEventCommand {
                Id = Guid.NewGuid(), UserId = "test"
            };

            // Setup
            _mockCalendarService.Setup(x => x.DeleteEvent(It.Is <Guid>(y => y == deleteCalendarEventCommand.Id), It.Is <string>(y => y == "test")))
            .Returns(Task.CompletedTask).Verifiable();

            // Test
            var handler = new CalendarEventHandler(_mockCalendarService.Object);
            await handler.Handle(deleteCalendarEventCommand, _mockMessageHandlerContext.Object);

            // Analysis
            _mockCalendarService.Verify();
        }
        public async Task HandleUpdate_ShouldCallUpdateOnService()
        {
            // Data
            var updateCalendarEventCommand = new UpdateCalendarEventCommand {
                Model = new CalendarEventModel()
            };

            // Setup
            _mockCalendarService.Setup(x => x.UpdateEvent(It.Is <CalendarEventModel>(y => y == updateCalendarEventCommand.Model)))
            .Returns(Task.CompletedTask).Verifiable();

            // Test
            var handler = new CalendarEventHandler(_mockCalendarService.Object);
            await handler.Handle(updateCalendarEventCommand, _mockMessageHandlerContext.Object);

            // Analysis
            _mockCalendarService.Verify();
        }