public void InsertTour_WithValidDetailsWithFutureReminder_NotInserted()
        {
            TourViewModel tourViewModel = TourMockData.GetTourViewModel();

            tourViewModel.ReminderDate = new DateTime(14, 8, 14);
            mockTourRepository.Setup(tr => tr.Insert(It.IsAny <Tour>())).Verifiable("Unable to insert Tour");
            mockUnitOfWork.Setup(tr => tr.Commit()).Returns(new Tour()
            {
                Id = NEW_TOUR_ID
            });
            InsertTourRequest request = new InsertTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository,
                                                                            0, 2, 1, 2, new DateTime(2015, 1, 31), new List <ReminderType>()
                {
                    ReminderType.Email
                }, new DateTime(2014, 12, 31)).Object
            };
            InsertTourResponse response = new InsertTourResponse();

            response = tourService.InsertTour(request);
            mockRepository.VerifyAll();
            Assert.AreEqual(null, response.Exception);
            Assert.AreNotEqual(typeof(ArgumentNullException), response.Exception);
        }
        public void GetTour_ForAnExistingContact_TourObjectFound()
        {
            var mockTour = TourMockData.CreateMockTourWithId(mockRepository, ACTIVE_CONTACT_ID);

            mockTourRepository.Setup(tr => tr.GetTourByID(It.IsAny <int>())).Returns(mockTour.Object);
            GetTourResponse response = new GetTourResponse();

            response = tourService.GetTour(ACTIVE_CONTACT_ID);

            mockRepository.VerifyAll();
            Assert.AreEqual(mockTour.Object.Id, response.TourViewModel.TourID);
        }
        public void UpdateTour_WithCurrentTourTimeWithoutReminder_SuccessfullyUpdated()
        {
            mockTourRepository.Setup(tr => tr.Update(It.IsAny <Tour>())).Verifiable("Unable to update Tour");
            UpdateTourRequest request = new UpdateTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository, 0, 2, 3, 10, new DateTime()).Object
            };
            UpdateTourResponse response = new UpdateTourResponse();

            response = tourService.UpdateTour(request);

            Assert.AreEqual(null, response.Exception);
        }
        public void InsertTour_WithoutContacts_NotInserted()
        {
            mockTourRepository.Setup(tr => tr.Insert(It.IsAny <Tour>())).Verifiable("Unable to insert Tour");
            InsertTourRequest request = new InsertTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository, 0, 0, 3, 10, new DateTime()).Object
            };
            InsertTourResponse response = new InsertTourResponse();

            response = tourService.InsertTour(request);

            Assert.AreNotEqual(null, response.Exception);
        }
        public void UpdateTour_WithoutTourType_NotUpdated()
        {
            var mockTour = TourMockData.CreateMockTourWithId(mockRepository, 1);

            mockTourRepository.Setup(tr => tr.Update(mockTour.Object)).Verifiable("Unable to update Tour");
            UpdateTourRequest request = new UpdateTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository, 0, 2, 0, 10, new DateTime()).Object
            };
            UpdateTourResponse response = new UpdateTourResponse();

            response = tourService.UpdateTour(request);

            Assert.AreNotEqual(null, response.Exception);
        }
        public void InsertTour_ReminderTypeSelectedWithoutReminderDate_NotInserted()
        {
            mockTourRepository.Setup(tr => tr.Insert(It.IsAny <Tour>())).Verifiable("Unable to insert Tour");
            InsertTourRequest request = new InsertTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository,
                                                                            0, 2, 3, 10, new DateTime(2014, 4, 1), new List <ReminderType>()
                {
                    ReminderType.Email
                }, null).Object
            };
            InsertTourResponse response = new InsertTourResponse();

            response = tourService.InsertTour(request);

            Assert.AreNotEqual(null, response.Exception);
        }
        public void InsertTour_WithCurrentTourTimeWithReminder_NotInserted()  //Business Rule: Reminder cannot be set for past and current times.
        {
            mockTourRepository.Setup(tr => tr.Insert(It.IsAny <Tour>())).Verifiable("Unable to insert Tour");
            InsertTourRequest request = new InsertTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository,
                                                                            0, 2, 3, 10, new DateTime(), new List <ReminderType>()
                {
                    ReminderType.Email
                }, new DateTime()).Object
            };
            InsertTourResponse response = new InsertTourResponse();

            response = tourService.InsertTour(request);

            Assert.AreNotEqual(null, response.Exception);
        }
        public void UpdateTour_WithoutCommunity_NotUpdated()
        {
            mockTourRepository.Setup(tr => tr.Update(It.IsAny <Tour>())).Verifiable("Unable to update Tour");
            UpdateTourRequest request = new UpdateTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository,
                                                                            0, 2, 1, 0, new DateTime(2015, 1, 1),
                                                                            new List <ReminderType>()
                {
                    ReminderType.Email
                }, new DateTime()).Object
            };
            UpdateTourResponse response = new UpdateTourResponse();

            response = tourService.UpdateTour(request);

            Assert.AreNotEqual(null, response.Exception);
        }
        public void UpdateTour_ReminderTypeSelectedWithReminderDate_SuccessfullyUpdated()
        {
            mockTourRepository.Setup(tr => tr.Update(It.IsAny <Tour>())).Verifiable("Unable to update Tour");
            UpdateTourRequest request = new UpdateTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository,
                                                                            0, 2, 3, 10, new DateTime(2015, 4, 1, 12, 0, 0),
                                                                            new List <ReminderType>()
                {
                    ReminderType.Email
                }, new DateTime(2015, 4, 1, 11, 0, 0)).Object
            };
            UpdateTourResponse response = new UpdateTourResponse();

            response = tourService.UpdateTour(request);

            Assert.AreEqual(null, response.Exception);
        }
