public void CallSignOut_FroMTripService_WithCorrectParamethers()
        {
            // Arrange
            var mockedTripRepo = new Mock<IProjectableRepositoryEf<Trip>>();
            var mockedUserTripRepo = new Mock<IProjectableRepositoryEf<UsersTrips>>();
            var mockedTripService = new Mock<ITripService>();
            var mockedUnitOfWork = new Mock<IUnitOfWorkEF>();

            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "userid";
            var tripId = 1;

            mockedTripService.Setup(x => x.SignOutOfTrip(tripId, userId));

            // Act
            service.RejectUserToJoinTrip(userId, tripId);

            // Assert
            mockedTripService.Verify(x => x.SignOutOfTrip(tripId, userId), Times.Once);
        }
        public void ReturnUpdatedTripInfo()
        {
            // Arrange
            var mockedTripRepo = new Mock<IProjectableRepositoryEf<Trip>>();
            var mockedUserTripRepo = new Mock<IProjectableRepositoryEf<UsersTrips>>();
            var mockedTripService = new Mock<ITripService>();
            var mockedUnitOfWork = new Mock<IUnitOfWorkEF>();

            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "userid";
            var tripId = 1;

            mockedTripService.Setup(x => x.SignOutOfTrip(tripId, userId));

            var expected = new TripInfoWithUserRequests();
            mockedTripRepo.Setup(x => x.GetFirstMapped<TripInfoWithUserRequests>(It.IsAny<Expression<Func<Trip, bool>>>()))
                .Returns(expected);

            // Act
            var result = service.RejectUserToJoinTrip(userId, tripId);

            // Assert
            mockedTripService.Verify(x => x.SignOutOfTrip(tripId, userId), Times.Once);
            Assert.AreSame(expected, result);
        }
Esempio n. 3
0
        public void IncrementTakenSeats()
        {
            // Arrange
            var mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            var mockedTripService  = new Mock <ITripService>();
            var mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();

            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "userId";
            int tripId = 1;

            var trip = new Trip()
            {
                Id = tripId, TotalSeats = 4, TakenSeats = 3
            };

            mockedTripService.Setup(x => x.IsUserOwnerOfTrip(userId, tripId)).Returns(false);
            mockedTripRepo.Setup(x => x.GetFirst(It.IsAny <Expression <Func <Trip, bool> > >()))
            .Returns(trip);

            var expectedSeats = trip.TakenSeats + 1;

            // Act
            service.JoinUserToTrip(userId, tripId);

            //Assert
            Assert.AreEqual(expectedSeats, trip.TakenSeats);
        }
Esempio n. 4
0
        public void ThrowInvalidOperationException_WhenTakenSeatsBecomeGreaterThanTheTotalSeats()
        {
            // Arrange
            var mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            var mockedTripService  = new Mock <ITripService>();
            var mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();

            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "userId";
            int tripId = 1;

            var trip = new Trip()
            {
                Id = tripId, TotalSeats = 4, TakenSeats = 4
            };

            mockedTripService.Setup(x => x.IsUserOwnerOfTrip(userId, tripId)).Returns(false);
            mockedTripRepo.Setup(x => x.GetFirst(It.IsAny <Expression <Func <Trip, bool> > >()))
            .Returns(trip);

            // Act and Assert
            Assert.Throws <InvalidOperationException>(() => service.JoinUserToTrip(userId, tripId));
        }
Esempio n. 5
0
        public void ReturnAnInstance_AndNotThrow_WhenAllArgumentsAreValid()
        {
            // Arrange
            var mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            var mockedTripService  = new Mock <ITripService>();
            var mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();

            // Act and Assert
            Assert.DoesNotThrow(() =>
            {
                var service = new UserDashboardService(
                    () => mockedUnitOfWork.Object,
                    mockedUserTripRepo.Object,
                    mockedTripService.Object,
                    mockedTripRepo.Object);
            });
        }
Esempio n. 6
0
        public void ThrowArgumentNullException_WithMessageContainingTripService_WhenTripServiceIsNull()
        {
            // Arrange
            var          mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var          mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            ITripService tripService        = null;
            var          mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();

            // Act and Assert
            Assert.That(() =>
            {
                var service = new UserDashboardService(
                    () => mockedUnitOfWork.Object,
                    mockedUserTripRepo.Object,
                    tripService,
                    mockedTripRepo.Object);
            },
                        Throws.ArgumentNullException.With.Message.Contain(nameof(tripService))
                        );
        }
Esempio n. 7
0
        public void ThrowInvalidOperationException_WhenUserIsAOwner()
        {
            // Arrange
            var mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            var mockedTripService  = new Mock <ITripService>();
            var mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();

            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "userId";
            int tripId = 1;

            mockedTripService.Setup(x => x.IsUserOwnerOfTrip(userId, tripId)).Returns(true);

            // Act and Assert
            Assert.Throws <InvalidOperationException>(() => service.JoinUserToTrip(userId, tripId));
        }
