コード例 #1
0
        public async Task TestCancelAsync_WithIncorrectWorkoutId_ShouldThrowNullRefEx()
        {
            var testUserId   = "testUserId";
            var testUserName = "******";

            var user = new TrainConnectedUser()
            {
                Id       = testUserId,
                UserName = testUserName,
            };

            await this.usersRepository.AddAsync(user);

            await this.usersRepository.SaveChangesAsync();

            var workoutActivity = new WorkoutActivity()
            {
                Id   = "activityId1",
                Name = "activityName1",
                Icon = "iconUrl1",
            };

            await this.workoutActivityRepository.AddAsync(workoutActivity);

            await this.workoutActivityRepository.SaveChangesAsync();

            var paymentMethod = new PaymentMethod()
            {
                Id               = "activityId1",
                Name             = "activityName1",
                PaymentInAdvance = false,
            };

            await this.paymentMethodsRepository.AddAsync(paymentMethod);

            await this.paymentMethodsRepository.SaveChangesAsync();

            WorkoutCreateInputModel workoutCreateInputModel = new WorkoutCreateInputModel()
            {
                Activity        = workoutActivity.Name,
                Duration        = 15,
                Location        = "location1",
                MaxParticipants = 10,
                Price           = 10.50m,
                Time            = DateTime.Now.AddDays(1),
                PaymentMethods  = new List <string>()
                {
                    paymentMethod.Name
                },
            };

            await this.workoutsService.CreateAsync(workoutCreateInputModel, testUserId);

            var createdWorkout = await this.workoutsRepository.All()
                                 .FirstOrDefaultAsync();

            var incorrectWorkoutId = "incorrect" + createdWorkout.Id;

            await Assert.ThrowsAsync <NullReferenceException>(async() => await this.workoutsService.CancelAsync(incorrectWorkoutId, testUserId));
        }
        public async Task TestUpdateAsync_WithIncorrectId_ShouldThrowNullRefEx()
        {
            var testActivityId         = "testActivityId";
            var incorrectActivityId    = "incorrectActivityId";
            var testInitialName        = "testInitialName";
            var testUpdatedName        = "testUpdatedName";
            var testInitialDescription = "testInitialDescription";
            var testUpdatedDescription = "testUpdatedDescription";

            var workoutActivity = new WorkoutActivity
            {
                Id          = testActivityId,
                Name        = testInitialName,
                Description = testInitialDescription,
                Icon        = "ActivityIconUrl",
            };

            await this.workoutActivitiesRepository.AddAsync(workoutActivity);

            await this.workoutActivitiesRepository.SaveChangesAsync();

            var workoutActivityEditInputModel = new WorkoutActivityEditInputModel()
            {
                Id          = incorrectActivityId,
                Name        = testUpdatedName,
                Description = testUpdatedDescription,
            };

            await Assert.ThrowsAsync <NullReferenceException>(async() => await this.workoutActivitiesService.UpdateAsync(workoutActivityEditInputModel));
        }
コード例 #3
0
        public async Task <WorkoutActivityDetailsViewModel> CreateAsync(WorkoutActivityServiceModel workoutActivityServiceModel)
        {
            var checkActivityExists = this.workoutActivitiesRepository.All()
                                      .FirstOrDefault(x => x.Name == workoutActivityServiceModel.Name);

            if (checkActivityExists != null)
            {
                return(AutoMapper.Mapper.Map <WorkoutActivityDetailsViewModel>(checkActivityExists));
            }

            var workoutActivity = new WorkoutActivity
            {
                Name        = workoutActivityServiceModel.Name,
                Description = workoutActivityServiceModel.Description,
                Icon        = workoutActivityServiceModel.Icon,
            };

            await this.workoutActivitiesRepository.AddAsync(workoutActivity);

            await this.workoutActivitiesRepository.SaveChangesAsync();

            var workoutActivityDetailsViewModel = AutoMapper.Mapper.Map <WorkoutActivityDetailsViewModel>(workoutActivity);

            return(workoutActivityDetailsViewModel);
        }
