public void Should_Be_Right_Challenges_When_Find_By_Accelartion_And_User(int accelerationId, int userId)
        {
            var fakeContext = new FakeContext("ChallengeByAccelerationAndUser");

            fakeContext.FillWithAll();

            using (var context = new CodenationContext(fakeContext.FakeOptions))
            {
                var expected = fakeContext.GetFakeData <User>().
                               Where(user => user.Id == userId).
                               Join(fakeContext.GetFakeData <Candidate>(),
                                    user => user.Id,
                                    candidate => candidate.UserId,
                                    (user, candidate) => candidate).
                               Join(fakeContext.GetFakeData <Acceleration>(),
                                    candidate => candidate.AccelerationId,
                                    acceleration => acceleration.Id,
                                    (candidate, acceleration) => acceleration).
                               Where(acceleration => acceleration.Id == accelerationId).
                               Join(fakeContext.GetFakeData <Models.Challenge>(),
                                    acceleration => acceleration.ChallengeId,
                                    challenge => challenge.Id,
                                    (acceleration, challenge) => challenge).
                               Distinct().
                               ToList();

                var service = new ChallengeService(context);
                var actual  = service.FindByAccelerationIdAndUserId(userId, accelerationId);

                Assert.Equal(expected, actual, new ChallengeIdComparer());
            }
        }
Exemplo n.º 2
0
        public void Should_Return_Right_Challenge_When_Find_By_Id(int accelerationId, int userId)
        {
            _contextoFake.FillWithAll();

            var userEsperado = _contextoFake.GetFakeData <Candidate>()
                               .Find(x => x.UserId == userId);

            // seleciona candidato por accelerationId e userId
            var candidateEsperado = _contextoFake.GetFakeData <Candidate>()
                                    .Find(x => x.AccelerationId == accelerationId && x.UserId == userId);

            // seleciona a aceleração de acordo com o que achamos anteriormente
            var accelerationEsperado = _contextoFake.GetFakeData <Acceleration>()
                                       .Find(x => x.Id == candidateEsperado.AccelerationId);

            // seleciona challenge de acordo com o que achamos anteriormente
            var challengeEsperado = _contextoFake.GetFakeData <Models.Challenge>()
                                    .Find(x => x.Id == accelerationEsperado.ChallengeId);

            var challengeReal = _challengeService.FindByAccelerationIdAndUserId(accelerationEsperado.Id, userEsperado.UserId);

            Assert.Equal(challengeEsperado.Id, challengeReal.FirstOrDefault().Id);
        }
        public void FindByAccelerationIdAndUserIdTest_Return_Right(int accelerationId, int userId
                                                                   , params int[] idChallengesExpected)
        {
            var fakeContext = new FakeContext("indByAccelerationIdAndUserIdTest");

            fakeContext.FillWith <User>();
            fakeContext.FillWith <Acceleration>();
            fakeContext.FillWith <Candidate>();
            fakeContext.FillWith <Models.Challenge>();

            using (var context = new CodenationContext(fakeContext.FakeOptions))
            {
                List <Models.Challenge> expected = new List <Models.Challenge>();
                foreach (var id in idChallengesExpected)
                {
                    expected.Add(fakeContext.GetFakeData <Models.Challenge>().Find(x => x.Id == id));
                }

                var service = new ChallengeService(context);
                var actual  = service.FindByAccelerationIdAndUserId(accelerationId, userId);

                Assert.Equal(expected, actual, new ChallengeIdComparer());
            }
        }