Exemplo n.º 1
0
        public async Task Return_WhenFeedbackIsNotDeleted()
        {
            var text   = "text";
            var author = "gosho";
            var rating = 5;

            var editedText   = "new text";
            var editedAuthor = "pesho";
            var editedRating = 4;
            var isDeleted    = false;

            var businessId = 1;
            var feedbackId = 1;

            var paginatedListMocked   = new Mock <IPaginatedList <FeedbackDTO> >();
            var dateTimeWrapperMocked = new Mock <IDateTimeWrapper>();
            var censorMocked          = new Mock <ICensor>();

            FeedbackTestUtils.GetContextWithFullFeedback(nameof(Return_WhenFeedbackIsNotDeleted), text, rating, author, businessId, feedbackId);

            using (var assertContext = new AlphaHotelDbContext(FeedbackTestUtils.GetOptions(nameof(Return_WhenFeedbackIsNotDeleted))))
            {
                var feedbackService = new FeedbackService(assertContext, paginatedListMocked.Object, dateTimeWrapperMocked.Object, censorMocked.Object);
                await feedbackService.EditFeedback(feedbackId, editedAuthor, editedText, editedRating, isDeleted);

                var feedback = await assertContext.Feedbacks.FirstOrDefaultAsync(f => f.Id == feedbackId);

                Assert.AreEqual(editedText, feedback.Text);
                Assert.AreEqual(editedRating, feedback.Rate);
                Assert.AreEqual(editedAuthor, feedback.Author);
                Assert.IsFalse(feedback.IsDeleted);
                Assert.AreEqual(feedback.ModifiedOn, dateTimeWrapperMocked.Object.Now());
            }
        }
        public async Task Return_WhenAllParametersArePassedAndAuthorIsAnonymous()
        {
            var feedbackText          = "text";
            var rating                = 5;
            var author                = "";
            var businessId            = 1;
            var paginatedListMocked   = new Mock <IPaginatedList <FeedbackDTO> >();
            var dateTimeWrapperMocked = new Mock <IDateTimeWrapper>();
            var censorMocked          = new Mock <ICensor>();

            FeedbackTestUtils.GetContextWithFullFeedbackAndAnonymousAuthor(nameof(Return_WhenAllParametersArePassedAndAuthorIsAnonymous), feedbackText, rating, author, businessId);

            using (var assertContext = new AlphaHotelDbContext(FeedbackTestUtils.GetOptions(nameof(Return_WhenAllParametersArePassedAndAuthorIsAnonymous))))
            {
                var feedbackService = new FeedbackService(assertContext, paginatedListMocked.Object, dateTimeWrapperMocked.Object, censorMocked.Object);
                await feedbackService.AddFeedbackAsync(feedbackText, rating, author, businessId);

                var feedback = await assertContext.Feedbacks.FirstOrDefaultAsync(s => s.BusinessId == businessId);

                Assert.AreEqual(feedbackText, feedback.Text);
                Assert.AreEqual(rating, feedback.Rate);
                Assert.AreEqual("Anonymous", feedback.Author);
                Assert.AreEqual(businessId, feedback.BusinessId);
                Assert.IsFalse(feedback.IsDeleted);
            }
        }
        public async Task ThrowException_WhenUserIsNotFound()
        {
            var userId = "userId";

            var userManagerWrapperMocked = new Mock <IUserManagerWrapper <User> >();
            var mappingProviderMocked    = new Mock <IMappingProvider>();
            var dateTimeWrapperMocked    = new Mock <IDateTimeWrapper>();

            //AccountTestUtils.GetContextWithUser(nameof(ThrowException_WhenUserIsNotFound), userId);

            using (var assertContext = new AlphaHotelDbContext(FeedbackTestUtils.GetOptions(nameof(ThrowException_WhenUserIsNotFound))))
            {
                var accountService = new AccountService(assertContext, userManagerWrapperMocked.Object, mappingProviderMocked.Object, dateTimeWrapperMocked.Object);

                await Assert.ThrowsExceptionAsync <ArgumentException>(
                    async() => await accountService.FindAccountAsync(userId));
            }
        }
        public async Task ListAllFeedbacksForUserAsync_CallCreateAsyncOnce()
        {
            var paginatedListMocked   = new Mock <IPaginatedList <FeedbackDTO> >();
            var dateTimeWrapperMocked = new Mock <IDateTimeWrapper>();
            var censorMocked          = new Mock <ICensor>();

            FeedbackTestUtils.ResetAutoMapper();
            FeedbackTestUtils.InitializeAutoMapper();
            //FeedbackTestUtils.GetContextWithBusiness(nameof(ListAllFeedbacksForUserAsync_CallCreateAsyncOnce), businessId, businessName);

            using (var assertContext = new AlphaHotelDbContext(FeedbackTestUtils.GetOptions(nameof(ListAllFeedbacksForUserAsync_CallCreateAsyncOnce))))
            {
                var feedbackService = new FeedbackService(assertContext, paginatedListMocked.Object, dateTimeWrapperMocked.Object, censorMocked.Object);
                await feedbackService.ListAllFeedbacksForUserAsync(It.IsAny <int>(), It.IsAny <int?>(), It.IsAny <int>());

                paginatedListMocked.Verify(pl => pl.CreateAsync(It.IsAny <IQueryable <FeedbackDTO> >(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>()), Times.Once);
            }
        }
Exemplo n.º 5
0
        public async Task ReturnFeedback_WhenFeedbackIsFound()
        {
            var id = 1;
            var paginatedListMocked   = new Mock <IPaginatedList <FeedbackDTO> >();
            var dateTimeWrapperMocked = new Mock <IDateTimeWrapper>();
            var censorMocked          = new Mock <ICensor>();

            FeedbackTestUtils.ResetAutoMapper();
            FeedbackTestUtils.InitializeAutoMapper();
            FeedbackTestUtils.GetContextWithFeedbackId(nameof(ReturnFeedback_WhenFeedbackIsFound), id);

            using (var assertContext = new AlphaHotelDbContext(FeedbackTestUtils.GetOptions(nameof(ReturnFeedback_WhenFeedbackIsFound))))
            {
                var feedbackService = new FeedbackService(assertContext, paginatedListMocked.Object, dateTimeWrapperMocked.Object, censorMocked.Object);

                var feedback = await feedbackService.FindFeedback(id);

                Assert.AreEqual(id, feedback.Id);
            }
        }
        public async Task ThrowException_WhenBusinessIsNotFound()
        {
            var text                  = "text";
            var rating                = 5;
            var author                = "gosho";
            var businessId            = 1;
            var wrongBusinessId       = 2;
            var feedbackId            = 1;
            var paginatedListMocked   = new Mock <IPaginatedList <FeedbackDTO> >();
            var dateTimeWrapperMocked = new Mock <IDateTimeWrapper>();
            var censorMocked          = new Mock <ICensor>();

            FeedbackTestUtils.GetContextWithFullFeedback(nameof(ThrowException_WhenBusinessIsNotFound), text, rating, author, businessId, feedbackId);

            using (var assertContext = new AlphaHotelDbContext(FeedbackTestUtils.GetOptions(nameof(ThrowException_WhenBusinessIsNotFound))))
            {
                var feedbackService = new FeedbackService(assertContext, paginatedListMocked.Object, dateTimeWrapperMocked.Object, censorMocked.Object);

                await Assert.ThrowsExceptionAsync <ArgumentException>(
                    async() => await feedbackService.AddFeedbackAsync(text, rating, author, wrongBusinessId));
            }
        }