コード例 #4
0
        public async Task TestUpdateAsync_WithIncorrectUser_ShouldThrowArgEx()
        {
            var testUserId        = "testUserId1";
            var incorrectUserId   = "incorrectUserId";
            var testCertificateId = "testCertificateId";
            var testIssuedBy      = "TestOrganization1";
            var testActivityName  = "activityName1";
            var updatedIssuedById = "TestOrganization2";

            var workoutActivity = new WorkoutActivity()
            {
                Id          = "testId1",
                Name        = testActivityName,
                Icon        = "testIconUrl1",
                Description = "TestDescription1",
            };

            await this.workoutActivityRepository.AddAsync(workoutActivity);

            await this.workoutActivityRepository.SaveChangesAsync();

            var testUser = new TrainConnectedUser()
            {
                Id = testUserId,
            };

            var incorrectTestUser = new TrainConnectedUser()
            {
                Id = incorrectUserId,
            };

            await this.usersRepository.AddAsync(testUser);

            await this.usersRepository.AddAsync(incorrectTestUser);

            await this.usersRepository.SaveChangesAsync();

            var certificate = new Certificate()
            {
                Id = testCertificateId,
                TrainConnectedUserId = testUserId,
                ActivityId           = "testId1",
                Description          = "TestDescriptionForTesting1",
                IssuedBy             = testIssuedBy,
                Activity             = workoutActivity,
                IssuedOn             = DateTime.Now.AddDays(-5),
            };

            await this.certificatesRepository.AddAsync(certificate);

            await this.certificatesRepository.SaveChangesAsync();

            var certificateEditInputModel = AutoMapper.Mapper.Map <CertificateEditInputModel>(certificate);

            certificateEditInputModel.IssuedBy = updatedIssuedById;

            await Assert.ThrowsAsync <ArgumentException>(async() => await this.certificatesService.UpdateAsync(certificateEditInputModel, incorrectUserId));
        }
コード例 #5
0
        public async Task TestUpdateAsync_WithTestData_ShouldUpdateCertificate()
        {
            var testUserId        = "testUserId1";
            var testCertificateId = "testCertificateId";
            var testIssuedBy      = "TestOrganization1";
            var testActivityName  = "activityName1";
            var updatedIssuedById = "TestOrganization2";

            var workoutActivity = new WorkoutActivity()
            {
                Id          = "testId1",
                Name        = testActivityName,
                Icon        = "testIconUrl1",
                Description = "TestDescription1",
            };

            await this.workoutActivityRepository.AddAsync(workoutActivity);

            await this.workoutActivityRepository.SaveChangesAsync();

            var testUser = new TrainConnectedUser()
            {
                Id = testUserId,
            };

            await this.usersRepository.AddAsync(testUser);

            await this.usersRepository.SaveChangesAsync();

            var certificate = new Certificate()
            {
                Id = testCertificateId,
                TrainConnectedUserId = testUserId,
                ActivityId           = "testId1",
                Description          = "TestDescriptionForTesting1",
                IssuedBy             = testIssuedBy,
                Activity             = workoutActivity,
                IssuedOn             = DateTime.Now.AddDays(-5),
            };

            await this.certificatesRepository.AddAsync(certificate);

            await this.certificatesRepository.SaveChangesAsync();

            var certificateEditInputModel = AutoMapper.Mapper.Map <CertificateEditInputModel>(certificate);

            certificateEditInputModel.IssuedBy = updatedIssuedById;

            await this.certificatesService.UpdateAsync(certificateEditInputModel, testUserId);

            var actualResult = await this.certificatesRepository.All()
                               .Where(u => u.TrainConnectedUserId == testUserId)
                               .FirstOrDefaultAsync();

            Assert.Equal(updatedIssuedById, actualResult.IssuedBy);
        }
コード例 #6
0
        public async Task TestDeleteAsync_WithIncorrectUserId_ShouldThrowArgEx()
        {
            var testUserId        = "testUserId1";
            var incorrectUserId   = "incorrectUserId";
            var testCertificateId = "testCertificateId";
            var testIssuedBy      = "TestOrganization1";
            var testActivityName  = "activityName1";

            var workoutActivity = new WorkoutActivity()
            {
                Id          = "testId1",
                Name        = testActivityName,
                Icon        = "testIconUrl1",
                Description = "TestDescription1",
            };

            await this.workoutActivityRepository.AddAsync(workoutActivity);

            await this.workoutActivityRepository.SaveChangesAsync();

            var testUser = new TrainConnectedUser()
            {
                Id = testUserId,
            };

            var incorrectUser = new TrainConnectedUser()
            {
                Id = incorrectUserId,
            };

            await this.usersRepository.AddAsync(testUser);

            await this.usersRepository.AddAsync(incorrectUser);

            await this.usersRepository.SaveChangesAsync();

            var certificate = new Certificate()
            {
                Id = testCertificateId,
                TrainConnectedUserId = testUserId,
                ActivityId           = "testId1",
                Description          = "TestDescriptionForTesting1",
                IssuedBy             = testIssuedBy,
                Activity             = workoutActivity,
                IssuedOn             = DateTime.Now.AddDays(-5),
            };

            await this.certificatesRepository.AddAsync(certificate);

            await this.certificatesRepository.SaveChangesAsync();

            Assert.NotEmpty(await this.certificatesRepository.All().ToArrayAsync());

            await Assert.ThrowsAsync <ArgumentException>(async() => await this.certificatesService.DeleteAsync(testCertificateId, incorrectUserId));
        }
