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);
}
