Support switching between repositories in the Add Package Reference dialog.

src/AddIns/Misc/PackageManagement/Project/Src/AvailablePackagesViewModel.cs

@@ -15,6 +15,7 @@ namespace ICSharpCode.PackageManagement
 			: base(packageManagementService)
 		{
 			IsSearchable = true;
+			ShowPackageSources = packageManagementService.HasMultiplePackageSources;
 		}
 		
 		protected override IQueryable<IPackage> GetAllPackages()

src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManagementService.cs

@@ -38,13 +38,19 @@ namespace ICSharpCode.PackageManagement.Design
 		public IPackageRepository RepositoryPassedToUninstallPackage;
 		public IPackage PackagePassedToUninstallPackage;
 		
-		public FakeProjectManager FakeActiveProjectManager = new FakeProjectManager();
-		public FakePackageRepository FakeActivePackageRepository = new FakePackageRepository();
+		public FakeProjectManager FakeActiveProjectManager {
+			get { return ActiveProjectManager as FakeProjectManager; }
+			set { ActiveProjectManager = value; }
+		}
+		public FakePackageRepository FakeActivePackageRepository {
+			get { return ActivePackageRepository as FakePackageRepository; }
+			set { ActivePackageRepository = value; }
+		}
 		
 		public FakePackageManagementService()
 		{
-			ActiveProjectManager = FakeActiveProjectManager;
-			ActivePackageRepository = FakeActivePackageRepository;
+			FakeActiveProjectManager = new FakeProjectManager();
+			FakeActivePackageRepository = new FakePackageRepository();
 			FakeActiveProjectManager.FakeSourceRepository = FakeActivePackageRepository;
 		}
 		
@@ -82,5 +88,27 @@ namespace ICSharpCode.PackageManagement.Design
 		public PackageManagementOptions Options {
 			get { return options; }
 		}
+		
+		public void ClearPackageSources()
+		{
+			options.PackageSources.Clear();
+		}
+		
+		public void AddOnePackageSource()
+		{
+			var source = new PackageSource("http://sharpdevelop.codeplex.com", "Test");
+			options.PackageSources.Add(source);
+		}
+		
+		public bool HasMultiplePackageSources { get; set; }
+		
+		public void AddPackageSources(IEnumerable<PackageSource> sources)
+		{
+			foreach (PackageSource source in sources) {
+				options.PackageSources.Add(source);
+			}
+		}
+		
+		public PackageSource ActivePackageSource { get; set; }
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementService.cs

@@ -19,5 +19,8 @@ namespace ICSharpCode.PackageManagement
 		void UninstallPackage(IPackageRepository repository, IPackage package);
 
 		PackageManagementOptions Options { get; }
+		
+		bool HasMultiplePackageSources { get; }
+		PackageSource ActivePackageSource { get; set; }
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementService.cs

@@ -17,6 +17,7 @@ namespace ICSharpCode.PackageManagement
 		IPackageManagerFactory packageManagerFactory;
 		IPackageManagementProjectService projectService;
 		IPackageRepository activePackageRepository;
+		PackageSource activePackageSource;
 		
 		public PackageManagementService(PackageManagementOptions options,
 			ISharpDevelopPackageRepositoryFactory packageRepositoryFactory,
@@ -66,8 +67,7 @@ namespace ICSharpCode.PackageManagement
 		IPackageRepository GetActivePackageRepository()
 		{
 			if (activePackageRepository == null) {
-				PackageSource packageSource = options.PackageSources[0];
-				activePackageRepository =  packageRepositoryFactory.CreateRepository(packageSource);
+				activePackageRepository = packageRepositoryFactory.CreateRepository(ActivePackageSource);
 			}
 			return activePackageRepository;
 		}
@@ -104,5 +104,24 @@ namespace ICSharpCode.PackageManagement
 			projectService.RefreshProjectBrowser();
 			OnPackageUninstalled();
 		}
