public void PackageViewModels_GetParentOfPackageViewModel_ReturnsAvailablePackagesViewModel()
{
CreateViewModel();
AddOnePackageSourceToRegisteredSources();
var package1 = new FakePackage("Test", "0.1.0.0");
var package2 = new FakePackage("Test", "0.2.0.0");
var packages = new FakePackage[] {
package1, package2
};
registeredPackageRepositories.FakeActiveRepository.FakePackages.AddRange(packages);
viewModel.ReadPackages();
CompleteReadPackagesTask();
PackageViewModel childViewModel = viewModel.PackageViewModels.First();
IPackageViewModelParent parent = childViewModel.GetParent();
Assert.AreEqual(viewModel, parent);
}
public void Execute_ProjectHasOnePackageInstallOperationThatHasALicenseToBeAcceptedAndLicensesNotAccepted_ExceptionThrown()
{
CreateAction();
FakePackage expectedPackage = fakeProject.FakeSourceRepository.AddFakePackageWithVersion("Test", "1.0");
expectedPackage.RequireLicenseAcceptance = true;
var operation = new FakePackageOperation(expectedPackage, PackageAction.Install);
action.PackageId = expectedPackage.Id;
action.PackageVersion = expectedPackage.Version;
fakeProject.FakeInstallOperations.Add(operation);
packageManagementEvents.AcceptLicenses += (sender, e) => {
e.IsAccepted = false;
};
Exception ex = Assert.Throws(typeof(ApplicationException), () => action.Execute());
Assert.AreEqual("Licenses not accepted.", ex.Message);
}
public void ReadPackages_RepositoryHasPrereleasePackageAndIncludePrereleaseIsTrue_HasPrereleasePackageInList()
{
CreateViewModel();
AddOnePackageSourceToRegisteredSources();
viewModel.IncludePrerelease = true;
var prereleasePackage = new FakePackage("Test", "1.1.0-alpha")
{
IsLatestVersion = false,
IsAbsoluteLatestVersion = true
};
var expectedPackages = new FakePackage[] { prereleasePackage };
registeredPackageRepositories.FakeActiveRepository.FakePackages.AddRange(expectedPackages);
viewModel.ReadPackages();
CompleteReadPackagesTask();
PackageCollectionAssert.AreEqual(expectedPackages, viewModel.PackageViewModels);
}
public void UninstallPackage_PackageReferencedByTwoProjects_PackageIsNotRemovedFromSharedSolutionRepository()
{
CreatePackageManager();
CreateTestableProjectManager();
var package = new FakePackage("MyPackageId", "1.4.5.2");
testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
fakeSolutionSharedRepository.FakePackages.Add(package);
fakeSolutionSharedRepository.PackageIdsReferences.Add("MyPackageId");
packageManager.UninstallPackage(package);
bool containsPackage = fakeSolutionSharedRepository.FakePackages.Contains(package);
Assert.IsTrue(containsPackage);
Assert.AreEqual("MyPackageId", fakeSolutionSharedRepository.PackageIdPassedToIsReferenced);
Assert.AreEqual(package.Version, fakeSolutionSharedRepository.VersionPassedToIsReferenced);
}
public void InstallPackage_OldPackageReferenceIsRemovedOnInstalling_OldPackageIsUninstalled()
{
CreatePackageManager();
var fakeProjectManager = new FakeProjectManager();
packageManager.ProjectManager = fakeProjectManager;
FakePackage installedPackage = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage", "1.0");
FakePackage newPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
var eventArgs = new PackageOperationEventArgs(installedPackage, null, null);
RaisePackageRemovedEventWhenPackageReferenceAdded(fakeProjectManager, newPackage, eventArgs);
var installAction = new FakeInstallPackageAction {
Operations = new List <PackageOperation> ()
};
packageManager.InstallPackage(newPackage, installAction);
Assert.IsFalse(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage));
}
public void GetPackagesFromPackageSource_RepositoryIsServiceBasedRepositoryAndPrereleaseIncluded_ServiceBasedRepositorySearchUsed()
{
CreateViewModel();
var package = FakePackage.CreatePackageWithVersion("Test", "0.1.0.0");
var packages = new FakePackage[] { package };
var repository = new FakeServiceBasedRepository();
repository.PackagesToReturnForSearch("id:test", true, packages);
registeredPackageRepositories.FakeActiveRepository = repository;
viewModel.SearchTerms = "id:test";
viewModel.IncludePrerelease = true;
viewModel.ReadPackages();
IList <IPackage> allPackages = viewModel.GetPackagesFromPackageSource().ToList();
var expectedPackages = new FakePackage[] { package };
PackageCollectionAssert.AreEqual(expectedPackages, allPackages);
}
public void ProcessRecord_FilterParameterPassedContainingTwoSearchTermsSeparatedBySpaceCharacter_InstallPackagesAreFilteredByBothSearchTerms()
{
CreateCmdlet();
AddPackageSourceToConsoleHost();
FakePackage packageA = fakeSolution.AddPackageToActiveProjectLocalRepository("A");
FakePackage packageB = fakeSolution.AddPackageToActiveProjectLocalRepository("B");
FakePackage packageC = fakeSolution.AddPackageToActiveProjectLocalRepository("C");
SetFilterParameter("B C");
RunCmdlet();
List <object> actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
var expectedPackages = new FakePackage[] {
packageB,
packageC
};
Assert.AreEqual(expectedPackages, actualPackages);
}
public void ProcessRecord_UpdatedPackagesRequestedWithFilter_ReturnsFilteredUpdatedPackages()
{
CreateCmdlet();
AddPackageToProjectManagerLocalRepository("A", "1.0.0.0");
AddPackageToAggregateRepository("A", "1.1.0.0");
AddPackageToProjectManagerLocalRepository("B", "2.0.0.0");
FakePackage updatedPackage = AddPackageToAggregateRepository("B", "2.1.0.0");
EnableUpdatesParameter();
SetFilterParameter("B");
RunCmdlet();
List <object> actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
var expectedPackages = new FakePackage[] {
updatedPackage
};
CollectionAssert.AreEqual(expectedPackages, actualPackages);
}
public void GetPackagesInstalledInSolution_PackageInstalledInSolutionAndProjectNotSelected_ReturnsPackageInstalledInSolution()
{
CreateFakeSolution();
List <IProject> projectsAddedToSolution = AddSolutionWithTwoProjectsToProjectService();
NoProjectsSelected();
var package = new FakePackage("Test");
fakeSolution.FakeInstalledPackages.Add(package);
CreateSelectedProjects();
IQueryable <IPackage> packages = selectedProjects.GetPackagesInstalledInSolution();
var expectedPackages = new FakePackage[] {
package
};
PackageCollectionAssert.AreEqual(expectedPackages, packages);
}
public void ReadPackages_PackagesReturnedNotSortedFromRepository_PackagesDisplayedSortedById()
{
CreateViewModel();
viewModel.AddFakePackage("Z");
viewModel.AddFakePackage("C");
viewModel.AddFakePackage("A");
viewModel.AddFakePackage("B");
viewModel.ReadPackages();
CompleteReadPackagesTask();
var expectedPackages = new FakePackage[] {
viewModel.FakePackages[2],
viewModel.FakePackages[3],
viewModel.FakePackages[1],
viewModel.FakePackages[0]
};
PackageCollectionAssert.AreEqual(expectedPackages, viewModel.PackageViewModels);
}
public void ProcessRecord_ListAvailableAndSkipFirstTwoPackages_ReturnsAllPackagesExceptionFirstTwo()
{
CreateCmdlet();
FakePackageRepository repository = fakeRegisteredPackageRepositories.FakePackageRepository;
repository.AddFakePackage("A");
repository.AddFakePackage("B");
FakePackage packageC = repository.AddFakePackage("C");
EnableListAvailableParameter();
SetSkipParameter(2);
RunCmdlet();
List <object> actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
var expectedPackages = new FakePackage[] {
packageC
};
CollectionAssert.AreEqual(expectedPackages, actualPackages);
}
public void Execute_PackageHasPowerShellUninstallScript_PowerShellInfoLogged()
{
CreateAction();
FakePackage package = FakePackage.CreatePackageWithVersion("Test", "1.0");
action.Package = package;
package.AddFile(@"tools\uninstall.ps1");
var messagesLogged = new List <string> ();
packageManagementEvents.PackageOperationMessageLogged += (sender, e) => {
if (e.Message.Level == MessageLevel.Info)
{
messagesLogged.Add(e.Message.ToString());
}
};
action.Execute();
Assert.That(messagesLogged, Contains.Item("WARNING: Test Package contains PowerShell scripts which will not be run."));
}
public void ProcessRecord_RecentPackagesRequestedWithFilter_FilteredRecentPackagesReturned()
{
CreateCmdlet();
FakePackageRepository recentPackageRepository = fakeRegisteredPackageRepositories.FakeRecentPackageRepository;
recentPackageRepository.AddFakePackage("A");
FakePackage packageB = recentPackageRepository.AddFakePackage("B");
EnableRecentParameter();
SetFilterParameter("B");
RunCmdlet();
List <object> actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
var expectedPackages = new FakePackage[] {
packageB
};
Assert.AreEqual(expectedPackages, actualPackages);
}
public void CreatePackageManager_PackagesSolutionFolderDefinedInOptions_PackageManagerPathResolverUsesPackagesFolderInsideSolutionFolder()
{
CreateFactory();
CreateTestProject();
testProject.ParentSolution.FileName = @"c:\projects\MyProject\MySolution.sln";
options.PackagesDirectory = "packages";
CreatePackageManager();
FakePackage package = new FakePackage();
package.Id = "TestPackage";
package.Version = new Version(1, 0, 0, 0);
string expectedDirectory = @"c:\projects\MyProject\packages\TestPackage.1.0.0.0";
SharpDevelopPackageManager sharpDevelopPackageManager = packageManager as SharpDevelopPackageManager;
string actualDirectory = sharpDevelopPackageManager.PathResolver.GetInstallPath(package);
Assert.AreEqual(expectedDirectory, actualDirectory);
}
public void PackageViewModels_PackageIsUninstalledAfterRecentPackagesDisplayed_PackagesOnDisplayAreUpdated()
{
CreateViewModel();
viewModel.ReadPackages();
CompleteReadPackagesTask();
var package = new FakePackage("Test");
FakePackageRepository repository = packageManagementService.FakeRecentPackageRepository;
repository.FakePackages.Add(package);
ClearReadPackagesTasks();
packageManagementService.FirePackageUninstalled();
CompleteReadPackagesTask();
var expectedPackages = new FakePackage[] {
package
};
PackageCollectionAssert.AreEqual(expectedPackages, viewModel.PackageViewModels);
}
public void Execute_PackageHasPowerShellInstallScript_NoPowerShellWarningLogged()
{
CreateAction();
FakePackage package = FakePackage.CreatePackageWithVersion("Test", "1.0");
action.Package = package;
package.AddFile(@"tools\install.ps1");
bool messageLogged = false;
packageManagementEvents.PackageOperationMessageLogged += (sender, e) => {
if (e.Message.Level == MessageLevel.Warning)
{
messageLogged = true;
}
};
action.Execute();
Assert.IsFalse(messageLogged);
}
public void GetUpdatedPackages_OnePackageHasUpdatesAndNewerVersionButNotLatestIsInstalled_UpdatesStillShowAsAvailable()
{
CreateUpdatedPackagesInSolution();
FakePackageManagementProject project = AddProjectToSolution();
project.AddPackageReference("MyPackage", "1.0");
var newerPackage = new FakePackage("MyPackage", "1.1");
FakePackage updatedPackage = AddUpdatedPackageToAggregateSourceRepository("MyPackage", "1.9");
updatedPackagesInSolution.CheckForUpdates();
project.PackageReferences.Clear();
project.AddPackageReference("MyPackage", "1.1");
packageManagementEvents.OnParentPackageInstalled(newerPackage, project);
UpdatedPackagesInProject updatedPackages = updatedPackagesInSolution.GetUpdatedPackages(project.Project);
Assert.AreEqual(1, updatedPackages.GetPackages().Count());
Assert.AreEqual("MyPackage", updatedPackages.GetPackages().First().Id);
Assert.AreEqual("1.9", updatedPackages.GetPackages().First().Version.ToString());
}
public void Execute_PackageHasPowerShellUninstallScript_PowerShellWarningLogged()
{
CreateAction();
FakePackage package = FakePackage.CreatePackageWithVersion("Test", "1.0");
action.Package = package;
package.AddFile(@"tools\uninstall.ps1");
string messageLogged = null;
packageManagementEvents.PackageOperationMessageLogged += (sender, e) => {
if (e.Message.Level == MessageLevel.Warning)
{
messageLogged = e.Message.ToString();
}
};
action.Execute();
Assert.AreEqual("Test Package contains PowerShell scripts which will not be run.", messageLogged);
}
public void PackageViewModels_PackageReferenceIsRemoved_PackageViewModelsIsUpdated()
{
CreateViewModel();
FakePackage package = new FakePackage();
package.Id = "Test";
FakePackageRepository repository = packageManagementService.FakeActiveProjectManager.FakeLocalRepository;
repository.FakePackages.Add(package);
viewModel.ReadPackages();
CompleteReadPackagesTask();
repository.FakePackages.Clear();
ClearReadPackagesTasks();
packageManagementService.FirePackageUninstalled();
CompleteReadPackagesTask();
Assert.AreEqual(0, viewModel.PackageViewModels.Count);
}
public void GetUpdatedPackages_TwoPackagesInstalledOneUpdatedWhichUpdatesItsDependency_NoUpdatesAvailable()
{
CreateUpdatedPackagesInSolution();
FakePackageManagementProject project = AddProjectToSolution();
project.AddPackageReference("One", "1.0");
project.AddPackageReference("Two", "1.0");
FakePackage updatedPackage = AddUpdatedPackageToAggregateSourceRepository("One", "1.1");
AddUpdatedPackageToAggregateSourceRepository("Two", "1.1");
updatedPackagesInSolution.CheckForUpdates();
project.PackageReferences.Clear();
project.AddPackageReference("One", "1.1");
project.AddPackageReference("Two", "1.1");
packageManagementEvents.OnParentPackageInstalled(updatedPackage, project);
UpdatedPackagesInProject updatedPackages = updatedPackagesInSolution.GetUpdatedPackages(project.Project);
Assert.AreEqual(0, updatedPackages.GetPackages().Count());
}
void ProjectHasOnePackageReferenceNeedingReinstall(string packageId)
{
var package = FakePackage.CreatePackageWithVersion(packageId, "1.2.3.4");
package.AddFile(@"lib\net45\MyPackage.dll");
package.AddFile(@"lib\net40\MyPackage.dll");
FakePackageManagementProject packageManagementProject =
solution.AddFakeProjectToReturnFromGetProject(project.Name);
packageManagementProject.FakePackages.Add(package);
string xml = String.Format(
@"<packages>
<package id='{0}' version='1.2.3.4' targetFramework='net40'/>
</packages>" ,
packageId);
SetProjectPackagesConfigFileContents(xml);
}
public TestableUpdatedPackageViewModel(
IPackageViewModelParent parent,
FakePackage package,
SelectedProjectsForUpdatedPackages selectedProjects,
FakePackageManagementEvents packageManagementEvents,
FakePackageActionRunner actionRunner,
FakeLogger logger)
: base(
parent,
package,
selectedProjects,
packageManagementEvents,
actionRunner,
logger)
{
this.FakePackage = package;
this.FakeActionRunner = actionRunner;
this.FakeLogger = logger;
this.FakePackageManagementEvents = packageManagementEvents;
}
public void PackageViewModels_PackageReferenceIsAdded_PackageViewModelsIsUpdated()
{
CreateViewModel();
viewModel.ReadPackages();
CompleteReadPackagesTask();
FakePackage package = new FakePackage();
package.Id = "Test";
FakePackageRepository repository = packageManagementService.FakeActiveProjectManager.FakeLocalRepository;
repository.FakePackages.Add(package);
ClearReadPackagesTasks();
packageManagementService.FirePackageInstalled();
CompleteReadPackagesTask();
IPackage firstPackage = viewModel.PackageViewModels[0].GetPackage();
Assert.AreEqual(package, firstPackage);
}
public void UninstallPackage_ProjectLocalRepositoryHasPackage_PackageRemovedFromProjectRepositoryBeforeSolutionRepository()
{
CreatePackageManager();
CreateTestableProjectManager();
FakePackage package = CreateFakePackage();
package.Id = "Test";
testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
IPackage packageRemovedFromProject = null;
packageManager.PackageUninstalled += (sender, e) => {
packageRemovedFromProject = testableProjectManager.PackagePassedToRemovePackageReference;
};
packageManager.UninstallPackage(package);
Assert.AreEqual("Test", packageRemovedFromProject.Id);
}
public void UpdatePackage_OldPackageReferenceIsRemovedOnUpdating_OldPackageIsUninstalled()
{
CreatePackageManager();
var fakeProjectManager = MockRepository.GenerateStub <ISharpDevelopProjectManager>();
packageManager.ProjectManager = fakeProjectManager;
FakePackage installedPackage = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage", "1.0");
FakePackage updatedPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
var eventArgs = new PackageOperationEventArgs(installedPackage, null, null);
RaisePackageRemovedEventWhenPackageReferenceUpdated(fakeProjectManager, updatedPackage, eventArgs);
var updateAction = new FakeUpdatePackageAction {
Operations = new List <PackageOperation>(),
UpdateDependencies = false
};
packageManager.UpdatePackage(updatedPackage, updateAction);
Assert.IsFalse(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage));
}
public void Execute_ProjectHasOneUnrestoredPackage_PackageRestoredEventFiredForPackage()
{
FakePackageManagementProject project = CreateSolutionWithOneProject();
project.AddPackageReference("MyPackage", "1.0");
FakePackage package = AddPackageToPriorityRepository("MyPackage", "1.0");
CreateAction();
CapturePackageRestoredEvents();
var dotNetProject = new FakeDotNetProject();
dotNetProject.Name = "MyProject";
solution.FakeProjectsToReturnFromGetProject.Add("MyProject", project);
action.Project = dotNetProject;
action.Execute();
PackageRestoredEventArgs eventArgs = packageRestoredEvents [0];
Assert.AreEqual(package, eventArgs.Package);
}
public void GetUpdatedPackages_OnePackageUpdatedSameUnderlyingDotNetProjectButDifferentProxy_OneUpdatedPackageFoundForProject()
{
CreateUpdatedPackagesInSolution();
FakePackageManagementProject project = AddProjectToSolution();
project.AddPackageReference("MyPackage", "1.0");
FakePackage updatedPackage = AddUpdatedPackageToAggregateSourceRepository("MyPackage", "1.1");
var expectedPackages = new FakePackage [] { updatedPackage };
var newProject = new FakeDotNetProject();
project.FakeDotNetProject.EqualsAction = p => {
return(p == newProject);
};
updatedPackagesInSolution.CheckForUpdates();
UpdatedPackagesInProject updatedPackages = updatedPackagesInSolution.GetUpdatedPackages(newProject);
Assert.IsNotNull(updatedPackages.Project);
CollectionAssert.AreEqual(expectedPackages, updatedPackages.GetPackages());
Assert.AreNotEqual(newProject, updatedPackages.Project);
}
public void ProcessRecord_ListAvailablePackagesAndFilterResults_PackagesReturnedMatchFilter()
{
CreateCmdlet();
FakePackageRepository repository = fakeRegisteredPackageRepositories.FakePackageRepository;
repository.AddFakePackage("A");
FakePackage package = repository.AddFakePackage("B");
repository.AddFakePackage("C");
EnableListAvailableParameter();
SetFilterParameter("B");
RunCmdlet();
List <object> actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
var expectedPackages = new FakePackage[] {
package
};
CollectionAssert.AreEqual(expectedPackages, actualPackages);
}
public void InstallPackage_OldPackageReferenceIsRemovedOnInstallingButOtherProjectsReferencesOldPackage_OldPackageIsNotUninstalled()
{
CreatePackageManager();
var fakeProjectManager = MockRepository.GenerateStub <ISharpDevelopProjectManager>();
packageManager.ProjectManager = fakeProjectManager;
FakePackage installedPackage = fakeSolutionSharedRepository.AddFakePackageWithVersion("MyPackage.Core", "1.0");
FakePackage newPackage = fakeFeedSourceRepository.AddFakePackageWithVersion("MyPackage", "1.1");
fakeSolutionSharedRepository.PackageIdsReferences.Add("MyPackage.Core");
var eventArgs = new PackageOperationEventArgs(installedPackage, null, null);
RaisePackageRemovedEventWhenPackageReferenceAdded(fakeProjectManager, newPackage, eventArgs);
var installAction = new FakeInstallPackageAction {
Operations = new List <PackageOperation>()
};
packageManager.InstallPackage(newPackage, installAction);
Assert.IsTrue(fakeSolutionSharedRepository.FakePackages.Contains(installedPackage));
}
public void ProcessRecord_ListAvailablePackagesAndAllVersionsAndTwoVersionsOfSamePackageInOnlineRepository_OutputIsAllPackageVersions()
{
CreateCmdlet();
FakePackage expectedPackage1 = AddPackageToSelectedRepositoryInConsoleHost("Test", "1.0");
expectedPackage1.IsLatestVersion = false;
FakePackage expectedPackage2 = AddPackageToSelectedRepositoryInConsoleHost("Test", "1.1");
EnableListAvailableParameter();
EnableAllVersionsParameter();
var expectedPackages = new FakePackage[] {
expectedPackage1,
expectedPackage2
};
RunCmdlet();
List <object> actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
CollectionAssert.AreEqual(expectedPackages, actualPackages);
}
