bool PackageOperationRequiresLicenseAcceptance(PackageOperation operation)
{
return
((operation.Action == PackageAction.Install) &&
operation.Package.RequireLicenseAcceptance &&
!IsPackageInstalledInSolution(operation.Package));
}
PackageOperation AddInstallOperationForPackage(IPackage package)
{
var operation = new PackageOperation(package, PackageAction.Install);
AddInstallOperationsForPackage(package, operation);
return(operation);
}
public Operation(
PackageOperation operation,
IProjectManager projectManager,
IPackageManager packageManager)
: base(operation.Package, operation.Action)
{
if (projectManager != null && packageManager != null)
{
throw new ArgumentException("Only one of packageManager and projectManager can be non-null");
}
if (operation.Target == PackageOperationTarget.PackagesFolder && packageManager == null)
{
throw new ArgumentNullException("packageManager");
}
if (operation.Target == PackageOperationTarget.Project && projectManager == null)
{
throw new ArgumentNullException("projectManager");
}
Target = operation.Target;
PackageManager = packageManager;
ProjectManager = projectManager;
if (ProjectManager != null)
{
_projectName = ProjectManager.Project.ProjectName;
}
}
public void InstallPackageWithOperationsExecuteAllOperations()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, dependencies: new PackageDependency[] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" });
sourceRepository.AddPackage(package2);
var package3 = PackageUtility.CreatePackage("awesome", "1.0", new[] { "candy" });
localRepository.AddPackage(package3);
var operations = new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
new PackageOperation(package3, PackageAction.Uninstall)
};
// Act
packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, logger: NullLogger.Instance);
// Assert
Assert.IsTrue(packageManager.LocalRepository.Exists(package));
Assert.IsTrue(packageManager.LocalRepository.Exists(package2));
Assert.IsTrue(!packageManager.LocalRepository.Exists(package3));
Assert.IsTrue(projectManager.LocalRepository.Exists(package));
Assert.IsTrue(projectManager.LocalRepository.Exists(package2));
}
private void Execute(PackageOperation operation)
{
bool isPackageInstalled = this.LocalRepository.Exists(operation.Package);
if (operation.Action == PackageAction.Install)
{
if (isPackageInstalled)
{
this.Logger.Log(MessageLevel.Info, NuGetResources.Log_PackageAlreadyInstalled, (object)operation.Package.GetFullName());
}
else if (this.WhatIf)
{
this.Logger.Log(MessageLevel.Info, NuGetResources.Log_InstallPackage, (object)operation.Package);
}
else
{
this.ExecuteInstall(operation.Package);
}
}
else
{
if (!isPackageInstalled)
{
return;
}
if (this.WhatIf)
{
this.Logger.Log(MessageLevel.Info, NuGetResources.Log_UninstallPackage, (object)operation.Package);
}
else
{
this.ExecuteUninstall(operation.Package);
}
}
}
public Operation(
PackageOperation operation,
IProjectManager projectManager,
IPackageManager packageManager)
: base(operation.Package, operation.Action)
{
if (projectManager != null && packageManager != null)
{
throw new ArgumentException("Only one of packageManager and projectManager can be non-null");
}
if (operation.Target == PackageOperationTarget.PackagesFolder && packageManager == null)
{
throw new ArgumentNullException("packageManager");
}
if (operation.Target == PackageOperationTarget.Project && projectManager == null)
{
throw new ArgumentNullException("projectManager");
}
Target = operation.Target;
PackageManager = packageManager;
ProjectManager = projectManager;
if (ProjectManager != null)
{
_projectName = ProjectManager.Project.ProjectName;
}
}
private static async Task RunDeletePackageAsync(PackageOperation packageOperation, CloudBlockBlob packageBlob, IAsyncCollector <PackageDocument> documentDeleteCollector)
{
// Delete from index blob
await packageBlob.DeleteIfExistsAsync();
// Add delete from index actions
await documentDeleteCollector.AddAsync(new PackageDocument(packageOperation.Id, packageOperation.Version));
}
private static async Task RunDeletePackageAsync(PackageOperation packageOperation, CloudBlockBlob packageBlob, ILogger log)
{
log.LogInformation("Deleting package {packageId}@{packageVersionNormalized} from blob storage...", packageOperation.Id, packageOperation.VersionNormalized);
await packageBlob.DeleteIfExistsAsync();
log.LogInformation("Deleted package {packageId}@{packageVersionNormalized} from blob storage.", packageOperation.Id, packageOperation.VersionNormalized);
}
public static List <PackageOperation> CreateListWithOneInstallOperationWithFile(string fileName)
{
PackageOperation operation = CreateInstallOperationWithFile(fileName);
var operations = new List <PackageOperation>();
operations.Add(operation);
return(operations);
}
public FakePackage AddPackageInstallOperation()
{
var package = new FakePackage("Package to install");
var operation = new PackageOperation(package, PackageAction.Install);
PackageOperations.Add(operation);
return(package);
}
public void Execute_UpdatePackagesActionWithOnePackageOperation_PackagesUpdatedUsingProject()
{
PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
CreateActionWithOperations(operation);
action.Execute();
project.AssertWasCalled(p => p.UpdatePackages(action));
}
public void HasPackageScriptsToRun_PackageHasInitPowerShellScript_ReturnsTrue()
{
PackageOperation operation = CreateInstallOperationWithFile(@"tools\install.ps1");
CreateActionWithOperations(operation);
bool result = action.HasPackageScriptsToRun();
Assert.IsTrue(result);
}
FakeInstallPackageAction CreateInstallActionWithOneOperation()
{
var operations = new PackageOperation[] {
new PackageOperation(new FakePackage(), PackageAction.Install)
};
FakeInstallPackageAction action = CreateInstallAction();
action.Operations = operations;
return(action);
}
public void HasPackageScriptsToRun_PackageHasOneTextFile_ReturnsFalse()
{
PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
CreateActionWithOperations(operation);
bool result = action.HasPackageScriptsToRun();
Assert.IsFalse(result);
}
FakePackage InstallPackageWithPackageOperations(PackageOperation operation)
{
var operations = new PackageOperation[] {
operation
};
FakePackage package = CreateFakePackage();
packageManager.InstallPackage(package, operations);
return(package);
}
internal void AddOperation(PackageOperation operation)
{
Dictionary <IPackage, PackageOperation> packageLookup = this.GetPackageLookup(operation.Action, true);
if (!packageLookup.ContainsKey(operation.Package))
{
packageLookup.Add(operation.Package, operation);
this._operations.Add(operation);
}
}
public static void Run(
[NuGetCatalogTrigger(CursorBlobName = nameof(Enqueuer))] PackageOperation packageOperation,
[Queue(Constants.IndexingQueue, Connection = Constants.IndexingQueueConnection)] ICollector <PackageOperation> queueCollector,
ILogger logger)
{
// Log
logger.LogInformation(packageOperation.Action + ": " + packageOperation.Id + "@" + packageOperation.Version);
// Forward...
queueCollector.Add(packageOperation);
}
public void Reduce_OnePackage_ReturnsPackageOperationsFromResolverForPackage()
{
CreateReducedPackageOperations();
IPackage package = AddPackage("Test", "1.0");
PackageOperation operation = AddInstallOperationForPackage(package);
reducedPackageOperations.Reduce();
Assert.AreEqual(1, reducedPackageOperations.Operations.Count());
Assert.AreEqual(operation, reducedPackageOperations.Operations.First());
}
public void UpdatePackage_PackageInstanceAndOneInstallPackageOperationPassed_PackageDefinedInOperationIsInstalledInLocalRepository()
{
CreatePackageManager();
CreateTestableProjectManager();
PackageOperation operation = CreateOneInstallPackageOperation();
UpdatePackageWithPackageOperations(operation);
Assert.AreEqual(operation.Package, fakeSolutionSharedRepository.FirstPackageAdded);
}
public void AddPackage_PackageAddedSuccessfully_PackageOperationsUsedWhenInstallingPackage()
{
CreateViewModel();
viewModel.AddPackage();
PackageOperation[] expectedOperations = new PackageOperation[] {
new PackageOperation(package, PackageAction.Install)
};
CollectionAssert.AreEqual(expectedOperations, packageManagementService.PackageOperationsPassedToInstallPackage);
}
FakePackage InstallPackageWithPackageOperations(PackageOperation operation)
{
var operations = new PackageOperation[] {
operation
};
FakePackage package = CreateFakePackage();
var installAction = new FakeInstallPackageAction();
installAction.Operations = operations;
packageManager.InstallPackage(package, installAction);
return(package);
}
public void AddPackage_OnePackageOperationIsToUninstallPackageWhichRequiresLicenseAcceptance_UserIsNotAskedToAcceptLicenseAgreementForPackageToBeUninstalled()
{
CreateViewModel();
fakePackage.RequireLicenseAcceptance = false;
PackageOperation operation = viewModel.AddOneFakeUninstallPackageOperation();
FakePackage packageToUninstall = operation.Package as FakePackage;
packageToUninstall.RequireLicenseAcceptance = true;
viewModel.AddPackage();
Assert.IsFalse(fakePackageManagementEvents.IsOnAcceptLicensesCalled);
}
public void Execute_PackageScriptRunnerSet_PackagesAreUpdated()
{
CreateAction();
PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
CreateActionWithOperations(operation);
action.PackageScriptRunner = CreatePackageScriptRunner();
action.Execute();
project.AssertWasCalled(p => p.UpdatePackages(action));
}
public void AddPackage_PackageAddedSuccessfully_PackageOperationsUsedWhenInstallingPackage()
{
CreateViewModel();
viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
viewModel.AddPackage();
PackageOperation[] expectedOperations = new PackageOperation[] {
new PackageOperation(fakePackage, PackageAction.Install)
};
CollectionAssert.AreEqual(expectedOperations, fakeInstallPackageAction.Operations);
}
public static async Task RunAsync(
[QueueTrigger(Constants.IndexingQueue, Connection = Constants.IndexingQueueConnection)] PackageOperation packageOperation,
[Blob("index/{Id}.{VersionNormalized}.json", FileAccess.ReadWrite, Connection = Constants.IndexConnection)] CloudBlockBlob packageBlob,
ILogger log)
{
var indexClient = SearchServiceClient.Indexes.GetClient(Constants.SearchServiceIndexName);
var indexActions = new List <IndexAction <PackageDocument> >();
// Build actions
if (packageOperation.IsAdd())
{
await RunAddPackageAsync(packageOperation, packageBlob, log, indexActions);
}
else if (packageOperation.IsDelete())
{
await RunDeletePackageAsync(packageOperation, packageBlob, indexClient, indexActions);
}
// Commit changes to index
if (!Constants.DevCommitToSearchIndex)
{
return;
}
log.LogInformation("Committing changes for package {packageId}@{packageVersionNormalized} to index...", packageOperation.Id, packageOperation.Version);
foreach (var actions in indexActions.Paged(BatchCommitSize))
{
var indexBatch = IndexBatch.New(actions);
try
{
log.LogInformation("Committing batch to index...");
await indexClient.Documents.IndexAsync(indexBatch);
log.LogInformation("Committed batch to index.");
}
catch (IndexBatchException ex)
{
log.LogError("Error while committing batch to index.", ex);
foreach (var result in ex.IndexingResults)
{
if (result.Succeeded)
{
continue;
}
log.LogError("Result for {key}: {message}", result.Key, result.ErrorMessage);
}
throw;
}
}
log.LogInformation("Finished committing changes for package {packageId}@{packageVersionNormalized} to index.", packageOperation.Id, packageOperation.Version);
}
FakePackage UpdatePackageWithPackageOperations(PackageOperation operation)
{
var operations = new PackageOperation[] {
operation
};
FakePackage package = CreateFakePackage();
var updateAction = new FakeUpdatePackageAction();
updateAction.Operations = operations;
updateAction.UpdateDependencies = true;
packageManager.UpdatePackage(package, updateAction);
return(package);
}
public void Reduce_OncePackageOperationInstallsPackageWhilstOneUninstallsSamePackage_PackageOperationNotIncludedInReducedSet()
{
CreateReducedPackageOperations();
IPackage package = AddPackage("Test", "1.0");
PackageOperation installOperation = CreatePackageOperation("Foo", "1.0", PackageAction.Install);
PackageOperation uninstallOperation = CreatePackageOperation("Foo", "1.0", PackageAction.Uninstall);
AddInstallOperationsForPackage(package, installOperation, uninstallOperation);
reducedPackageOperations.Reduce();
Assert.AreEqual(0, reducedPackageOperations.Operations.Count());
}
void AddInstallOperationWithFile(string fileName)
{
var package = new FakePackage();
package.AddFile(fileName);
var operation = new PackageOperation(package, PackageAction.Install);
var operations = new List <PackageOperation>();
operations.Add(operation);
action.Operations = operations;
}
public void Execute_OneProjectThatHasOlderVersionOfPackageBeingUpdated_PackagesUpdatedEventIsFired()
{
PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
CreateActionWithOperations(operation);
IPackageFromRepository package = AddPackageToAction("Test", "1.0");
IPackageManagementProject project = AddProjectToSolution();
var expectedOperations = new PackageOperation[] { operation };
action.Execute();
packageEvents.AssertWasCalled(events => events.OnParentPackagesUpdated(action.Packages));
}
public void AddPackage_PackageAddedSuccessfully_PackageOperationsUsedWhenInstallingPackage()
{
CreateViewModel();
viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
viewModel.AddPackage();
PackageOperation[] expectedOperations = new PackageOperation[] {
new PackageOperation(fakePackage, PackageAction.Install)
};
FakeInstallPackageAction action = fakeSolution.FakeProjectToReturnFromGetProject.LastInstallPackageCreated;
CollectionAssert.AreEqual(expectedOperations, action.Operations);
}
public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageOperationsReturnedFromPackageOperationsResolverCreated()
{
CreatePackageManager();
var package = new FakePackage();
var expectedOperations = new PackageOperation [] {
new PackageOperation(package, PackageAction.Install)
};
fakePackageOperationResolver.AddOperations(package, expectedOperations);
IEnumerable <PackageOperation> operations = GetInstallPackageOperations(package);
Assert.AreEqual(expectedOperations, operations);
}
public void Reduce_TwoPackages_ReturnsPackageOperationsForBothPackages()
{
CreateReducedPackageOperations();
IPackage package1 = AddPackage("Test", "1.0");
IPackage package2 = AddPackage("Test2", "1.0");
PackageOperation operation1 = AddInstallOperationForPackage(package1);
PackageOperation operation2 = AddInstallOperationForPackage(package2);
reducedPackageOperations.Reduce();
Assert.AreEqual(2, reducedPackageOperations.Operations.Count());
AssertReducedOperationsContains(operation1);
AssertReducedOperationsContains(operation2);
}
public override void Execute(PackageOperation op)
{
// Try to get the project for this project manager
Project project = _packageManager.GetProject(this);
IVsProjectBuildSystem build = null;
if (project != null)
{
build = project.ToVsProjectBuildSystem();
}
try
{
if (build != null)
{
// Start a batch edit so there is no background compilation until we're done
// processing project actions
build.StartBatchEdit();
}
base.Execute(op);
}
finally
{
if (build != null)
{
// End the batch edit when we are done.
build.EndBatchEdit();
}
}
var eventArgs = CreateOperation(op.Package);
if (op.Action == PackageAction.Install)
{
_packageManager.PackageEvents.NotifyReferenceAdded(eventArgs);
}
else
{
_packageManager.PackageEvents.NotifyReferenceRemoved(eventArgs);
}
}
private void AssertOperation(string expectedId, string expectedVersion, PackageAction expectedAction, PackageOperation operation)
{
Assert.Equal(expectedAction, operation.Action);
Assert.Equal(expectedId, operation.Package.Id);
Assert.Equal(new SemanticVersion(expectedVersion), operation.Package.Version);
}
#pragma warning restore 0067
public void Execute(PackageOperation operation)
{
// no-op
}
public void Execute(PackageOperation operation)
{
System.Diagnostics.Debug.Assert(false, "Didn't expect this to be called!");
throw new NotImplementedException();
}
public void UpdatePackageWithNoProjectsInstallsAtSolutionLevel()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", dependencies: new PackageDependency[] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0");
sourceRepository.AddPackage(package2);
var package3 = PackageUtility.CreatePackage("awesome", "1.0");
localRepository.AddPackage(package3);
var operations = new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
new PackageOperation(package3, PackageAction.Uninstall)
};
// Act
packageManager.UpdatePackage(Enumerable.Empty<Project>(),
package,
operations,
updateDependencies: true,
allowPrereleaseVersions: false,
logger: NullLogger.Instance,
packageOperationEventListener: null);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package));
Assert.True(packageManager.LocalRepository.Exists(package2));
Assert.True(!packageManager.LocalRepository.Exists(package3));
}
public void UpdatePackagesWithOperationsAddPackageCorrectly()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var projectRepository = new MockProjectPackageRepository(localRepository);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var A1 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello1" });
var A2 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello2" });
var A3 = PackageUtility.CreatePackage("A", "3.0", new[] { "hello3" });
var B1 = PackageUtility.CreatePackage("B", "1.0", new[] { "world1" });
var B2 = PackageUtility.CreatePackage("B", "2.0", new[] { "world2" });
sourceRepository.AddPackage(A2);
sourceRepository.AddPackage(A3);
sourceRepository.AddPackage(B1);
sourceRepository.AddPackage(B2);
localRepository.AddPackage(A1);
localRepository.AddPackage(B1);
projectRepository.Add(A1);
projectRepository.Add(B1);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository);
var operations = new PackageOperation[] {
new PackageOperation(A3, PackageAction.Install),
new PackageOperation(B2, PackageAction.Install)
};
// Act
packageManager.UpdatePackages(projectManager, new[] { A3, B2 }, operations, updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance);
// Assert
Assert.True(localRepository.Exists("A", new SemanticVersion("3.0")));
Assert.False(localRepository.Exists("A", new SemanticVersion("2.0")));
Assert.False(localRepository.Exists("A", new SemanticVersion("1.0")));
Assert.True(localRepository.Exists("B", new SemanticVersion("2.0")));
Assert.False(localRepository.Exists("B", new SemanticVersion("1.0")));
Assert.True(projectRepository.Exists("A", new SemanticVersion("3.0")));
Assert.True(projectRepository.Exists("B", new SemanticVersion("2.0")));
}
public void InstallPackageUninstalledSolutionLevelPackagesAreNotAddedToSolutionPackageConfig()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object);
var packageFoo = PackageUtility.CreatePackage("foo", "1.0", content: new[] { "hello" });
sourceRepository.AddPackage(packageFoo);
var packageBar1 = PackageUtility.CreatePackage("bar1", "2.0",
tools: new[] { "install.ps1" });
sourceRepository.AddPackage(packageBar1);
var packageBar2 = PackageUtility.CreatePackage("bar2", "2.0",
tools: new[] { "install.ps1" });
sourceRepository.AddPackage(packageBar2);
var operations = new PackageOperation[] {
new PackageOperation(packageFoo, PackageAction.Install),
new PackageOperation(packageBar1, PackageAction.Uninstall),
new PackageOperation(packageBar2, PackageAction.Uninstall)
};
// Act
packageManager.InstallPackage(
projectManager, packageFoo, operations,
ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance);
// Assert
Assert.False(localRepository.IsReferenced("bar1", new SemanticVersion("2.0")));
Assert.False(localRepository.IsReferenced("bar2", new SemanticVersion("2.0")));
Assert.True(packageManager.LocalRepository.Exists(packageFoo));
Assert.True(projectManager.LocalRepository.Exists(packageFoo));
}
public void InstallPackageWithOperationsInstallsMetaPackageSuccessfully()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", dependencies: new [] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0", content: new[] { "world" });
sourceRepository.AddPackage(package2);
var operations = new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
};
// Act
packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package));
Assert.True(packageManager.LocalRepository.Exists(package2));
Assert.True(projectManager.LocalRepository.Exists(package));
Assert.True(projectManager.LocalRepository.Exists(package2));
}