+		
+		public bool HasMultiplePackageSources {
+			get { return options.PackageSources.HasMultiplePackageSources; }
+		}
+		
+		public PackageSource ActivePackageSource {
+			get {
+				if (activePackageSource == null) {
+					activePackageSource = options.PackageSources[0];
+				}
+				return activePackageSource;
+			}
+			set {
+				if (activePackageSource != value) {
+					activePackageSource = value;
+					activePackageRepository = null;
+				}
+			}
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/PackagesView.xaml

@@ -22,7 +22,11 @@
 			UriSource="pack://application:,,,/PackageManagement;component/Resources/magnifier.png"/>
 		<BooleanToVisibilityConverter x:Key="BoolToVisibility"/>
 		
-		<DataTemplate x:Key="PackagesListBoxTemplate">
+		<DataTemplate x:Key="PackageSourceComboBoxItemTemplate">
+			<TextBlock Text="{Binding Path=Name}"/>
+		</DataTemplate>
+		
+		<DataTemplate x:Key="PackageListBoxItemTemplate">
 			<Grid>
 				<Grid.ColumnDefinitions>
 					<ColumnDefinition Width="60"/>
@@ -224,7 +228,7 @@
 				x:Name="allPackagesListBox"
 				Grid.Row="0"
 				SelectedIndex="0"
-				ItemTemplate="{StaticResource PackagesListBoxTemplate}"
+				ItemTemplate="{StaticResource PackageListBoxItemTemplate}"
 				ItemsSource="{Binding Path=PackageViewModels}"
 				HorizontalContentAlignment="Stretch"
 				ScrollViewer.HorizontalScrollBarVisibility="Disabled"/>
@@ -252,11 +256,25 @@
 					<ColumnDefinition />
 					<ColumnDefinition Width="Auto"/>
 				</Grid.ColumnDefinitions>
+				<Grid.RowDefinitions>
+					<RowDefinition Height="Auto"/>
+					<RowDefinition Height="Auto"/>
+				</Grid.RowDefinitions>
+				<ComboBox 
+					Grid.Row="0"
+					Grid.ColumnSpan="2"
+					Margin="0, 0, 0, 2"
+					SelectedItem="{Binding Path=SelectedPackageSource}"
+					ItemsSource="{Binding Path=PackageSources}"
+					ItemTemplate="{StaticResource PackageSourceComboBoxItemTemplate}"
+					Visibility="{Binding Path=ShowPackageSources, Converter={StaticResource BoolToVisibility}}"/>
 				<TextBox
+					Grid.Row="1"
 					Grid.Column="0"
 					pm:TextBoxBehaviour.EnterKeyCommand="{Binding Path=SearchCommand}"
 					Text="{Binding Path=SearchTerms, UpdateSourceTrigger=PropertyChanged}"/>
 				<TextBlock 
+					Grid.Row="1"
 					Grid.Column="1"
 					Margin="4">
 					<Hyperlink 

src/AddIns/Misc/PackageManagement/Project/Src/PackagesViewModel.cs

@@ -238,9 +238,7 @@ namespace ICSharpCode.PackageManagement
 			SelectedPageNumber = pageNumber;
 		}
 		
-		public bool IsSearchable {
-			get; set;
-		}
+		public bool IsSearchable { get; set; }
 		
 		public string SearchTerms {
 			get { return searchTerms; }
@@ -252,5 +250,22 @@ namespace ICSharpCode.PackageManagement
 			ReadPackages();
 			OnPropertyChanged(null);
 		}
+		
+		public bool ShowPackageSources { get; set; }
+		
+		public IEnumerable<PackageSource> PackageSources {
+			get { return packageManagementService.Options.PackageSources; }
+		}
+		
+		public PackageSource SelectedPackageSource {
+			get { return packageManagementService.ActivePackageSource; }
+			set {
+				if (packageManagementService.ActivePackageSource != value) {
+					packageManagementService.ActivePackageSource = value;
+					ReadPackages();
+					OnPropertyChanged(null);
+				}
+			}
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/RegisteredPackageSources.cs

@@ -42,15 +42,8 @@ namespace ICSharpCode.PackageManagement
 			get { return Count == 0; }
 		}
 		
