public void TestSourceRepoPackageSourcesChanged()
        {
            // Arrange
            var localAppDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            var localPackageSource = new PackageSource(localAppDataPath);
            var oldPackageSources = new List<PackageSource>() { localPackageSource };
            var packageSourceProvider = new TestPackageSourceProvider(oldPackageSources);
            var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(packageSourceProvider);

            // Act
            var oldEffectivePackageSources = sourceRepositoryProvider.GetRepositories().ToList();

            // Assert
            Assert.Equal(1, oldEffectivePackageSources.Count);
            Assert.Equal(localAppDataPath, oldEffectivePackageSources[0].PackageSource.Source);

            // Main Act
            var newPackageSources = new List<PackageSource>() { TestSourceRepositoryUtility.V3PackageSource, localPackageSource };
            packageSourceProvider.SavePackageSources(newPackageSources);

            var newEffectivePackageSources = sourceRepositoryProvider.GetRepositories().ToList();

            // Main Assert
            Assert.Equal(2, newEffectivePackageSources.Count);
            Assert.Equal(TestSourceRepositoryUtility.V3PackageSource.Source, newEffectivePackageSources[0].PackageSource.Source);
            Assert.Equal(localAppDataPath, newEffectivePackageSources[1].PackageSource.Source);
        }

		void CreateAction (
			string packageId = "Test",
			string version = "2.1")
		{
			project = new FakeDotNetProject (@"d:\projects\MyProject\MyProject.csproj");
			solutionManager = new FakeSolutionManager ();
			nugetProject = new FakeNuGetProject (project);
			solutionManager.NuGetProjects[project] = nugetProject;

			var repositoryProvider = solutionManager.SourceRepositoryProvider;
			var source = new PackageSource ("http://test.com");
			repositoryProvider.AddRepository (source);
			primaryRepositories = repositoryProvider.Repositories;

			action = new TestableReinstallNuGetPackageAction (
				project,
				solutionManager);

			packageManagementEvents = action.PackageManagementEvents;
			fileRemover = action.FileRemover;

			action.PackageId = packageId;
			action.Version = new NuGetVersion (version);

			uninstallPackageManager = action.UninstallAction.PackageManager;
			installPackageManager = action.InstallAction.PackageManager;
		}

        public virtual IPackageRepository CreateRepository(PackageSource packageSource)
        {
            if (packageSource == null) {
                throw new ArgumentNullException("packageSource");
            }

            if (packageSource.IsAggregate) {
                throw new NotSupportedException();
            }

            Uri uri = new Uri(packageSource.Source);
            if (uri.IsFile) {
                return new LocalPackageRepository(uri.LocalPath);
            }

            try {
                uri = _httpClient.GetRedirectedUri(uri);
            }
            catch (Exception exception) {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                    NuGetResources.UnavailablePackageSource, packageSource),
                    exception);
            }

            // Make sure we get resolve any fwlinks before creating the repository
            return new DataServicePackageRepository(uri, _httpClient);
        }

		void CreateAction (
			string packageId = "Test",
			string version = "2.1")
		{
			project = new FakeDotNetProject (@"d:\projects\MyProject\MyProject.csproj");
			solutionManager = new FakeSolutionManager ();
			nugetProject = new FakeNuGetProject (project);
			solutionManager.NuGetProjects[project] = nugetProject;

			var metadataResourceProvider = new FakePackageMetadataResourceProvider ();
			packageMetadataResource = metadataResourceProvider.PackageMetadataResource;
			var source = new PackageSource ("http://test.com");
			var providers = new INuGetResourceProvider[] {
				metadataResourceProvider
			};
			var sourceRepository = new SourceRepository (source, providers);
			primaryRepositories = new [] {
				sourceRepository
			}.ToList ();

			action = new TestableInstallNuGetPackageAction (
				primaryRepositories,
				solutionManager,
				project);

			packageManager = action.PackageManager;
			packageManagementEvents = action.PackageManagementEvents;
			fileRemover = action.FileRemover;

			action.PackageId = packageId;
			action.Version = new NuGetVersion (version);
		}

        public override async Task<Resource> Create(PackageSource source)
        {
            try
            {
                object repo = null;
                string host = "TestHost";

                // Check if the source is already present in the cache.
                if (!packageSourceCache.TryGetValue(source.Url, out repo))
                {
                    // if it's not in cache, then check if it is V2.
                    if (await V2Utilities.IsV2(source))
                    {
                        // Get a IPackageRepo object and add it to the cache.
                        repo = V2Utilities.GetV2SourceRepository(source, host);
                        packageSourceCache.Add(source.Url, repo);
                    }
                    else
                    {
                        // if it's not V2, returns null
                        return null;
                    }
                }

                // Create a resource and return it.
                var resource = new V2Resource((IPackageRepository)repo, host);
                return resource;
            }
            catch (Exception)
            {
                // *TODOs:Do tracing and throw apppropriate exception here.
                return null; 
            }
        }

 private static PackageSource CreateV3PreviewSource()
 {
     var source = new PackageSource(
         Strings.VsSourceRepositoryManager_V3SourceName,
         NuGetConstants.V3FeedUrl);
     return source;
 }

		private HttpMessageHandler TryGetCredentialAndProxy(PackageSource packageSource) 
        {
            Uri uri = new Uri(packageSource.Source);
            var proxy = ProxyCache.Instance.GetProxy(uri);
            var credential = CredentialStore.Instance.GetCredentials(uri);

            if (proxy != null && proxy.Credentials == null) {
                proxy.Credentials = CredentialCache.DefaultCredentials;
            }

            if (credential == null && !String.IsNullOrEmpty(packageSource.UserName) && !String.IsNullOrEmpty(packageSource.Password)) 
            {
                var cache = new CredentialCache();
                foreach (var scheme in _authenticationSchemes)
                {
                    cache.Add(uri, scheme, new NetworkCredential(packageSource.UserName, packageSource.Password));
                }
                credential = cache;
            }

            if (proxy == null && credential == null) return null;
            else
            {
                if(proxy != null) ProxyCache.Instance.Add(proxy);
                if (credential != null) CredentialStore.Instance.Add(uri, credential);
                return new WebRequestHandler()
                {
                    Proxy = proxy,
                    Credentials = credential
                };
            }


        }

 public static bool TryLoad(string uriOrPath, out PackageSource packageSource)
 {
     try
     {
         Uri path;
         if (!Uri.TryCreate(uriOrPath, UriKind.RelativeOrAbsolute, out path))
         {
             packageSource = null;
             return false;
         }
         var resolvedPath = path.IsAbsoluteUri ? path.LocalPath : uriOrPath;
         if (File.Exists(resolvedPath))
         {
             packageSource = PackageSource.FromJson(File.OpenRead(resolvedPath), uriOrPath);
             return true;
         }
     }
     catch (Exception e)
     {
         // TODO: proper logging
         if (Environment.IsDebug)
         {
             Console.Error.WriteLine($"Unable to load local file index '{uriOrPath}'");
             Console.Error.WriteLine(e);
         }
     }
     packageSource = null;
     return false;
 }

        public static async Task<bool> IsV2(PackageSource source)
        {
            var url = new Uri(source.Url);

            // If the url is a directory, then it's a V2 source
            if (url.IsFile || url.IsUnc) 
            {
                return !File.Exists(url.LocalPath);
            }

            using (var client = new Data.DataClient())
            {
                var result = await client.GetFile(url);
                if (result == null)
                {
                    return false;
                }

                var raw = result.Value<string>("raw");
                if (raw != null && raw.IndexOf("Packages", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    return true;
                }

                return false;
            }
        }

		void CreateAction ()
		{
			project = new FakeDotNetProject (@"d:\projects\MyProject\MyProject.csproj");
			solutionManager = new FakeSolutionManager ();
			nugetProject = new FakeNuGetProject (project);
			solutionManager.NuGetProjects[project] = nugetProject;

			var metadataResourceProvider = new FakePackageMetadataResourceProvider ();
			packageMetadataResource = metadataResourceProvider.PackageMetadataResource;
			var source = new PackageSource ("http://test.com");
			var providers = new INuGetResourceProvider[] {
				metadataResourceProvider
			};
			var sourceRepository = new SourceRepository (source, providers);
			primaryRepositories = new [] {
				sourceRepository
			}.ToList ();
			solutionManager.SourceRepositoryProvider.Repositories.AddRange (primaryRepositories);

			action = new TestableUpdateAllNuGetPackagesInProjectAction (
				solutionManager,
				project);

			packageManager = action.PackageManager;
			packageManagementEvents = action.PackageManagementEvents;
			fileRemover = action.FileRemover;
			restoreManager = action.RestoreManager;
		}

        public RemoteV2FindPackageByIdResourcce(PackageSource packageSource)
        {
            _baseUri = packageSource.Source.EndsWith("/") ? packageSource.Source : (packageSource.Source + "/");
            _httpSource = new HttpSource(new Uri(_baseUri), packageSource.UserName, packageSource.Password);

            PackageSource = packageSource;
        }

        public void AddFromExtension(ISourceRepositoryProvider provider, string extensionId)
        {
            string path = GetExtensionRepositoryPath(extensionId, null, _errorHandler);

            PackageSource source = new PackageSource(path);

            _repositories.Add(provider.CreateRepository(source));
        }

        public void AddFromRegistry(string keyName)
        {
            string path = GetRegistryRepositoryPath(keyName, null, _errorHandler);

            PackageSource source = new PackageSource(path);

            _repositories.Add(_provider.CreateRepository(source));
        }

		public IPackageRepository CreateRepository(PackageSource packageSource)
		{
			IPackageRepository repository = GetExistingRepository(packageSource);
			if (repository != null) {
				return repository;
			}
			return CreateNewCachedRepository(packageSource);
		}

		public RegisteredPackageSource(PackageSource packageSource)
		{
			Source = packageSource.Source;
			Name = packageSource.Name;
			IsEnabled = packageSource.IsEnabled;
			UserName = packageSource.UserName;
			Password = packageSource.Password;
		}

		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 DisablePackageSource(PackageSource source)
 {
     var sourceInUse = _sources.Find(p => p.Equals(source));
     if (sourceInUse != null)
     {
         sourceInUse.IsEnabled = false;
     }
 }

		void CreateCacheUsingPackageSources()
		{
			nuGetPackageSource = new PackageSource("http://nuget.org", "NuGet");
			fakePackageRepositoryFactory = new FakePackageRepositoryFactory();
			RegisteredPackageSources packageSources = packageSourcesHelper.Options.PackageSources;
			IList<RecentPackageInfo> recentPackages = packageSourcesHelper.Options.RecentPackages;
			cache = new PackageRepositoryCache(fakePackageRepositoryFactory, packageSources, recentPackages);
		}

		IPackageRepository GetExistingRepository(PackageSource packageSource)
		{
			IPackageRepository repository = null;
			if (repositories.TryGetValue(packageSource, out repository)) {
				return repository;
			}
			return null;
		}

		static string ConvertToString (PackageSource source)
		{
			if (source != null) {
				return String.Format ("[PackageSource] Name='{0}', Source='{1}'",
					source.Name,
					source.Source);
			}
			return "[PackageSource] == Null";
		}