Beispiel #10
0
        public void InsertTour_WithCurrentTourTimeWithoutReminder_SuccessfullyInserted()
        {
            mockTourRepository.Setup(tr => tr.Insert(It.IsAny <Tour>()));
            mockUnitOfWork.Setup(tr => tr.Commit()).Returns(new Tour()
            {
                Id = NEW_TOUR_ID
            });
            InsertTourRequest request = new InsertTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository, 0, 2, 3, 10, new DateTime()).Object
            };
            InsertTourResponse response = new InsertTourResponse();

            response = tourService.InsertTour(request);
            //Assert.AreEqual(request.TourViewModel.ReminderDate, new DateTime(2015, 4, 1, 12, 0, 0));
            Assert.AreEqual(null, response.Exception);
            Assert.AreNotEqual(typeof(ArgumentNullException), response.Exception);
        }
Beispiel #11
0
        public void UpdateTour_WithValidDetailsWithoutReminder_SuccessfullyUpdated()
        {
            var mockTour = TourMockData.CreateMockTourWithId(mockRepository, 0);

            mockTourRepository.Setup(tr => tr.Update(mockTour.Object)).Verifiable("Unable to update Tour");
            UpdateTourRequest request = new UpdateTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository, 10, 2, 1, 5, new DateTime()).Object
            };
            UpdateTourResponse response = new UpdateTourResponse();

            request.TourViewModel.Contacts.Add(new ContactEntry()
            {
                Id = 10
            });
            response = tourService.UpdateTour(request);

            Assert.AreEqual(null, response.Exception);
        }
Beispiel #12
0
        //[TestMethod]
        public void InsertTour_WithValidDetailsWithoutReminder_SuccessfullyInserted()
        {
            TourViewModel tourViewModel = TourMockData.GetTourViewModel();

            mockTourRepository.Setup(tr => tr.Insert(It.IsAny <Tour>())).Verifiable("Unable to insert Tour");
            mockUnitOfWork.Setup(tr => tr.Commit()).Returns(new Tour()
            {
                Id = NEW_TOUR_ID
            });
            InsertTourRequest request = new InsertTourRequest()
            {
                TourViewModel = TourMockData.CreateMockTourWithCustomValues(mockRepository, 10, 2, 1, 5, new DateTime()).Object
            };
            InsertTourResponse response = new InsertTourResponse();

            //InsertTourResponse response = tourService.InsertTour(new InsertTourRequest() { TourViewModel = tourViewModel });
            //response = tourService.InsertTour(request);
            mockRepository.VerifyAll();
            Assert.AreEqual(null, response.Exception);
            Assert.AreNotEqual(typeof(ArgumentNullException), response.Exception);
        }