Esempio n. 8
0
        public void ReturnTheTrip_WhenJoiningToItWasSuccessfull()
        {
            // Arrange
            var mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            var mockedTripService  = new Mock <ITripService>();
            var mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();

            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "userId";
            int tripId = 1;

            var trip = new Trip()
            {
                Id = tripId, TotalSeats = 4, TakenSeats = 3
            };

            mockedTripService.Setup(x => x.IsUserOwnerOfTrip(userId, tripId))
            .Returns(false);

            mockedTripRepo.Setup(x => x.GetFirst(It.IsAny <Expression <Func <Trip, bool> > >()))
            .Returns(trip);

            var expected = new TripInfoWithUserRequests();

            mockedTripRepo.Setup(x => x.GetFirstMapped <TripInfoWithUserRequests>(It.IsAny <Expression <Func <Trip, bool> > >()))
            .Returns(expected);

            // Act
            var result = service.JoinUserToTrip(userId, tripId);

            //Assert
            Assert.AreSame(expected, result);
        }
        public void ReturnOnlyTripsCreatedByUser_ThatAreNotMarkedAsDeletedOrFinished()
        {
            // Arrange
            var mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            var mockedTripService  = new Mock <ITripService>();
            var mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();


            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "UserId";

            var trip = new Trip()
            {
                Id = 1, IsDeleted = false, IsFinished = false
            };
            var trip1 = new Trip()
            {
                Id = 2, IsDeleted = false, IsFinished = false
            };

            var trip2 = new Trip()
            {
                Id = 3, IsDeleted = true, IsFinished = false
            };
            var trip3 = new Trip()
            {
                Id = 4, IsDeleted = false, IsFinished = true
            };

            var data = new List <UsersTrips>()
            {
                new UsersTrips()
                {
                    TripId = 1, Trip = trip, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
                new UsersTrips()
                {
                    TripId = 2, Trip = trip1, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
                new UsersTrips()
                {
                    TripId = 3, Trip = trip2, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
                new UsersTrips()
                {
                    TripId = 4, Trip = trip3, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
            };


            mockedUserTripRepo.Setup(x => x.GetAll(It.IsAny <Expression <Func <UsersTrips, bool> > >(), It.IsAny <Expression <Func <UsersTrips, int> > >()))
            .Returns((Expression <Func <UsersTrips, bool> > predicate, Expression <Func <UsersTrips, int> > select) =>
            {
                return(data.Where(predicate.Compile()).Select(select.Compile()));
            });

            var tripsData = new List <Trip>()
            {
                trip, trip1, trip2, trip3
            };

            mockedTripRepo.Setup(x => x.GetAllMapped <TripInfoWithUserRequests>(It.IsAny <Expression <Func <Trip, bool> > >()))
            .Returns((Expression <Func <Trip, bool> > predicate) =>
            {
                return(tripsData.Where(predicate.Compile()).Select(x => new TripInfoWithUserRequests()
                {
                    Id = x.Id
                }));
            });

            var expectedCount = 2;

            // Act
            var result = service.GetTripsCreatedByUser(userId);

            // Assert
            Assert.AreEqual(expectedCount, result.Count());
        }
        public void ReturnEmpyCollection_WhenUserIsNotInAnyTrip()
        {
            // Arrange
            var mockedTripRepo     = new Mock <IProjectableRepositoryEf <Trip> >();
            var mockedUserTripRepo = new Mock <IProjectableRepositoryEf <UsersTrips> >();
            var mockedTripService  = new Mock <ITripService>();
            var mockedUnitOfWork   = new Mock <IUnitOfWorkEF>();

            var service = new UserDashboardService(
                () => mockedUnitOfWork.Object,
                mockedUserTripRepo.Object,
                mockedTripService.Object,
                mockedTripRepo.Object);

            var userId = "UserId";

            var trip = new Trip()
            {
                Id = 1, IsDeleted = false, IsFinished = false
            };
            var trip1 = new Trip()
            {
                Id = 2, IsDeleted = false, IsFinished = false
            };

            var trip2 = new Trip()
            {
                Id = 3, IsDeleted = true, IsFinished = false
            };
            var trip3 = new Trip()
            {
                Id = 4, IsDeleted = false, IsFinished = true
            };

            var data = new List <UsersTrips>()
            {
                new UsersTrips()
                {
                    TripId = 1, Trip = trip, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
                new UsersTrips()
                {
                    TripId = 2, Trip = trip1, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
                new UsersTrips()
                {
                    TripId = 3, Trip = trip2, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
                new UsersTrips()
                {
                    TripId = 4, Trip = trip3, UserId = userId, UserTripStatusId = (int)UserTripStatusType.Owner
                },
            };

            mockedUserTripRepo.Setup(x => x.GetAllMapped <TripBasicInfoWithStatus>(It.IsAny <Expression <Func <UsersTrips, bool> > >()))
            .Returns((Expression <Func <UsersTrips, bool> > predicate) =>
            {
                return(data.Where(predicate.Compile()).Select(x => new TripBasicInfoWithStatus()
                {
                    Id = x.TripId
                }));
            });

            var expectedCount = 0;

            // Act
            var result = service.GetTripsJoinedByUser(userId);

            // Assert
            Assert.AreEqual(expectedCount, result.Count());
        }