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);
}
public FakePackageRepository AddFakePackageRepositoryForPackageSource(string source)
{
var repository = new FakePackageRepository();
FakePackageRepositories.Add(source, repository);
return(repository);
}
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 ();
fakePackageOperationResolver = fakePackageOperationResolverFactory.FakeInstallPackageOperationResolver;
var fakeSolutionPackageRepository = new FakeSolutionPackageRepository ();
fakeSolutionPackageRepository.FileSystem = fakeFileSystem;
fakeSolutionPackageRepository.PackagePathResolver = pathResolver;
fakeSolutionPackageRepository.FakeSharedRepository = fakeSolutionSharedRepository;
packageManager = new MonoDevelopPackageManager (fakeFeedSourceRepository,
packageRefRepositoryHelper.FakeProjectSystem,
fakeSolutionPackageRepository,
fakePackageOperationResolverFactory);
}
IPackageRepository CreateRecentPackageRepositoryPassingAggregateRepository ()
{
recentPackagesPassedToCreateRecentPackageRepository = new RecentPackageInfo[0];
fakeAggregateRepositoryPassedToCreateRecentPackageRepository = new FakePackageRepository ();
return cache.CreateRecentPackageRepository (
recentPackagesPassedToCreateRecentPackageRepository,
fakeAggregateRepositoryPassedToCreateRecentPackageRepository);
}
public IPackageRepository CreateRepository(string packageSource)
{
PackageSourcesPassedToCreateRepository.Add(packageSource);
FakePackageRepository repository = null;
if (FakePackageRepositories.TryGetValue(packageSource, out repository))
{
return(repository);
}
return(FakePackageRepository);
}
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 GetUpdatedPackages_OnePackageReferencedWithConstraintAndUpdatesAvailable_LatestVersionReturnedBasedOnConstraint ()
{
AddPackageReference ("Test", "1.0");
FakePackage package = AddPackageToSourceRepository ("Test", "2.0");
FakePackage [] expectedPackages = new [] {
package
};
AddPackageToSourceRepository ("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;
var repository = new FakePackageRepository ();
repository.FakePackages = sourceRepositoryPackages;
CreateUpdatedPackages (repository);
IEnumerable<IPackage> packages = updatedPackages.GetUpdatedPackages ();
PackageCollectionAssert.AreEqual (expectedPackages, packages);
}
public void GetProject_RepositoryAndProjectNameWithDifferentCasePassed_CreatesProjectUsingFoundProjectMatchingName ()
{
CreateSolution ();
FakeDotNetProject expectedProject = AddProjectToOpenProjects ("Test");
var repository = new FakePackageRepository ();
solution.GetProject (repository, "TEST");
IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
Assert.AreEqual (expectedProject, project);
}
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 GetActiveProject_RepositoryPassed_CreatesProjectUsingFallbackRepositoryWithAggregateAsFallback ()
{
CreateSolution ();
var expectedRepository = new FakePackageRepository ();
solution.GetActiveProject (expectedRepository);
IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
var fallbackRepository = repository as FallbackRepository;
Assert.IsNotNull (fallbackRepository);
Assert.AreEqual (expectedRepository, fallbackRepository.SourceRepository);
Assert.AreEqual (fakeRegisteredPackageRepositories.FakeAggregateRepository, fallbackRepository.DependencyResolver);
}
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 ();
packageSourcesHelper.Options.ProjectService.RaiseSolutionUnloadedEvent ();
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);
}
FakePackageRepository AddRepository ()
{
var repository = new FakePackageRepository ();
repositories.Add (repository);
return repository;
}
public TestablePackageFromRepository (FakePackage package, FakePackageRepository repository)
: base (package, repository)
{
this.FakePackagePassedToConstructor = package;
this.FakePackageRepositoryPassedToConstructor = repository;
}
void CreateProject ()
{
fakeSourceRepository = new FakePackageRepository ();
CreateProject (fakeSourceRepository);
}
void CreatePackage ()
{
package = new TestablePackageFromRepository ();
fakePackage = package.FakePackagePassedToConstructor;
fakeRepository = package.FakePackageRepositoryPassedToConstructor;
}
public bool IsCloneOf(FakePackageRepository packageRepository)
{
return(ClonedRepository == packageRepository);
}
public void Run_ActionDownloadsTwoPackages_DownloadingMessageLoggedOnceForEachDownloadOperationByProgressMonitor ()
{
CreateRunner ();
AddInstallActionWithCustomExecuteAction (() => {
var repository = new FakePackageRepository ();
repositoryFactoryEvents.RaiseRepositoryCreatedEvent (new PackageRepositoryFactoryEventArgs (repository));
var progress = new ProgressEventArgs ("Download1", 100);
repository.RaiseProgressAvailableEvent (progress);
progress = new ProgressEventArgs ("Download2", 50);
repository.RaiseProgressAvailableEvent (progress);
progress = new ProgressEventArgs ("Download2", 100);
repository.RaiseProgressAvailableEvent (progress);
});
Run ();
progressMonitor.AssertMessageIsLogged ("Download1");
progressMonitor.AssertMessageIsLogged ("Download2");
progressMonitor.AssertMessageIsNotLogged ("Download2" + Environment.NewLine + "Download2");
}
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 CreateUpdateAllPackagesInSolution ()
{
fakeSolution = new FakePackageManagementSolution ();
fakeSourceRepository = new FakePackageRepository ();
updateAllPackagesInSolution = new UpdateAllPackagesInSolution (fakeSolution, fakeSourceRepository);
}
void CreateCacheUsingPackageSources (ISharpDevelopPackageRepositoryFactory repositoryFactory)
{
nuGetPackageSource = new PackageSource ("http://nuget.org", "NuGet");
machineCache = new FakePackageRepository ();
cache = new PackageRepositoryCache (packageSourcesHelper.Options, machineCache, repositoryFactory);
}
void CreateNewActiveRepositoryWithDifferentPackages ()
{
var package = new FakePackage ("NewRepositoryPackageId");
var newRepository = new FakePackageRepository ();
newRepository.FakePackages.Add (package);
registeredPackageRepositories.FakeActiveRepository = newRepository;
}
public FakeProjectManager()
{
LocalRepository = new FakePackageRepository();
SourceRepository = new FakePackageRepository();
}
public TestablePackageFromRepository(FakePackage package, FakePackageRepository repository)
: base(package, repository)
{
this.FakePackagePassedToConstructor = package;
this.FakePackageRepositoryPassedToConstructor = repository;
}
public void GetActiveProject_RepositoryPassed_CreatesProjectUsingCurrentActiveProject ()
{
CreateSolution ();
var expectedRepository = new FakePackageRepository ();
FakeDotNetProject expectedProject = ProjectHelper.CreateTestProject ();
fakeProjectService.CurrentProject = expectedProject;
solution.GetActiveProject (expectedRepository);
IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
Assert.AreEqual (expectedProject, project);
}
public FakeProjectManager ()
{
LocalRepository = new FakePackageRepository ();
SourceRepository = new FakePackageRepository ();
}
public void GetProject_PackagesRepositoryAndProjectPassed_CreatesProjectUsingProjectPassed ()
{
CreateSolution ();
FakeDotNetProject expectedProject = AddProjectToOpenProjects ("Test");
var repository = new FakePackageRepository ();
solution.GetProject (repository, expectedProject);
IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
Assert.AreEqual (expectedProject, project);
}
public void GetActiveProject_RepositoryPassedWhenSolutionOpenButNoProjectSelected_ReturnsNull ()
{
CreateSolution ();
fakeProjectService.CurrentProject = null;
var repository = new FakePackageRepository ();
IPackageManagementProject activeProject = solution.GetActiveProject (repository);
Assert.IsNull (activeProject);
}
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 GetProjects_SolutionHasOneProject_MSBuildProjectUsedToCreateProject ()
{
CreateSolution ();
FakeDotNetProject expectedProject = AddProjectToOpenProjects ("MyProject");
var repository = new FakePackageRepository ();
solution.GetProjects (repository).ToList ();
IDotNetProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
Assert.AreEqual (expectedProject, project);
}
public void GetProjects_SolutionHasOneProject_FallbackRepositoryUsedToCreateProject ()
{
CreateSolution ();
AddProjectToOpenProjects ("MyProject");
var expectedRepository = new FakePackageRepository ();
solution.GetProjects (expectedRepository).ToList ();
IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
var fallbackRepository = repository as FallbackRepository;
Assert.AreEqual (expectedRepository, fallbackRepository.SourceRepository);
Assert.AreEqual (fakeRegisteredPackageRepositories.FakeAggregateRepository, fallbackRepository.DependencyResolver);
}
public void CreateAggregatePackageRepository_TwoRegisteredPackageSourcesButOneDisabled_ReturnsAggregateRepositoryCreatedWithOnlyEnabledPackageSource ()
{
CreatePackageSources ();
packageSourcesHelper.AddTwoPackageSources ("Source1", "Source2");
packageSourcesHelper.RegisteredPackageSources [0].IsEnabled = false;
CreateCacheUsingPackageSources ();
AddFakePackageRepositoryForPackageSource ("Source1");
FakePackageRepository repository2 = AddFakePackageRepositoryForPackageSource ("Source2");
var expectedRepositories = new FakePackageRepository[] {
repository2
};
cache.CreateAggregateRepository ();
IEnumerable<IPackageRepository> repositoriesUsedToCreateAggregateRepository =
fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository;
var actualRepositoriesAsList = new List<IPackageRepository> (repositoriesUsedToCreateAggregateRepository);
IPackageRepository[] actualRepositories = actualRepositoriesAsList.ToArray ();
CollectionAssert.AreEqual (expectedRepositories, actualRepositories);
}
public void GetProjects_SolutionHasNoProjects_ReturnsNoProjects ()
{
CreateSolution ();
var repository = new FakePackageRepository ();
List<IPackageManagementProject> projects = solution.GetProjects (repository).ToList ();
Assert.AreEqual (0, projects.Count);
}
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);
}
AggregateRepository CreateAggregateRepositoryWithOneRepository ()
{
var repositories = new FakePackageRepository [] {
new FakePackageRepository ()
};
return new AggregateRepository (repositories);
}
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);
}