コード例 #7
0
        public async Task Handle(ActivityCompleted notification, CancellationToken cancellationToken)
        {
            Workout workout = await GetWorkoutAsync(notification.UserId, notification.WorkoutId);

            var activity = new Activity(notification.WorkoutId, notification.ActivityId)
            {
                WorkoutStarted = workout.StartDateTime,
                ExerciseId     = notification.ExerciseId,
                Added          = notification.Added,
                UserId         = notification.UserId,
                Sets           = notification.Sets?.ToArray(),
                Rating         = notification.Rating
            };
            await _activityTableHandler.InsertOrReplace(activity);

            var exercises = await _exerciseRepository.GetAllExercisesAsync();

            var workoutActivity = new WorkoutActivity
            {
                ActivityId   = notification.ActivityId,
                Added        = notification.Added,
                ExerciseId   = notification.ExerciseId,
                SetCount     = notification.Sets.Count(),
                ExerciseName = exercises.SingleOrDefault(s => s.Id == notification.ExerciseId).Name,
            };
            var activities    = workout.Activities.ToList();
            var existingIndex = activities.Select((x, idx) => new { x.ActivityId, idx })
                                .Where(p => p.ActivityId == notification.ActivityId)
                                .Select(p => p.idx + 1)
                                .FirstOrDefault() - 1;

            if (existingIndex == -1)
            {
                activities.Add(workoutActivity);
            }
            else
            {
                activities[existingIndex] = workoutActivity;
            }
            workout.Activities    = activities.ToArray();
            workout.ActivityCount = workout.Activities.Count();
            workout.Version       = notification.Version;
            await _workoutTableHandler.InsertOrReplace(workout);
        }
        public async Task TestUpdateAsync_WithDuplicateName_ShouldThrowInvOpEx()
        {
            var testActivityId         = "testActivityId";
            var testInitialName        = "testInitialName";
            var testUpdatedName        = "testUpdatedName";
            var testInitialDescription = "testInitialDescription";
            var testUpdatedDescription = "testUpdatedDescription";

            await this.workoutActivitiesRepository.AddAsync(new WorkoutActivity()
            {
                Id          = "testId",
                Name        = testUpdatedName,
                Description = testUpdatedDescription,
            });

            await this.workoutActivitiesRepository.SaveChangesAsync();

            var workoutActivity = new WorkoutActivity
            {
                Id          = testActivityId,
                Name        = testInitialName,
                Description = testInitialDescription,
                Icon        = "ActivityIconUrl",
            };

            await this.workoutActivitiesRepository.AddAsync(workoutActivity);

            await this.workoutActivitiesRepository.SaveChangesAsync();

            var workoutActivityEditInputModel = new WorkoutActivityEditInputModel()
            {
                Id          = testActivityId,
                Name        = testUpdatedName,
                Description = testUpdatedDescription,
            };

            await Assert.ThrowsAsync <InvalidOperationException>(async() => await this.workoutActivitiesService.UpdateAsync(workoutActivityEditInputModel));
        }
        public async Task TestUpdateAsync_WithTestData_ShouldUpdateWorkoutActivity()
        {
            var testActivityId         = "testActivityId";
            var testInitialName        = "testInitialName";
            var testUpdatedName        = "testUpdatedName";
            var testInitialDescription = "testInitialDescription";
            var testUpdatedDescription = "testUpdatedDescription";

            var workoutActivity = new WorkoutActivity
            {
                Id          = testActivityId,
                Name        = testInitialName,
                Description = testInitialDescription,
                Icon        = "ActivityIconUrl",
            };

            await this.workoutActivitiesRepository.AddAsync(workoutActivity);

            await this.workoutActivitiesRepository.SaveChangesAsync();

            var workoutActivityEditInputModel = new WorkoutActivityEditInputModel()
            {
                Id          = testActivityId,
                Name        = testUpdatedName,
                Description = testUpdatedDescription,
            };

            await this.workoutActivitiesService.UpdateAsync(workoutActivityEditInputModel);

            var result = await this.workoutActivitiesRepository.All()
                         .Where(wa => wa.Id == testActivityId)
                         .FirstOrDefaultAsync();

            Assert.Equal(testUpdatedName, result.Name);
            Assert.Equal(testUpdatedDescription, result.Description);
        }