-//		protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
-//		{
-//			options.UpdateSavedPackageSources();
-//			base.OnCollectionChanged(e);
-//		}
-//		
-//		void UpdateSavedPackageSources()
-//		{
-//			options.SavedRegisteredPackageSources = PackageSourceConverter.ConvertToRegisteredPackageSourcesList(this);
-//		}
+		public bool HasMultiplePackageSources {
+			get { return Count > 1; }
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/AvailablePackagesViewModelTests.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
+using NuGet;
 using NUnit.Framework;
 using PackageManagement.Tests.Helpers;
 
@@ -17,11 +18,74 @@ namespace PackageManagement.Tests
 		FakePackageManagementService packageManagementService;
 		
 		void CreateViewModel()
+		{
+			CreatePackageManagementService();
+			CreateViewModel(packageManagementService);
+		}
+		
+		void CreatePackageManagementService()
 		{
 			packageManagementService = new FakePackageManagementService();
+		}
+		
+		void CreateViewModel(IPackageManagementService packageManagementService)
+		{
 			viewModel = new AvailablePackagesViewModel(packageManagementService);
 		}
 		
+		void AddOnePackageSourceToRegisteredSources()
+		{
+			packageManagementService.ClearPackageSources();
+			packageManagementService.AddOnePackageSource();
+			packageManagementService.HasMultiplePackageSources = false;
+		}
+		
+		void AddTwoPackageSourcesToRegisteredSources()
+		{
+			var expectedPackageSources = new PackageSource[] {
+				new PackageSource("http://first.com", "First"),
+				new PackageSource("http://second.com", "Second")
+			};
+			AddPackageSourcesToRegisteredSources(expectedPackageSources);
+			packageManagementService.HasMultiplePackageSources = true;
+		}
+				
+		void AddPackageSourcesToRegisteredSources(PackageSource[] sources)
+		{
+			packageManagementService.ClearPackageSources();
+			packageManagementService.AddPackageSources(sources);
+		}
+		
+		void CreateNewActiveRepositoryWithDifferentPackages()
+		{
+			var package = new FakePackage("NewRepositoryPackageId");
+			var newRepository = new FakePackageRepository();
+			newRepository.FakePackages.Add(package);
+			packageManagementService.FakeActivePackageRepository = newRepository;
+		}
+		
+		void SetUpTwoPackageSourcesAndViewModelHasReadPackages()
+		{
+			CreatePackageManagementService();
+			AddTwoPackageSourcesToRegisteredSources();
+			CreateViewModel(packageManagementService);
+			packageManagementService.ActivePackageSource = packageManagementService.Options.PackageSources[0];
+			viewModel.ReadPackages();	
+			CreateNewActiveRepositoryWithDifferentPackages();
+		}
+		
+		void ChangeSelectedPackageSourceToSecondSource()
+		{
+			var secondPackageSource = packageManagementService.Options.PackageSources[1];
+			viewModel.SelectedPackageSource = secondPackageSource;
+		}
+		
+		void ChangeSelectedPackageSourceToFirstSource()
+		{
+			var firstPackageSource = packageManagementService.Options.PackageSources[0];
+			viewModel.SelectedPackageSource = firstPackageSource;
+		}
+		
 		[Test]
 		public void ReadPackages_RepositoryHasThreePackagesWithSameIdButDifferentVersions_HasLatestPackageVersionOnly()
 		{
@@ -140,5 +204,121 @@ namespace PackageManagement.Tests
 			PackageCollectionAssert.AreEqual(expectedPackages, viewModel.PackageViewModels);
 			Assert.IsTrue(collectionChangedEventFired);
 		}
+		
+		[Test]
+		public void ShowSources_TwoPackageSources_ReturnsTrue()
+		{
+			CreatePackageManagementService();
+			AddTwoPackageSourcesToRegisteredSources();
+			CreateViewModel(packageManagementService);
+			
+			Assert.IsTrue(viewModel.ShowPackageSources);
+		}
+		
+		[Test]
+		public void ShowPackageSources_OnePackageSources_ReturnsFalse()
+		{
+			CreatePackageManagementService();
+			AddOnePackageSourceToRegisteredSources();
+			CreateViewModel(packageManagementService);
+			
+			Assert.IsFalse(viewModel.ShowPackageSources);
+		}
+		
+		[Test]
+		public void PackageSources_TwoPackageSourcesInOptions_HasTwoRepositoriesInCollection()
+		{
+			CreatePackageManagementService();
+			AddTwoPackageSourcesToRegisteredSources();
+			CreateViewModel(packageManagementService);
+			
+			var expectedPackageSources = packageManagementService.Options.PackageSources;
+			
+			PackageSourceCollectionAssert.AreEqual(expectedPackageSources, viewModel.PackageSources);
+		}
+		
+		[Test]
+		public void SelectedPackageSource_TwoPackageSourcesInOptionsAndActivePackageSourceIsFirstSource_IsFirstPackageSource()
+		{
+			CreatePackageManagementService();
+			AddTwoPackageSourcesToRegisteredSources();
+			CreateViewModel(packageManagementService);
+			
+			var expectedPackageSource = packageManagementService.Options.PackageSources[0];
+			packageManagementService.ActivePackageSource = expectedPackageSource;
+			
+			Assert.AreEqual(expectedPackageSource, viewModel.SelectedPackageSource);
+		}
+		
+		[Test]
+		public void SelectedPackageSource_TwoPackageSourcesInOptionsAndActivePackageSourceIsSecondSource_IsSecondPackageSource()
+		{
+			CreatePackageManagementService();
+			AddTwoPackageSourcesToRegisteredSources();
+			CreateViewModel(packageManagementService);
+			
+			var expectedPackageSource = packageManagementService.Options.PackageSources[1];
+			packageManagementService.ActivePackageSource = expectedPackageSource;
+			
+			Assert.AreEqual(expectedPackageSource, viewModel.SelectedPackageSource);
+		}
+		
+		[Test]
+		public void SelectedPackageSource_Changed_PackageManagementServiceActivatePackageSourceChanged()
+		{
+			CreatePackageManagementService();
+			AddTwoPackageSourcesToRegisteredSources();
+			CreateViewModel(packageManagementService);
+			
+			packageManagementService.ActivePackageSource = packageManagementService.Options.PackageSources[0];
+			var expectedPackageSource = packageManagementService.Options.PackageSources[1];
+			viewModel.SelectedPackageSource = expectedPackageSource;
+			
+			Assert.AreEqual(expectedPackageSource, packageManagementService.ActivePackageSource);
+		}
+		
+		[Test]
+		public void SelectedPackageSource_PackageSourceChangedAfterReadingPackages_PackagesReadFromNewPackageSourceAndDisplayed()
+		{
+			SetUpTwoPackageSourcesAndViewModelHasReadPackages();
+			ChangeSelectedPackageSourceToSecondSource();
+			
+			var expectedPackages = packageManagementService.FakeActivePackageRepository.FakePackages;
+			
+			PackageCollectionAssert.AreEqual(expectedPackages, viewModel.PackageViewModels);
+		}
+		
+		[Test]
+		public void SelectedPackageSource_PackageSourceChangedAfterReadingPackages_PropertyChangedEventFiredAfterPackagesAreRead()
+		{
+			SetUpTwoPackageSourcesAndViewModelHasReadPackages();
+			
+			int packageCountWhenPropertyChangedEventFired = -1;
+			viewModel.PropertyChanged += (sender, e) => packageCountWhenPropertyChangedEventFired = viewModel.PackageViewModels.Count;
+			ChangeSelectedPackageSourceToSecondSource();
+			
+			Assert.AreEqual(1, packageCountWhenPropertyChangedEventFired);
+		}
+		
+		[Test]
+		public void SelectedPackageSource_PackageSourceChangedButToSameSelectedPackageSource_PackagesAreNotRead()
+		{
+			SetUpTwoPackageSourcesAndViewModelHasReadPackages();
+			ChangeSelectedPackageSourceToFirstSource();
+			
+			Assert.AreEqual(0, viewModel.PackageViewModels.Count);
+		}
+		
+		[Test]
+		public void SelectedPackageSource_PackageSourceChangedButToSameSelectedPackageSource_PropertyChangedEventNotFired()
+		{
+			SetUpTwoPackageSourcesAndViewModelHasReadPackages();
+			
+			bool fired = false;
+			viewModel.PropertyChanged += (sender, e) => fired = true;
+			ChangeSelectedPackageSourceToFirstSource();
+			
+			Assert.IsFalse(fired);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/OneRegisteredPackageSourceHelper.cs

@@ -24,8 +24,19 @@ namespace PackageManagement.Tests.Helpers
 			Properties properties = new Properties();
 			Options = new PackageManagementOptions(properties);
 			RegisteredPackageSources = Options.PackageSources;
+			AddOnePackageSource();
+		}
+		
+		public void AddOnePackageSource()
+		{
 			RegisteredPackageSources.Clear();
 			RegisteredPackageSources.Add(PackageSource);
 		}
+		
+		public void AddTwoPackageSources()
+		{			
+			AddOnePackageSource();
+			RegisteredPackageSources.Add(new PackageSource("http://second.codeplex.com", "second"));
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementServiceTests.cs

@@ -219,5 +219,100 @@ namespace PackageManagement.Tests
 			
 			Assert.AreEqual(expectedPackage, package);
 		}
+		
+		[Test]
+		public void HasMultiplePackageSources_OnePackageSource_ReturnsFalse()
+		{
+			CreatePackageManagementService();
+			packageSourcesHelper.AddOnePackageSource();
+			
+			bool result = packageManagementService.HasMultiplePackageSources;
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void HasMultiplePackageSources_TwoPackageSources_ReturnsTrue()
+		{
+			CreatePackageManagementService();
+			packageSourcesHelper.AddTwoPackageSources();
+			
+			bool result = packageManagementService.HasMultiplePackageSources;
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void ActivePackageSource_TwoPackageSources_ByDefaultReturnsFirstPackageSource()
+		{
+			CreatePackageManagementService();
+			packageSourcesHelper.AddTwoPackageSources();
+			
+			var expectedPackageSource = packageManagementService.Options.PackageSources[0];
+			var packageSource = packageManagementService.ActivePackageSource;
+			
+			Assert.AreEqual(expectedPackageSource, packageSource);
+		}
+		
+		[Test]
+		public void ActivePackageSource_ChangedToSecondRegisteredPackageSources_ReturnsSecondPackageSource()
+		{
+			CreatePackageManagementService();
+			packageSourcesHelper.AddTwoPackageSources();
+			
+			var expectedPackageSource = packageManagementService.Options.PackageSources[1];
+			packageManagementService.ActivePackageSource = expectedPackageSource;
+			var packageSource = packageManagementService.ActivePackageSource;
+			
+			Assert.AreEqual(expectedPackageSource, packageSource);
+		}
+		
+		[Test]
+		public void ActivePackageRepository_ActivePackageSourceChangedToSecondRegisteredPackageSource_CreatesRepositoryUsingSecondPackageSource()
+		{
+			CreatePackageManagementService();
+			packageSourcesHelper.AddTwoPackageSources();
+			
+			var expectedPackageSource = packageManagementService.Options.PackageSources[1];
+			packageManagementService.ActivePackageSource = expectedPackageSource;
+			
+			IPackageRepository repository = packageManagementService.ActivePackageRepository;
+			var packageSource = fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository[0];
+			
+			Assert.AreEqual(expectedPackageSource, packageSource);
+		}
+		
+		[Test]
+		public void ActivePackageRepository_ActivePackageSourceChangedAfterActivePackageRepositoryCreated_CreatesNewRepositoryUsingActivePackageSource()
+		{
+			CreatePackageManagementService();
+			packageSourcesHelper.AddTwoPackageSources();
+			
+			IPackageRepository initialRepository = packageManagementService.ActivePackageRepository;
+			fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository.Clear();
+			
+			var expectedPackageSource = packageManagementService.Options.PackageSources[1];
+			packageManagementService.ActivePackageSource = expectedPackageSource;
+			
+			IPackageRepository repository = packageManagementService.ActivePackageRepository;
+			var packageSource = fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository[0];
+			
+			Assert.AreEqual(expectedPackageSource, packageSource);
+		}
+		
+		[Test]
+		public void ActivePackageRepository_ActivePackageSourceSetToSameValueAfterActivePackageRepositoryCreated_NewRepositoryNotCreated()
+		{
+			CreatePackageManagementService();
+			packageSourcesHelper.AddOnePackageSource();
+			
+			IPackageRepository initialRepository = packageManagementService.ActivePackageRepository;
+			fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository.Clear();
+			
+			var expectedPackageSource = packageManagementService.Options.PackageSources[0];
+			packageManagementService.ActivePackageSource = expectedPackageSource;
+			
+			IPackageRepository repository = packageManagementService.ActivePackageRepository;
+			
+			Assert.AreEqual(0, fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository.Count);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/PackagesViewModelTests.cs

@@ -711,5 +711,13 @@ namespace PackageManagement.Tests
 			
 			PageCollectionAssert.AreEqual(expectedPages, pages);
 		}
+		
+		[Test]
+		public void ShowPackageSources_ByDefault_ReturnsFalse()
+		{
+			CreateViewModel();
+			
+			Assert.IsFalse(viewModel.ShowPackageSources);
+		}
 	}
 }