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

        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(MSBuildBasedProject msbuildProject)
		{
			fakePackageManagerFactory = new FakePackageManagerFactory();
			fakePackageManager = fakePackageManagerFactory.FakePackageManager;
			fakeProjectManager = fakePackageManager.FakeProjectManager;
			fakeSourceRepository = new FakePackageRepository();
			fakePackageManagementEvents = new FakePackageManagementEvents();
			
			project = new PackageManagementProject(
				fakeSourceRepository,
				msbuildProject,
				fakePackageManagementEvents,
				fakePackageManagerFactory);
		}

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

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

        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 GetProjects_SolutionHasTwoProjects_ReturnsTwoProjects()
        {
            CreateSolution();
            AddProjectToOpenProjects("One");
            AddProjectToOpenProjects("Two");
            var repository = new FakePackageRepository();
            List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();

            Assert.AreEqual(2, projects.Count);
        }