Example #1
0
        public void AddPending_ShouldThrowWhenInvalidMemberIsPassed()
        {
            var membersRepoMock = new Mock <IEfRepostory <Member> >();
            var unitOfWorkStub  = new Mock <IUnitOfWork>();
            var sut             = new MemberService(membersRepoMock.Object, unitOfWorkStub.Object);

            var workout = new PendingWorkout();

            Assert.Throws <ArgumentException>(() => sut.AddPending(null, workout));
        }
Example #2
0
        public void MarkPendingAsCompleted(PendingWorkout pendingWorkout)
        {
            if (pendingWorkout == null)
            {
                throw new ArgumentException("PendingWorkout cannot be null");
            }

            pendingWorkout.IsCompleted = true;
            this.Update(pendingWorkout);
        }
Example #3
0
        public void AddPending(PendingWorkout pendingWorkout)
        {
            if (pendingWorkout == null)
            {
                throw new ArgumentException("PendingWorkout cannot be null");
            }

            this.pendingWorkoutsRepo.Add(pendingWorkout);
            this.unitOfWork.Commit();
        }
Example #4
0
        public void AddPending_ShouldAddWorkoutToMemberPendingWorkouts()
        {
            var membersRepoMock = new Mock <IEfRepostory <Member> >();
            var unitOfWorkStub  = new Mock <IUnitOfWork>();
            var sut             = new MemberService(membersRepoMock.Object, unitOfWorkStub.Object);

            var pendingWorkout = new PendingWorkout();
            var member         = new Member();

            sut.AddPending(member, pendingWorkout);

            Assert.AreEqual(1, member.PendingWorkouts.Count);
            Assert.AreSame(pendingWorkout, member.PendingWorkouts.First());
        }
Example #5
0
        public void AddPending(Member member, PendingWorkout workout)
        {
            if (member == null)
            {
                throw new ArgumentException("Member cannot be null");
            }

            if (workout == null)
            {
                throw new ArgumentException("Workout cannot be null");
            }

            member.PendingWorkouts.Add(workout);
            this.Update(member);
        }
Example #6
0
        public void MarkPendingAsCompleted_ShouldCallUnitOfWorkCommitOnce()
        {
            var pendingWorkoutsStub = new Mock <IEfRepostory <PendingWorkout> >();
            var unitOfWorkStub      = new Mock <IUnitOfWork>();

            var sut = new PendingWorkoutService(pendingWorkoutsStub.Object, unitOfWorkStub.Object);

            pendingWorkoutsStub.Setup(x => x.Update(It.IsAny <PendingWorkout>()));
            unitOfWorkStub.Setup(x => x.Commit());

            var workout = new PendingWorkout();

            sut.MarkPendingAsCompleted(workout);

            unitOfWorkStub.Verify(x => x.Commit(), Times.Once);
        }
Example #7
0
        public void MarkPendingAsCompleted_ShouldMarkTheWorkoutAsCompleted()
        {
            var pendingWorkoutsStub = new Mock <IEfRepostory <PendingWorkout> >();
            var unitOfWorkStub      = new Mock <IUnitOfWork>();

            var sut = new PendingWorkoutService(pendingWorkoutsStub.Object, unitOfWorkStub.Object);

            pendingWorkoutsStub.Setup(x => x.Update(It.IsAny <PendingWorkout>()));
            unitOfWorkStub.Setup(x => x.Commit());

            var workout = new PendingWorkout();

            sut.MarkPendingAsCompleted(workout);

            Assert.AreEqual(true, workout.IsCompleted);
        }
Example #8
0
        public void AddPending_ShouldCallUnitOfWorkCommitOnce()
        {
            var pendingWorkoutsStub = new Mock <IEfRepostory <PendingWorkout> >();
            var unitOfWorkStub      = new Mock <IUnitOfWork>();

            var sut = new PendingWorkoutService(pendingWorkoutsStub.Object, unitOfWorkStub.Object);

            pendingWorkoutsStub.Setup(x => x.Update(It.IsAny <PendingWorkout>()));
            unitOfWorkStub.Setup(x => x.Commit());

            var exercise = new PendingWorkout();

            sut.AddPending(exercise);

            unitOfWorkStub.Verify(x => x.Commit(), Times.Once);
        }
