C# Design.FakePackageRepository类代码示例

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