public void GetBookingsByBusinessBetweenDatesForInvalidDatesThrowsException()
            {
                // Arrange
                DateTime startDate = new DateTime(2012, 1, 5, 0, 0, 0, DateTimeKind.Utc);
                DateTime endDate = new DateTime(2012, 1, 2, 0, 0, 0, DateTimeKind.Utc);
                long businessId = 3;
                var bookingDao = new Mock<IBookingDao>();
                var orderDao = new Mock<IOrderDao>();
                DiaryDataRetrievalManager manager = new DiaryDataRetrievalManager();

                bookingDao.Setup(x => x.GetBetweenDates(businessId, startDate, endDate, It.IsAny<string>())).Returns(new List<Booking>());
                orderDao.Setup(o => o.GetByKey(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<GetOrderWithBookingsByEnum>())).Returns(new Order());

                manager.BookingDao = bookingDao.Object;
                manager.OrderDao = orderDao.Object;

                // act
                CheckForEviivoException<ValidationException>(() => manager.GetBookingsByBusinessBetweenDates(businessId, startDate, endDate), "Wrong dates did not throw correct error code.", "SRVEX30002");

                // assert
                bookingDao.Verify(b => b.GetBetweenDates(businessId, startDate, endDate, It.IsAny<string>()), Times.Never());
                orderDao.Verify(o => o.GetByKey(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<GetOrderWithBookingsByEnum>()), Times.Never());
            }
            public void GetBookingsByBusinessBetweenDatesValidDatesCallsDao()
            {
                // Arrange
                // Parameters for the invoke
                var startDate = new DateTime(2012, 1, 1, 0, 0, 0, DateTimeKind.Utc);
                var endDate = new DateTime(2012, 1, 5, 0, 0, 0, DateTimeKind.Utc);
                long businessId = 1;

                var bookingDao = new Mock<IBookingDao>();

                var diaryDataRetrievalMgr = new DiaryDataRetrievalManager
                    {
                        BookingDao = bookingDao.Object
                    };

                // Create a list with 2 entries
                var bookingData = new List<Booking>
                    {
                        new Booking
                        {
                            Id = 12345,
                            BookingReferenceNumber = "B123"
                        },
                        new Booking
                        {
                            Id = 54321,
                            BookingReferenceNumber = "B321"
                        }
                    };

                bookingDao.Setup(x => x.GetBetweenDates(businessId, startDate, endDate, It.IsAny<string>())).Returns(bookingData);

                // Act        
                var bookings = diaryDataRetrievalMgr.GetBookingsByBusinessBetweenDates(businessId, startDate, endDate);

                // Assert
                Assert.AreEqual(2, bookings.Count, "Check that correct number of bookings are returned.");
                bookingDao.Verify(x => x.GetBetweenDates(businessId, startDate, endDate, It.IsAny<string>()), Times.Once);
            }
            public void GetCloseoutReasonsFoLangaugeTranslationDoesNonExist()
            {
               
                var langauages = new List<string> { "En-GB" };
                var reasons = new List<CloseoutReason>
                {
                    new CloseoutReason() {Id = 12345, Name = "test1"}
                };
                
                var closeoutReasonDaoStub = new Mock<ICloseoutReasonDao>();
                closeoutReasonDaoStub.Setup(y => y.GetAllActive(It.IsAny<CloseoutReasonType>()))
                    .Returns(reasons);
                var dictionaryStub = new Mock<IDictionaryManager>();
                dictionaryStub.Setup(
                    x => x.GetDictionaryItemByKeysAndCultures(It.IsAny<List<string>>(), It.IsAny<List<string>>()))
                    .Returns(new List<DictionaryDataItem>()
                   );
                dictionaryStub.Setup(
                    x => x.DictionaryInstanceToContentByCulture(It.IsAny<List<DictionaryInstance>>(), It.IsAny<string>()))
                    .Returns(string.Empty);


                var manager = new DiaryDataRetrievalManager
                {
                    CloseoutReasonDao = closeoutReasonDaoStub.Object
                    ,
                    DictionaryManager = dictionaryStub.Object
                };

                var closeoutReasons = manager.GetCloseoutReasons(new CloseoutReasonType(), langauages[0]);

                Assert.AreEqual(closeoutReasons[0].Name, string.Empty, "Check that the items name is null is correct.");
            }
            public void GetCloseoutReasonsForLangauge()
            {
                var reasons = new List<CloseoutReason>
                {
                    new CloseoutReason() {Id = 12345, Name = "test1"},
                    new CloseoutReason() {Id = 67890, Name = "test2"}
                };
                var checkItem = new DictionaryDataItem { Id = (int) reasons[0].Id };
               
                var closeoutReasonDaoStub = new Mock<ICloseoutReasonDao>();
                closeoutReasonDaoStub.Setup(y => y.GetAllActive(It.IsAny<CloseoutReasonType>()))
                    .Returns(reasons);
                var dictionaryStub = new Mock<IDictionaryManager>();
                dictionaryStub.Setup(
                    x => x.GetDictionaryItemByKeysAndCultures(new List<string> { reasons[0].Name }, It.IsAny<List<string>>()))
                    .Returns(new List<DictionaryDataItem>
                    {
                       checkItem
                    });
                dictionaryStub.Setup(
                    x => x.DictionaryInstanceToContentByCulture(It.IsAny<List<DictionaryInstance>>(), It.IsAny<string>()))
                    .Returns(reasons[0].Name);


                var manager = new DiaryDataRetrievalManager
                {
                    CloseoutReasonDao = closeoutReasonDaoStub.Object
                    ,
                    DictionaryManager = dictionaryStub.Object
                };

                var closeoutReasons = manager.GetCloseoutReasons(new CloseoutReasonType(), "En-GB");

                Assert.AreEqual(closeoutReasons[0].Id, checkItem.Id, "Check that the items id is correct.");
            }
            public void GetEmptyCloseoutReasons()
            {
                const CloseoutReasonType REASON_TYPE = CloseoutReasonType.Allocation;
                var closeoutReasonDaoStub = new Mock<ICloseoutReasonDao>();
                closeoutReasonDaoStub.Setup(y => y.GetAllActive(REASON_TYPE))
                    .Returns(new List<CloseoutReason>());
                var dictionaryStub = new Mock<IDictionaryManager>();
                dictionaryStub.Setup(
                    x => x.GetDictionaryItemByKeysAndCultures(It.IsAny<List<string>>(), It.IsAny<List<string>>()))
                    .Returns(new List<DictionaryDataItem>
                    {
                        new DictionaryDataItem {Id=12345}
                    });

                var manager = new DiaryDataRetrievalManager
                {
                    CloseoutReasonDao = closeoutReasonDaoStub.Object
                    ,DictionaryManager = dictionaryStub.Object
                };             

                var closeoutReasons = manager.GetCloseoutReasons(REASON_TYPE, "En-GB");

                Assert.AreEqual(0, closeoutReasons.Count, "Check that correct number of Closeout reasons are returned.");
            }
            public void SelectByBusinessBetweenDatesValidDatesReturnsDiaryNotes()
            {
                // Arrange
                // Parameters for the invoke
                var startDate = new DateTime(2012, 1, 1, 0, 0, 0, DateTimeKind.Utc);
                var endDate = new DateTime(2012, 1, 5, 0, 0, 0, DateTimeKind.Utc);
                const long BUSINESS_ID = 1;

                var diaryNoteDao = new Mock<IDiaryNoteDao>();

                var diaryDataRetrievalMgr = new DiaryDataRetrievalManager
                {
                    DiaryNoteDao = diaryNoteDao.Object
                };

                // Create a list with 2 entries
                var diaryNoteData = new List<DiaryNote>()
                                                    {
                                                        new DiaryNote()
                                                            {
                                                                Id = 12345
                                                            },
                                                        new DiaryNote()
                                                            {
                                                                Id = 54321
                                                            }
                                                    };

                diaryNoteDao.Setup(x => x.GetBetweenDates(BUSINESS_ID, startDate, endDate)).Returns(diaryNoteData);

                // Act
                var diaryNotesResult = diaryDataRetrievalMgr.GetDiaryNotesByBusinessBetweenDates(BUSINESS_ID, startDate, endDate);
                // Assert
                // Check expectations tests
                Assert.AreEqual(diaryNoteData.Count, diaryNotesResult.Count,
                    "Check that correct number of Diary Notes are returned.");

                diaryNoteDao.Verify(d => d.GetBetweenDates(BUSINESS_ID, startDate, endDate), Times.Once());
            }
            public void GetDiaryNotesByBusinessBetweenDatesForInvalidDatesThrowsException()
            {
                // Arrange
                DateTime startDate = new DateTime(2012, 1, 5, 0, 0, 0, DateTimeKind.Utc);
                DateTime endDate = new DateTime(2012, 1, 2, 0, 0, 0, DateTimeKind.Utc);
                long businessId = 3;
                var diaryNoteDao = new Mock<IDiaryNoteDao>();

                var diaryDataRetrievalMgr = new DiaryDataRetrievalManager
                {
                    DiaryNoteDao = diaryNoteDao.Object
                };

                // act
                CheckForEviivoException<ValidationException>(() => diaryDataRetrievalMgr.GetCloseoutsByBusinessBetweenDates(businessId, startDate, endDate), "Wrong dates did not throw correct error code.", "SRVEX30002");

                // assert
                diaryNoteDao.Verify(
                    c => c.GetBetweenDates(It.IsAny<long>(), It.IsAny<DateTime>(), It.IsAny<DateTime>()),
                    Times.Never());
            }
            public void GetCloseoutsByBusinessBetweenDatesValidDatesReturnsCloseouts()
            {
                // Arrange
                // Parameters for the invoke
                var startDate = new DateTime(2012, 1, 1, 0, 0, 0, DateTimeKind.Utc);
                var endDate = new DateTime(2012, 1, 5, 0, 0, 0, DateTimeKind.Utc);
                long businessId = 1;

                var closeoutDao = new Mock<ICloseoutDao>();

                var diaryDataRetrievalMgr = new DiaryDataRetrievalManager
                {
                    CloseoutDao = closeoutDao.Object
                };

                // Create a list with 2 entries
                var closeouts = new List<Closeout>
                    {
                        new Closeout { Id = 12345 },
                        new Closeout { Id = 54321 }
                    };

                closeoutDao.Setup(x => x.GetBetweenDates(businessId, startDate, endDate)).Returns(closeouts);

                // Act
                var resultCloseouts = diaryDataRetrievalMgr.GetCloseoutsByBusinessBetweenDates(businessId, startDate, endDate);

                // Assert
                // Check expectations tests
                Assert.AreEqual(closeouts.Count,
                    resultCloseouts.Count,
                    "Check that correct number of Checkouts are returned.");
                closeoutDao.Verify(c => c.GetBetweenDates(businessId, startDate, endDate), Times.Once);
            }