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); }
void CreateNewActiveRepositoryWithDifferentPackages() { var package = new FakePackage("NewRepositoryPackageId"); var newRepository = new FakePackageRepository(); newRepository.FakePackages.Add(package); registeredPackageRepositories.FakeActiveRepository = newRepository; }
void CreateUpdatePackageInAllProjects(string packageId, SemanticVersion version) { fakeSolution = new FakePackageManagementSolution(); fakeSourceRepository = new FakePackageRepository(); var packageReference = new PackageReference(packageId, version, null, null, false, false); updatePackageInAllProjects = new UpdatePackageInAllProjects(packageReference, fakeSolution, fakeSourceRepository); }
void CreateNewActiveRepositoryWithDifferentPackages() { var package = new FakePackage("NewRepositoryPackageId"); var newRepository = new FakePackageRepository(); newRepository.FakePackages.Add(package); packageManagementService.FakeActivePackageRepository = newRepository; }
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; }
IPackageRepository CreateRecentPackageRepositoryPassingAggregateRepository() { recentPackagesPassedToCreateRecentPackageRepository = new RecentPackageInfo[0]; fakeAggregateRepositoryPassedToCreateRecentPackageRepository = new FakePackageRepository(); return cache.CreateRecentPackageRepository( recentPackagesPassedToCreateRecentPackageRepository, fakeAggregateRepositoryPassedToCreateRecentPackageRepository); }
public void CreateAggregatePackageRepository_OnePackageRepositoryPassed_ReturnsAggregateRepositoryFromFactory() { CreateCache(); var repositories = new FakePackageRepository[] { new FakePackageRepository() }; IPackageRepository aggregateRepository = cache.CreateAggregateRepository(repositories); FakePackageRepository expectedRepository = fakePackageRepositoryFactory.FakeAggregateRepository; Assert.AreEqual(expectedRepository, aggregateRepository); }
void CreateProject(MSBuildBasedProject msbuildProject) { fakePackageManagerFactory = new FakePackageManagerFactory(); fakePackageManager = fakePackageManagerFactory.FakePackageManager; fakeProjectManager = fakePackageManager.FakeProjectManager; fakeSourceRepository = new FakePackageRepository(); fakePackageManagementEvents = new FakePackageManagementEvents(); project = new PackageManagementProject( fakeSourceRepository, msbuildProject, fakePackageManagementEvents, fakePackageManagerFactory); }
public void GetInstalledPackages_PackageInstalledInProjectAndProjectIsSelected_CreatesProjectUsingRepository() { CreateFakeSolution(); List<IProject> projectsAddedToSolution = AddSolutionWithTwoProjectsToProjectService(); fakeSolution.FakeActiveMSBuildProject = projectsAddedToSolution[0]; CreateSelectedProjects(); var expectedRepository = new FakePackageRepository(); IQueryable<IPackage> packages = selectedProjects.GetPackages(expectedRepository); IPackageRepository repository = fakeSolution.RepositoryPassedToGetProject; Assert.AreEqual(expectedRepository, repository); }
public void CreateAggregatePackageRepository_OnePackageRepositoryPassed_RepositoryUsedToCreateAggregateRepository() { CreateCache(); var repositories = new FakePackageRepository[] { new FakePackageRepository() }; cache.CreateAggregateRepository(repositories); IEnumerable<IPackageRepository> repositoriesUsedToCreateAggregateRepository = fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository; Assert.AreEqual(repositories, repositoriesUsedToCreateAggregateRepository); }
void CreateProject() { fakePackageManagerFactory = new FakePackageManagerFactory(); fakePackageManager = fakePackageManagerFactory.FakePackageManager; fakeProjectManager = fakePackageManager.FakeProjectManager; fakeSourceRepository = new FakePackageRepository(); fakeMSBuildProject = ProjectHelper.CreateTestProject(); fakePackageManagementEvents = new FakePackageManagementEvents(); project = new PackageManagementProject( fakeSourceRepository, fakeMSBuildProject, fakePackageManagementEvents, fakePackageManagerFactory); }
public TestableUpdatedPackageViewModel( FakePackage package, FakePackageManagementService packageManagementService, FakeLicenseAcceptanceService licenseAcceptanceService, FakeMessageReporter messageReporter) : base( package, packageManagementService, licenseAcceptanceService, messageReporter) { this.FakePackage = package; this.FakePackageManagementService = packageManagementService; this.FakeLicenseAcceptanceService = licenseAcceptanceService; this.FakeMessageReporter = messageReporter; this.FakeSourcePackageRepository = FakePackageManagementService.FakeActivePackageRepository; }
void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper) { options = new PackageManagementOptions(new Properties()); options.PackagesDirectory = "packages"; repositoryPaths = new PackageRepositoryPaths(project, options); var pathResolver = new DefaultPackagePathResolver(repositoryPaths.SolutionPackagesPath); fakeFileSystem = new FakeFileSystem(); fakeFeedSourceRepository = new FakePackageRepository(); fakeSolutionSharedRepository = packageRefRepositoryHelper.FakeSharedSourceRepository; packageManager = new SharpDevelopPackageManager(fakeFeedSourceRepository, packageRefRepositoryHelper.FakeProjectSystem, fakeFileSystem, fakeSolutionSharedRepository, pathResolver); }
public void GetInstalledPackages_PackageInstalledInProjectAndProjectIsSelected_ReturnsPackageInstalledInProject() { CreateFakeSolution(); List<IProject> projectsAddedToSolution = AddSolutionWithTwoProjectsToProjectService(); fakeSolution.FakeActiveMSBuildProject = projectsAddedToSolution[0]; fakeSolution.FakeActiveMSBuildProject.Name = "MyProject"; var package = new FakePackage("Test"); var project = new FakePackageManagementProject("MyProject"); project.FakePackages.Add(package); fakeSolution.FakeProjectsToReturnFromGetProject.Add("MyProject", project); CreateSelectedProjects(); var repository = new FakePackageRepository(); IQueryable<IPackage> packages = selectedProjects.GetPackages(repository); var expectedPackages = new FakePackage[] { package }; PackageCollectionAssert.AreEqual(expectedPackages, packages); }
void CreateUpdateAllPackagesInSolution() { fakeSolution = new FakePackageManagementSolution(); fakeSourceRepository = new FakePackageRepository(); updateAllPackagesInSolution = new UpdateAllPackagesInSolution(fakeSolution, fakeSourceRepository); }
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 FakeProjectManager() { LocalRepository = new FakePackageRepository(); SourceRepository = new FakePackageRepository(); }
public void GetUpdatedPackages_OnePackageReferencedWithConstraintAndUpdatesAvailable_LatestVersionReturnedBasedOnConstraint() { CreateProject(); project.FakePackages.Add(new FakePackage("Test", "1.0")); var sourceRepository = new FakePackageRepository(); FakePackage packageVersion2 = sourceRepository.AddFakePackageWithVersion("Test", "2.0"); FakePackage [] expectedPackages = new [] { packageVersion2 }; sourceRepository.AddFakePackageWithVersion("Test", "3.0"); var versionSpec = new VersionSpec(); versionSpec.MinVersion = new SemanticVersion("1.0"); versionSpec.IsMinInclusive = true; versionSpec.MaxVersion = new SemanticVersion("2.0"); versionSpec.IsMaxInclusive = true; var constraintProvider = new DefaultConstraintProvider(); constraintProvider.AddConstraint("Test", versionSpec); project.ConstraintProvider = constraintProvider; CreateUpdatedPackages(sourceRepository); IEnumerable<IPackage> packages = updatedPackages.GetUpdatedPackages(); PackageCollectionAssert.AreEqual(expectedPackages, packages); }
void CreatePackage() { package = new TestablePackageFromRepository(); fakePackage = package.FakePackagePassedToConstructor; fakeRepository = package.FakePackageRepositoryPassedToConstructor; }
void CreateViewModel() { viewModel = new TestableUpdatedPackageViewModel(); fakePackageManagementService = viewModel.FakePackageManagementService; sourcePackageRepository = viewModel.FakeSourcePackageRepository; }
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 FakePackageManagementService() { FakeActiveProjectManager = new FakeProjectManager(); FakeActivePackageRepository = new FakePackageRepository(); FakeActiveProjectManager.FakeSourceRepository = FakeActivePackageRepository; }
public void RecentPackageRepository_OnePackageSource_OneRepositoryCreatedForPackageSourceAndUsedToCreateAggregateRepository() { CreatePackageSources(); packageSourcesHelper.AddOnePackageSource("Source1"); CreateCacheUsingPackageSources(); FakePackageRepository repository = AddFakePackageRepositoryForPackageSource("Source1"); var expectedRepositories = new FakePackageRepository[] { repository }; IRecentPackageRepository recentRepository = cache.RecentPackageRepository; IEnumerable<IPackageRepository> repositoriesUsedToCreateAggregateRepository = fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository; var actualRepositoriesAsList = new List<IPackageRepository>(repositoriesUsedToCreateAggregateRepository); IPackageRepository[] actualRepositories = actualRepositoriesAsList.ToArray(); CollectionAssert.AreEqual(expectedRepositories, actualRepositories); }
public void GetProjects_SolutionHasTwoProjects_ReturnsTwoProjects() { CreateSolution(); AddProjectToOpenProjects("One"); AddProjectToOpenProjects("Two"); var repository = new FakePackageRepository(); List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList(); Assert.AreEqual(2, projects.Count); }
public void GetProject_PackagesRepositoryAndProjectPassed_CreatesProjectUsingProjectPassed() { CreateSolution(); TestableProject expectedProject = AddProjectToOpenProjects("Test"); var repository = new FakePackageRepository(); solution.GetProject(repository, expectedProject); MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject; Assert.AreEqual(expectedProject, project); }
public FakePackageRepository AddFakePackageRepositoryForPackageSource(string source) { var repository = new FakePackageRepository(); FakePackageRepositories.Add(source, repository); return repository; }
public void GetProject_PackagesRepositoryAndProjectPassed_CreatesProjectUsingRepository() { CreateSolution(); TestableProject expectedProject = AddProjectToOpenProjects("Test"); var expectedRepository = new FakePackageRepository(); solution.GetProject(expectedRepository, expectedProject); IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject; Assert.AreEqual(expectedRepository, repository); }
public void GetProject_RepositoryAndProjectNamePassed_ReturnsProject() { CreateSolution(); AddProjectToOpenProjects("Test"); var repository = new FakePackageRepository(); IPackageManagementProject project = solution.GetProject(repository, "Test"); FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated; Assert.AreEqual(expectedProject, project); }
public void GetProject_RepositoryAndProjectNamePassed_RepositoryUsedToCreateProject() { CreateSolution(); AddProjectToOpenProjects("Test"); var expectedRepository = new FakePackageRepository(); solution.GetProject(expectedRepository, "Test"); IPackageRepository actualRepository = fakeProjectFactory.FirstRepositoryPassedToCreateProject; Assert.AreEqual(expectedRepository, actualRepository); }
public void GetProject_RepositoryAndProjectNameWithDifferentCasePassed_CreatesProjectUsingFoundProjectMatchingName() { CreateSolution(); TestableProject expectedProject = AddProjectToOpenProjects("Test"); var repository = new FakePackageRepository(); solution.GetProject(repository, "TEST"); MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject; Assert.AreEqual(expectedProject, project); }
public void CreateAggregatePackageRepository_TwoRegisteredPackageRepositories_AllRegisteredRepositoriesUsedToCreateAggregateRepositoryFromFactory() { CreatePackageSources(); packageSourcesHelper.AddTwoPackageSources("Source1", "Source2"); CreateCacheUsingPackageSources(); FakePackageRepository repository1 = AddFakePackageRepositoryForPackageSource("Source1"); FakePackageRepository repository2 = AddFakePackageRepositoryForPackageSource("Source2"); var expectedRepositories = new FakePackageRepository[] { repository1, repository2 }; cache.CreateAggregateRepository(); IEnumerable<IPackageRepository> repositoriesUsedToCreateAggregateRepository = fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository; var actualRepositoriesAsList = new List<IPackageRepository>(repositoriesUsedToCreateAggregateRepository); IPackageRepository[] actualRepositories = actualRepositoriesAsList.ToArray(); CollectionAssert.AreEqual(expectedRepositories, actualRepositories); }