Example #9
0
        public void Update_ShouldCallRepoUpdateOnceWithCorrectExercise()
        {
            var pendingWorkoutsStub = new Mock <IEfRepostory <PendingWorkout> >();
            var unitOfWorkStub      = new Mock <IUnitOfWork>();

            var sut = new PendingWorkoutService(pendingWorkoutsStub.Object, unitOfWorkStub.Object);

            pendingWorkoutsStub.Setup(x => x.Update(It.IsAny <PendingWorkout>()));
            unitOfWorkStub.Setup(x => x.Commit());

            var workout = new PendingWorkout();

            sut.Update(workout);

            pendingWorkoutsStub.Verify(x => x.Update(workout), Times.Once);
        }
Example #10
0
        public void AddPending_ShouldCallUnitOfWorkCommitOnce()
        {
            var membersRepoMock = new Mock <IEfRepostory <Member> >();
            var unitOfWorkStub  = new Mock <IUnitOfWork>();
            var sut             = new MemberService(membersRepoMock.Object, unitOfWorkStub.Object);

            membersRepoMock.Setup(x => x.Update(It.IsAny <Member>()));
            unitOfWorkStub.Setup(x => x.Commit());

            var pendingWorkout = new PendingWorkout();
            var member         = new Member();

            sut.AddPending(member, pendingWorkout);

            unitOfWorkStub.Verify(x => x.Commit(), Times.Once);
        }
Example #11
0
        public void Complete_ShouldRedirectToCorrectActionWhenModelIsValid()
        {
            var memberIdProviderStub      = new Mock <IMemberIdProvider>();
            var memberServiceStub         = new Mock <IMemberService>();
            var mapperStub                = new Mock <IMapper>();
            var pendingWorkoutServiceStub = new Mock <IPendingWorkoutService>();
            var modelViewFactoryStub      = new Mock <IModelViewFactory>();
            var dataModelFactoryStub      = new Mock <IDataModelFactory>();

            var sut = new CompleteWorkoutController(memberIdProviderStub.Object,
                                                    memberServiceStub.Object,
                                                    mapperStub.Object,
                                                    pendingWorkoutServiceStub.Object,
                                                    modelViewFactoryStub.Object,
                                                    dataModelFactoryStub.Object);

            var model = new CompleteViewModel();

            model.Id      = new Guid();
            model.Minutes = 15;
            model.Seconds = 10;
            var pending = new PendingWorkout();

            pending.Member       = new Member();
            pending.DailyWorkout = new DailyWorkout
            {
                WorkoutInformation = new WorkoutInformation()
            };

            var workout = new Workout();

            pendingWorkoutServiceStub.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(pending);
            pendingWorkoutServiceStub.Setup(x => x.MarkPendingAsCompleted(It.IsAny <PendingWorkout>()));
            dataModelFactoryStub.Setup(x => x.CreateWorkout()).Returns(workout);
            memberServiceStub.Setup(x => x.AddWorkout(It.IsAny <Member>(), It.IsAny <Workout>()));


            sut
            .WithCallTo(c => c.Complete(model))
            .ShouldRedirectTo(c => c.All());
        }
Example #12
0
        public void GetById_ShouldReturnCorrectEntryWhenIdMatchesThePasedId()
        {
            var pendingWorkoutsStub = new Mock <IEfRepostory <PendingWorkout> >();
            var unitOfWorkStub      = new Mock <IUnitOfWork>();

            var list    = new List <PendingWorkout>();
            var workout = new PendingWorkout();

            list.Add(workout);

            var dbSetStub = list.AsQueryable();

            var sut = new PendingWorkoutService(pendingWorkoutsStub.Object, unitOfWorkStub.Object);

            pendingWorkoutsStub.Setup(x => x.All).Returns(dbSetStub);

            var result = sut.GetById(workout.Id);

            Assert.IsNotNull(result);
            Assert.IsInstanceOf <PendingWorkout>(result);
            Assert.AreSame(result, workout);
        }
Example #13
0
        public void GetById_ShouldReturnNullWhenNoEntryMatchesTheId()
        {
            var pendingWorkoutsStub = new Mock <IEfRepostory <PendingWorkout> >();
            var unitOfWorkStub      = new Mock <IUnitOfWork>();

            var list    = new List <PendingWorkout>();
            var workout = new PendingWorkout();

            list.Add(workout);

            var dbSetStub = list.AsQueryable();

            var sut = new PendingWorkoutService(pendingWorkoutsStub.Object, unitOfWorkStub.Object);

            pendingWorkoutsStub.Setup(x => x.All).Returns(dbSetStub);

            var newId = new Guid();

            var result = sut.GetById(newId);

            Assert.IsNull(result);
        }