コード例 #10
0
        public async Task TestCancelAsync_WithTestData_ShouldCancelWorkout()
        {
            var testUserId   = "testUserId";
            var testUserName = "******";

            var user = new TrainConnectedUser()
            {
                Id       = testUserId,
                UserName = testUserName,
            };

            await this.usersRepository.AddAsync(user);

            await this.usersRepository.SaveChangesAsync();

            var workoutActivity = new WorkoutActivity()
            {
                Id   = "activityId1",
                Name = "activityName1",
                Icon = "iconUrl1",
            };

            await this.workoutActivityRepository.AddAsync(workoutActivity);

            await this.workoutActivityRepository.SaveChangesAsync();

            var paymentMethod = new PaymentMethod()
            {
                Id               = "activityId1",
                Name             = "activityName1",
                PaymentInAdvance = false,
            };

            await this.paymentMethodsRepository.AddAsync(paymentMethod);

            await this.paymentMethodsRepository.SaveChangesAsync();

            WorkoutCreateInputModel workoutCreateInputModel = new WorkoutCreateInputModel()
            {
                Activity        = workoutActivity.Name,
                Duration        = 15,
                Location        = "location1",
                MaxParticipants = 10,
                Price           = 10.50m,
                Time            = DateTime.Now.AddDays(1),
                PaymentMethods  = new List <string>()
                {
                    paymentMethod.Name
                },
            };

            await this.workoutsService.CreateAsync(workoutCreateInputModel, testUserId);

            var initialResult = await this.workoutsRepository.All()
                                .ToArrayAsync();

            Assert.NotEmpty(initialResult);

            var workoutId = initialResult.FirstOrDefault().Id;

            await this.workoutsService.CancelAsync(workoutId, testUserId);

            var finalResult = await this.workoutsRepository.All()
                              .ToArrayAsync();

            Assert.Empty(finalResult);
        }
コード例 #11
0
        public async Task TestGetCancelDetailsAsync_WithTestData_ShouldReturnWorkoutDetails()
        {
            var testUserId   = "testUserId";
            var testUserName = "******";

            var user = new TrainConnectedUser()
            {
                Id       = testUserId,
                UserName = testUserName,
            };

            await this.usersRepository.AddAsync(user);

            await this.usersRepository.SaveChangesAsync();

            var workoutActivity = new WorkoutActivity()
            {
                Id   = "activityId1",
                Name = "activityName1",
                Icon = "iconUrl1",
            };

            await this.workoutActivityRepository.AddAsync(workoutActivity);

            await this.workoutActivityRepository.SaveChangesAsync();

            var paymentMethod = new PaymentMethod()
            {
                Id               = "activityId1",
                Name             = "activityName1",
                PaymentInAdvance = false,
            };

            await this.paymentMethodsRepository.AddAsync(paymentMethod);

            await this.paymentMethodsRepository.SaveChangesAsync();

            WorkoutCreateInputModel workoutCreateInputModel = new WorkoutCreateInputModel()
            {
                Activity        = workoutActivity.Name,
                Duration        = 15,
                Location        = "location1",
                MaxParticipants = 10,
                Price           = 10.50m,
                Time            = DateTime.Now.AddDays(1),
                PaymentMethods  = new List <string>()
                {
                    paymentMethod.Name
                },
            };

            await this.workoutsService.CreateAsync(workoutCreateInputModel, testUserId);

            var expectedResult = await this.workoutsRepository.All()
                                 .Where(w => w.CoachId == testUserId)
                                 .To <WorkoutCancelViewModel>()
                                 .FirstOrDefaultAsync();

            var workoutId = expectedResult.Id;

            var actualResult = await this.workoutsService.GetCancelDetailsAsync(workoutId, testUserId);

            Assert.Equal(expectedResult.ActivityName, actualResult.ActivityName);
            Assert.Equal(expectedResult.Duration, actualResult.Duration);
            Assert.Equal(expectedResult.Price, actualResult.Price);
            Assert.Equal(expectedResult.Location, actualResult.Location);
            Assert.Equal(expectedResult.MaxParticipants, actualResult.MaxParticipants);
            Assert.Equal(expectedResult.Time, actualResult.Time);
            Assert.Equal(expectedResult.Id, actualResult.Id);
        }