Exemple #1
0
        public async Task <MemeRating> FetchRating(MemeReaction reaction)
        {
            var rating = await _context.MemeRatings
                         .FirstOrDefaultAsync(r =>
                                              r.MemeId == reaction.MemeId && r.UserId == reaction.UserId);

            if (rating == null)
            {
                rating = new MemeRating()
                {
                    UserId = reaction.UserId,
                    MemeId = reaction.MemeId,
                };
                await _context.MemeRatings.AddAsync(rating);
            }
            return(rating);
        }
Exemple #2
0
        private IBgcMemeRepository CreateMockRepository(MemeReaction reaction, sbyte vote)
        {
            var mockRepo = Substitute.For <IBgcMemeRepository>();

            mockRepo.DrawMeme(1)
            .Returns(Task.FromResult(new Meme()
            {
                Id     = 1,
                Rating = 0,
            }));
            mockRepo.FetchRating(reaction)
            .Returns(Task.FromResult(new MemeRating()
            {
                MemeId = reaction.MemeId,
                UserId = reaction.UserId,
                Vote   = vote
            }));
            return(mockRepo);
        }
        public async Task MemeReaction_DbIntegration()
        {
            using (var contextProvider = new EFInMemoryDbCreator.Sqlite <BgcFullContext>())
            {
                // arrange
                var context  = contextProvider.CreateContext(c => c.SeedUsers(1).SeedMemes(10));
                var repo     = new BgcMemeRepo(context);
                var sessions = new BgcSessionsRepo(context);

                var controller = new MemeListController(repo, sessions);
                var reaction   = new MemeReaction()
                {
                    MemeId = _random.Next(1, EFInMemoryDbCreator.MemeCount),
                    UserId = 1,
                    Vote   = (sbyte)(_random.Next(0, 10) % 2 == 0 ? -1 : 1)
                };
                var mRating = (await repo.DrawMeme(reaction.MemeId)).Rating;


                // act
                var outcome = await controller.MemeReaction(reaction);

                // fresh context
                repo = new BgcMemeRepo(contextProvider.GetFreshContext());

                // prepare assert
                var rating = await repo.FetchRating(reaction);

                var meme2 = await repo.DrawMeme(reaction.MemeId);

                // assert
                Assert.AreEqual(reaction.Vote, rating.Vote);
                Assert.AreNotEqual(meme2.Rating, mRating);
                mRating += reaction.Vote;
                Assert.AreEqual(mRating, meme2.Rating);
                Assert.AreEqual(outcome.Rating, meme2.Rating);
                Assert.AreEqual(1, rating.Id);
            }
        }
        public async Task <MemeState> MemeReaction([FromBody] MemeReaction reaction)
        {
            if (ModelState.IsValid == false)
            {
                return(null);
            }

            var meme = await _repo.DrawMeme(reaction.MemeId);

            var earlierRating = await _repo.FetchRating(reaction);

            // prevent forgering of likes without client
            if (reaction.Vote == earlierRating.Vote)
            {
                return(null);
            }
            // add rating
            if (reaction.Vote != 0)
            {
                meme.Rating       += reaction.Vote - earlierRating.Vote;
                earlierRating.Vote = reaction.Vote;
            }
            // remove previous, user undid his rating
            else
            {
                meme.Rating -= earlierRating.Vote;
                _repo.DeleteRating(earlierRating);
            }

            _repo.SaveChanges();

            return(new MemeState()
            {
                CommentCount = meme.CommentCount,
                Rating = meme.Rating,
                Vote = reaction.Vote
            });
        }