public async Task GetUsersSampleSetsByUserIDAsync_ShouldReturnUserSampleSets()
        {
            int id = 2;
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            var result = await projectRepoDB.GetUsersSampleSetsByUserIDAsync(id);

            Assert.Single(result);
        }
        public async Task GetUsersSampleSetsByIDAsync_ShouldReturnUserSampleSets()
        {
            int id = 1;
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            var result = await projectRepoDB.GetUsersSampleSetsByIDAsync(id);

            Assert.Equal(1, result.Id);
        }
        public async void GetPatternsAsyncShouldReturnAllPatterns()
        {
            using (var context = new ProjectDBContext(options))
            {
                IProjectRepoDB _repo = new ProjectRepoDB(context);

                var patterns = await _repo.GetPatternsAsync();

                Assert.Equal(2, patterns.Count);
            }
        }
        public async void AddPatternAsyncShouldAddPattern()
        {
            using (var context = new ProjectDBContext(options))
            {
                IProjectRepoDB _repo       = new ProjectRepoDB(context);
                Pattern        testPattern = new Pattern();
                testPattern.PatternData = "123";
                var newPattern = await _repo.AddPatternAsync(testPattern);

                Assert.Equal("123", newPattern.PatternData);
            }
        }
        public async Task GetTracksAsync_ShouldReturnTrack()
        {
            //arrange
            var           projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.GetTracksAsync();

            //assert
            Assert.Equal(2, result.Count);
        }
        public async Task GetUsersSampleSetsAsync_ShouldReturnUsersSampleSets()
        {
            //arrange
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.GetUsersSampleSetsAsync();

            //assert
            Assert.Equal(2, result.Count);
        }
        public async Task GetUsersSampleByUserIDAsync_ShouldReturnUsersSample()
        {
            //arrange
            int id = 1;
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.GetUsersSampleByUserIDAsync(id);

            Assert.Single(result);
        }
        public async Task GetSavedProjectByIDAsync_ShouldReturnSavedProject_WhenIDIsValid()
        {
            //arrange
            int id = 1;
            var projectDBContext = new ProjectDBContext(options);
            var projectrepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectrepoDB.GetSavedProjectByIDAsync(id);

            //assert
            Assert.Equal("test1", result.ProjectName);
        }
        public async Task GetTrackByIDAsync_ShouldReturnTrack()
        {
            //arrange
            int id = 1;
            var projectDBContext = new ProjectDBContext(options);
            var projectrepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectrepoDB.GetTrackByIDAsync(id);

            //assert
            Assert.Equal(1, result.ProjectId);
        }
        public async void GetPatternByIDAsyncShouldReturnPattern()
        {
            using (var context = new ProjectDBContext(options))
            {
                IProjectRepoDB _repo       = new ProjectRepoDB(context);
                Pattern        testPattern = new Pattern();
                testPattern.Id          = 1;
                testPattern.PatternData = "123";
                var foundPattern = await _repo.GetPatternByIDAsync(1);

                Assert.Equal(1, testPattern.Id);
            }
        }
        public async Task DeleteSavedProjectAsync_ShouldReturnDeletedProject_WhenSavedProjectIsValid()
        {
            //arrange
            int id = 1;
            var projectDBContext      = new ProjectDBContext(options);
            var projectrepoDB         = new ProjectRepoDB(projectDBContext);
            var savedProject2BDeleted = projectDBContext.SavedProject.Where(i => i.Id == id).FirstOrDefault();
            //act
            var result = await projectrepoDB.DeleteSavedProjectAsync(savedProject2BDeleted);

            //assert
            Assert.Equal("test1", result.ProjectName);
        }
        public async Task GetUserProjectByIDAsync_ShouldReturnUserProject_WhenIdIsValid()
        {
            //arrange
            int id = 1;
            var projectDBContext = new ProjectDBContext(options);
            var projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.GetUserProjectByIDAsync(id);

            //assert
            Assert.Equal(1, result.Id);
        }
        public async Task GetUserProjectByIDAsync_ShouldReturnNull_WhenIdIsInvalid()
        {
            //arrange
            int id = 22;
            var projectDBContext = new ProjectDBContext(options);
            var projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.GetUserProjectByIDAsync(id);

            //assert
            Assert.Null(result);
        }
        public async Task GetUsersSampleByIDAsync_ShouldReturnUsersSample()
        {
            //arrage
            int id = 1;
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.GetUsersSampleByIDAsync(id);

            //assert
            Assert.Equal(1, result.Id);
        }
        public async Task DeleteUsersSampleAsync_ShouldReturnUsersSample2BDeleted()
        {
            //arrange
            int id = 2;
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);
            var usersSample2BDeleted          = projectDBContext.UsersSample.Where(i => i.Id == id).FirstOrDefault();

            //act
            var result = await projectRepoDB.DeleteUsersSampleAsync(usersSample2BDeleted);

            //assert
            Assert.Equal(2, result.SampleId);
        }
        public async Task DeletePatternAsync_ShouldReturnPattern2BDeleted()
        {
            //arrange
            int id = 1;
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);
            var pattern2BDeleted = projectDBContext.Pattern.Where(i => i.Id == id).FirstOrDefault();

            //act
            var result = await projectRepoDB.DeletePatternAsync(pattern2BDeleted);

            //assert
            Assert.Equal(1, result.Id);
        }
        public async Task DeleteUserProjectAsync_ShouldReturnUserProject2BDeleted_WhenUserProjectIsValid()
        {
            //arrange
            int id = 1;
            var projectDBContext     = new ProjectDBContext(options);
            var projectRepoDB        = new ProjectRepoDB(projectDBContext);
            var userProject2BDeleted = projectDBContext.UserProject.Where(i => i.Id == id).FirstOrDefault();

            //act
            var result = await projectRepoDB.DeleteUserProjectAsync(userProject2BDeleted);

            //assert
            Assert.Equal(1, result.ProjectId);
        }
        public async Task DeleteSampleSetsAsync_ShouldReturnSampleSets2BDeleted()
        {
            //arrange
            int id = 1;
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);
            var sampleSet2BDeleted            = projectDBContext.SampleSet.Where(i => i.Id == id).FirstOrDefault();

            //act
            var result = await projectRepoDB.DeleteSampleSetsAsync(sampleSet2BDeleted);

            //assert
            Assert.Equal(1, result.Id);
        }
        public async Task AddSavedProjectAsync_ShouldReturnNewSavedProject_WhenSavedProjectIsValid()
        {
            //arrange
            var savedProject = new SavedProject();

            savedProject.ProjectName = "TestProject";
            var projectDBContext = new ProjectDBContext(options);
            var projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.AddSavedProjectAsync(savedProject);

            //assert
            Assert.Equal(savedProject.ProjectName, result.ProjectName);
        }
        public async Task DeleteTrackAsync_ShouldReturnDeletedTrack_WhenTrackisValid()
        {
            //arrange
            int id = 1;

            var projectDBContext = new ProjectDBContext(options);
            var projectRepoDB    = new ProjectRepoDB(projectDBContext);
            var track2BDeleted   = projectDBContext.Track.Where(i => i.Id == id).FirstOrDefault();

            //act
            var result = await projectRepoDB.DeleteTrackAsync(track2BDeleted);

            //assert
            Assert.Equal(1, result.ProjectId);
        }
        public async Task UpdateSamplePlaylistAsync_ShouldReturnOldSamplePlaylist()
        {//arrange
            SamplePlaylist samplePlaylist = new SamplePlaylist
            {
                Id       = 1,
                SampleId = 9
            };
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.UpdateSamplePlaylistAsync(samplePlaylist);

            //assert
            Assert.Equal(samplePlaylist.SampleId, result.SampleId);
        }
        public async Task UpdateSampleSetsAsync_ShouldReturnOldSampleSets()
        {
            //arrange
            SampleSets sampleSets = new SampleSets
            {
                Id   = 1,
                Name = "New sample sets name"
            };
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.UpdateSampleSetsAsync(sampleSets);

            //assert
            Assert.Equal(sampleSets.Name, result.Name);
        }
        public async Task UpdateSampleAsync_ShouldReturnOldSample()
        {
            //arrange
            Sample sample = new Sample
            {
                Id         = 1,
                SampleName = "new sample name"
            };
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.UpdateSampleAsync(sample);

            //assert
            Assert.Equal(sample.SampleName, result.SampleName);
        }
        public async Task UpdatePatternAsync_ShouldReturnOldPattern()
        {
            //arrange
            Pattern pattern = new Pattern
            {
                Id          = 1,
                PatternData = "NewPattern"
            };
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.UpdatePatternAsync(pattern);

            //assert
            Assert.Equal(pattern.PatternData, result.PatternData);
        }
        public async Task UpdateUsersSampleSetsAsync_ShouldReturn_OldUsersSampleSets()
        {
            //arrange
            UsersSampleSets usersSampleSets = new UsersSampleSets
            {
                Id     = 1,
                UserId = 99
            };
            ProjectDBContext projectDBContext = new ProjectDBContext(options);
            ProjectRepoDB    projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.UpdateUsersSampleSetsAsync(usersSampleSets);

            //assert
            Assert.Equal(usersSampleSets.UserId, result.UserId);
        }
        public async Task UpdateUsersSampleAsync_ShouldReturn_OldUsersSample()
        {
            //arrange
            UsersSample usersSample = new UsersSample
            {
                Id       = 1,
                SampleId = 98
            };
            var projectDBContext = new ProjectDBContext(options);
            var projectrepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectrepoDB.UpdateUsersSampleAsync(usersSample);

            //assert
            Assert.Equal(usersSample.SampleId, result.SampleId);
        }
 public async Task DeleteSavedProjectAsync_ShouldReturnArgumentNullException_WhenSavedProjectIsInvalid()
 {
     try
     {
         //arrange
         int id = 33;
         var projectDBContext      = new ProjectDBContext(options);
         var projectrepoDB         = new ProjectRepoDB(projectDBContext);
         var savedProject2BDeleted = projectDBContext.SavedProject.Where(i => i.Id == id).FirstOrDefault();
         //act
         var result = await projectrepoDB.DeleteSavedProjectAsync(savedProject2BDeleted);
     }
     catch (Exception ex)
     {
         //assert
         Assert.IsType <ArgumentNullException>(ex);
     }
 }
        public async Task UpdateUserProjectAsync_ShouldReturnUserProject2BUpdated_WhenUserProjectIsValid()
        {
            //arrange
            var userProject2BUpdated = new UserProject
            {
                Id        = 1,
                ProjectId = 8,
                UserId    = 1,
            };
            var projectDBContext = new ProjectDBContext(options);
            var projectRepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectRepoDB.UpdateUserProjectAsync(userProject2BUpdated);

            //assert
            Assert.Equal(userProject2BUpdated.ProjectId, result.ProjectId);
        }
        public async Task UpdateSavedProjectAsync_ShouldReturnSavedProject_WhenSavedProjectIsValid()
        {
            //arrange
            var savedproject2BUpdated = new SavedProject
            {
                Id          = 1,
                BPM         = "0",
                ProjectName = "test1Update"
            };
            var projectDBContext = new ProjectDBContext(options);
            var projectrepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectrepoDB.UpdateSavedProjectAsync(savedproject2BUpdated);

            //assert
            Assert.Equal(savedproject2BUpdated.ProjectName, result.ProjectName);
        }
        public async Task AddUserProjectAsync_ShouldReturnNewUserProject_WhenUserProjectIsValid()
        {
            //arrange
            var userProject = new UserProject
            {
                Id        = 7,
                ProjectId = 1,
                UserId    = 1
            };
            var projectDBContext = new ProjectDBContext(options);
            var projectrepoDB    = new ProjectRepoDB(projectDBContext);

            //act
            var result = await projectrepoDB.AddUserProjectAsync(userProject);

            //assert
            Assert.Equal(userProject.ProjectId, result.ProjectId);
        }