void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper) { options = new TestablePackageManagementOptions(); options.PackagesDirectory = "packages"; repositoryPaths = new SolutionPackageRepositoryPath(project, options); var pathResolver = new DefaultPackagePathResolver(repositoryPaths.PackageRepositoryPath); fakeFileSystem = new FakeFileSystem(); fakeFeedSourceRepository = new FakePackageRepository(); fakeSolutionSharedRepository = packageRefRepositoryHelper.FakeSharedSourceRepository; fakePackageOperationResolverFactory = new FakePackageOperationResolverFactory(); var fakeSolutionPackageRepository = new FakeSolutionPackageRepository(); fakeSolutionPackageRepository.FileSystem = fakeFileSystem; fakeSolutionPackageRepository.PackagePathResolver = pathResolver; fakeSolutionPackageRepository.FakeSharedRepository = fakeSolutionSharedRepository; packageManager = new SharpDevelopPackageManager(fakeFeedSourceRepository, packageRefRepositoryHelper.FakeProjectSystem, fakeSolutionPackageRepository, fakePackageOperationResolverFactory); }
public void CreateAggregateRepository_SolutionClosedAndEnabledPackageSourcesChangedAfterCacheCreated_AggregateRepositoryContainsCorrectEnabledPackageRepositories() { CreatePackageSources(); packageSourcesHelper.AddTwoPackageSources("Source1", "Source2"); CreateCacheUsingPackageSources(); FakePackageRepository source1Repo = AddFakePackageRepositoryForPackageSource("Source1"); FakePackageRepository source2Repo = AddFakePackageRepositoryForPackageSource("Source2"); fakePackageRepositoryFactory.CreateAggregrateRepositoryAction = (repositories) => { return(new AggregateRepository(repositories)); }; var initialAggregateRepository = cache.CreateAggregateRepository() as AggregateRepository; var expectedInitialRepositories = new FakePackageRepository[] { source1Repo, source2Repo }; List <IPackageRepository> actualInitialRepositories = initialAggregateRepository.Repositories.ToList(); var solution = new SolutionHelper().MSBuildSolution; packageSourcesHelper.Options.ProjectService.FireSolutionClosedEvent(solution); packageSourcesHelper.Options.PackageSources.Clear(); packageSourcesHelper.Options.PackageSources.Add(new PackageSource("Source3")); FakePackageRepository source3Repo = AddFakePackageRepositoryForPackageSource("Source3"); var expectedRepositories = new FakePackageRepository[] { source3Repo }; var aggregateRepository = cache.CreateAggregateRepository() as AggregateRepository; List <IPackageRepository> actualRepositories = aggregateRepository.Repositories.ToList(); CollectionAssert.AreEqual(expectedInitialRepositories, actualInitialRepositories); CollectionAssert.AreEqual(expectedRepositories, actualRepositories); }
public FakePackageRepository AddFakePackageRepositoryForPackageSource(string source) { var repository = new FakePackageRepository(); FakePackageRepositories.Add(source, repository); return(repository); }
AggregateRepository CreateAggregateRepositoryWithOneRepository() { var repositories = new FakePackageRepository [] { new FakePackageRepository() }; return(new AggregateRepository(repositories)); }
public void CreateAggregateRepository_MethodCalled_ReturnsAggregateRepositoryCreatedFromCache() { CreateRegisteredPackageRepositories(); IPackageRepository repository = registeredRepositories.CreateAggregateRepository(); FakePackageRepository expectedRepository = fakeRepositoryCache.FakeAggregateRepository; Assert.AreEqual(expectedRepository, repository); }
void CreateNewActiveRepositoryWithDifferentPackages() { var package = new FakePackage("NewRepositoryPackageId"); var newRepository = new FakePackageRepository(); newRepository.FakePackages.Add(package); packageManagementService.FakeActivePackageRepository = newRepository; }
public void CreateRepository_PackageSourceSpecified_CreatesRepositoryFromCache() { CreateRegisteredPackageRepositories(); IPackageRepository repository = registeredRepositories.CreateRepository(new PackageSource("a")); FakePackageRepository expectedRepository = fakeRepositoryCache.FakePackageRepository; Assert.AreEqual(expectedRepository, repository); }
public void GetProjects_SolutionHasNoProjects_ReturnsNoProjects() { CreateSolution(); var repository = new FakePackageRepository(); List <IPackageManagementProject> projects = solution.GetProjects(repository).ToList(); Assert.AreEqual(0, projects.Count); }
FakePackage AddPackageToRecentPackageRepository() { var package = new FakePackage("Test"); FakePackageRepository repository = registeredPackageRepositories.FakeRecentPackageRepository; repository.FakePackages.Add(package); return(package); }
void CreateUpdatePackageInAllProjects(string packageId, SemanticVersion version) { fakeSolution = new FakePackageManagementSolution(); fakeSourceRepository = new FakePackageRepository(); var packageReference = new PackageReference(packageId, version, null); updatePackageInAllProjects = new UpdatePackageInAllProjects(packageReference, fakeSolution, fakeSourceRepository); }
void WalkPackage(IPackage package) { var localRepository = new FakePackageRepository(); var sourceRepository = new FakePackageRepository(); var walker = new InstallWalker(localRepository, sourceRepository, null, NullLogger.Instance, true, false, DependencyVersion.Lowest); walker.Walk(package); }
void CreateNewActiveRepositoryWithDifferentPackages() { var package = new FakePackage("NewRepositoryPackageId"); var newRepository = new FakePackageRepository(); newRepository.FakePackages.Add(package); registeredPackageRepositories.FakeActiveRepository = newRepository; }
public void GetProjects_SolutionHasOneProject_ReturnsOneProject() { CreateSolution(); AddProjectToOpenProjects("MyProject"); var repository = new FakePackageRepository(); List <IPackageManagementProject> projects = solution.GetProjects(repository).ToList(); Assert.AreEqual(1, projects.Count); }
void CreateViewModel(FakePackageManagementService packageManagementService) { viewModel = new TestablePackageViewModel(packageManagementService); package = viewModel.FakePackage; this.packageManagementService = packageManagementService; sourcePackageRepository = packageManagementService.FakeActivePackageRepository; licenseAcceptanceService = viewModel.FakeLicenseAcceptanceService; messageReporter = viewModel.FakeMessageReporter; }
IPackageRepository CreateRecentPackageRepositoryPassingAggregateRepository() { recentPackagesPassedToCreateRecentPackageRepository = new RecentPackageInfo[0]; fakeAggregateRepositoryPassedToCreateRecentPackageRepository = new FakePackageRepository(); return(cache.CreateRecentPackageRepository( recentPackagesPassedToCreateRecentPackageRepository, fakeAggregateRepositoryPassedToCreateRecentPackageRepository)); }
public void GetActiveProject_RepositoryPassed_ReturnsProjectFromProjectFactory() { CreateSolution(); var expectedRepository = new FakePackageRepository(); IPackageManagementProject project = solution.GetActiveProject(expectedRepository); FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated; Assert.AreEqual(expectedProject, project); }
public void RecentPackageRepository_NoRecentPackages_CreatedWithAggregateRepository() { CreateCache(); IRecentPackageRepository repository = cache.RecentPackageRepository; FakePackageRepository expectedRepository = fakePackageRepositoryFactory.FakeAggregateRepository; IPackageRepository actualRepository = fakePackageRepositoryFactory.AggregateRepositoryPassedToCreateRecentPackageRepository; Assert.AreEqual(expectedRepository, actualRepository); }
public void GetPackageRepository_PackageSourceSpecified_ReturnsPackageRepositoryFromRegisteredRepositories() { CreateHost(); var packageSource = new PackageSource("Test"); IPackageRepository repository = host.GetPackageRepository(packageSource); FakePackageRepository expectedRepository = fakeRegisteredPackageRepositories.FakePackageRepository; Assert.AreEqual(expectedRepository, repository); }
public void GetActiveProject_RepositoryPassedWhenSolutionOpenButNoProjectSelected_ReturnsNull() { CreateSolution(); fakeProjectService.CurrentProject = null; var repository = new FakePackageRepository(); IPackageManagementProject activeProject = solution.GetActiveProject(repository); Assert.IsNull(activeProject); }
FakePackageRepository AddRegisteredPackageRepository(string packageSourceUrl, string packageSourceName) { var packageSource = new PackageSource(packageSourceUrl, packageSourceName); AddRegisteredPackageSource(packageSource); FakePackageRepository fakeRepository = new FakePackageRepository(); fakeMainCache.FakePackageRepositories.Add(packageSource.Source, fakeRepository); return(fakeRepository); }
public void CreateActions_SolutionHasOneProject_UpdateActionCreatedUsingSourceRepositoryPassedInConstructor() { CreateUpdatePackageInAllProjects(); AddProjectToSolution("MyProject"); CallCreateActions(); IPackageRepository repository = fakeSolution.SourceRepositoryPassedToGetProjects; FakePackageRepository expectedRepository = fakeSourceRepository; Assert.AreEqual(expectedRepository, repository); }
public void GetProject_ProjectNameAndRepositoryPassed_RepositoryUsedToGetProject() { CreateHost(); var repository = new FakePackageRepository(); host.GetProject(repository, "Test"); IPackageRepository actualRepository = fakeSolution.RepositoryPassedToGetProject; Assert.AreEqual(repository, actualRepository); }
public void CreateAggregatePackageRepository_TwoRegisteredPackageRepositories_ReturnsAggregateRepositoryFromFactory() { CreatePackageSources(); packageSourcesHelper.AddTwoPackageSources("Source1", "Source2"); CreateCacheUsingPackageSources(); IPackageRepository aggregateRepository = cache.CreateAggregateRepository(); FakePackageRepository expectedRepository = fakePackageRepositoryFactory.FakeAggregateRepository; Assert.AreEqual(expectedRepository, aggregateRepository); }
public void GetProject_ProjectNameAndRepositoryPassed_ReturnsProject() { CreateHost(); var repository = new FakePackageRepository(); IPackageManagementProject project = host.GetProject(repository, "Test"); FakePackageManagementProject expectedProject = fakeSolution.FakeProjectToReturnFromGetProject; Assert.AreEqual(expectedProject, project); }
public void GetProjects_SolutionHasOneProject_MSBuildProjectUsedToCreateProject() { CreateSolution(); TestableProject expectedProject = AddProjectToOpenProjects("MyProject"); var repository = new FakePackageRepository(); List <IPackageManagementProject> projects = solution.GetProjects(repository).ToList(); MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject; Assert.AreEqual(expectedProject, project); }
public void GetProjects_SolutionHasOneProject_RepositoryUsedToCreateProject() { CreateSolution(); AddProjectToOpenProjects("MyProject"); var expectedRepository = new FakePackageRepository(); List <IPackageManagementProject> projects = solution.GetProjects(expectedRepository).ToList(); IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject; Assert.AreEqual(expectedRepository, repository); }
public void GetActiveProject_RepositoryPassed_CreatesProjectUsingRepository() { CreateSolution(); var expectedRepository = new FakePackageRepository(); solution.GetActiveProject(expectedRepository); IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject; Assert.AreEqual(expectedRepository, repository); }
public void ProcessRecord_UpdatedPackagesRequested_AggregateRepositoryUsedWhenCreatingProject() { CreateCmdlet(); EnableUpdatesParameter(); RunCmdlet(); IPackageRepository actualRepository = fakeConsoleHost.PackageRepositoryPassedToGetProject; FakePackageRepository expectedRepository = fakeRegisteredPackageRepositories.FakeAggregateRepository; Assert.AreEqual(expectedRepository, actualRepository); }
public void GetSingleProjectSelected_NoProjectSelected_ReturnsNull() { CreateFakeSolution(); AddSolutionWithTwoProjectsToProjectService(); NoProjectsSelected(); CreateSelectedProjects(); var repository = new FakePackageRepository(); IPackageManagementProject project = selectedProjects.GetSingleProjectSelected(repository); Assert.IsNull(project); }
public void ActivePackageRepository_ActivePackageSourceIsAggregate_ReturnsAggregatePackageRepository() { CreateRegisteredPackageRepositories(); packageSourcesHelper.AddTwoPackageSources(); registeredRepositories.ActivePackageSource = RegisteredPackageSourceSettings.AggregatePackageSource; IPackageRepository repository = registeredRepositories.ActiveRepository; FakePackageRepository expectedRepository = fakeRepositoryCache.FakeAggregateRepository; Assert.AreEqual(expectedRepository, repository); }