public void SupressErrorWorksForGetPackagesForRepositoriesThatThrowDuringEnumeration()
{
// Arrange
var mockRepository = new Mock <IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable());
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
},
});
repository.IgnoreFailingRepositories = true;
// Act
var packages = repository.GetPackages();
// Assert
Assert.Equal(2, packages.Count());
}
public void FallbackRepositoryRetursNullIfPrimaryRepositoryDoesNotHaveDependencyAndDependencyResolverThrows()
{
// Arrange
var package = PackageUtility.CreatePackage("M1", "1.0");
var dependencyResolver = new Mock <IPackageRepository>(MockBehavior.Strict);
dependencyResolver.As <IDependencyResolver>()
.Setup(c => c.ResolveDependency(It.IsAny <PackageDependency>(), It.IsAny <IPackageConstraintProvider>(), false, It.IsAny <bool>(), DependencyVersion.Lowest))
.Throws(new Exception("Connection failure."));
var aggregateRepository = new AggregateRepository(new[] { dependencyResolver.Object })
{
IgnoreFailingRepositories = true
};
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(package);
var fallbackRepository = new FallbackRepository(primaryRepository, aggregateRepository);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec {
MinVersion = new SemanticVersion("1.0.1")
}), false, false);
// Assert
Assert.Null(resolvedPackage);
}
public void GetPackagesWithPagingTakesLowestNElements()
{
// Arrange
var r1 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
PackageUtility.CreatePackage("E"),
};
var r2 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("C"),
PackageUtility.CreatePackage("D"),
PackageUtility.CreatePackage("F"),
};
var repository = new AggregateRepository(new[] { r1, r2 });
// Act
var packages = repository.GetPackages().OrderBy(p => p.Id).Take(5).ToList();
// Assert
Assert.Equal(5, packages.Count);
Assert.Equal("A", packages[0].Id);
Assert.Equal("B", packages[1].Id);
Assert.Equal("C", packages[2].Id);
Assert.Equal("D", packages[3].Id);
Assert.Equal("E", packages[4].Id);
}
public void WillNotUseODataIfPackageLocal()
{
var console = new Mock <ILogger>().Object;
var resolver = new PackageResolutionManager(console, true, new MemoryBasedPackageCache(console));
var odata = new Mock <DataServicePackageRepository>(new Uri(@"http://nuget.org"));
var list = new List <IPackage>()
{
new DataServicePackage()
{
Id = "Assembly.Common",
Version = "3.0"
}
};
odata.Setup(o => o.GetPackages()).Returns(list.AsQueryable());
var remoteRepository = new AggregateRepository(new List <IPackageRepository>()
{
Utilities.GetFactory().CreateRepository("SingleAggregate"),
odata.Object
});
var localRepository = new MockPackageRepository();
var package = new DataServicePackage()
{
Id = "Assembly.Common",
Version = "3.0"
};
Assert.AreEqual(true, remoteRepository.GetPackages().Contains(package));
var local = resolver.FindPackageInAllLocalSources(localRepository, remoteRepository, package, false, false);
Assert.AreEqual(null, local);
}
/// <summary>
/// Returns a an AggregateRepository minus any LocalPackageRepositories or MachineCache repositories. Useful if you want to use a command that will not work across these types.
/// Snappy name, I know.
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public static AggregateRepository GetRemoteOnlyAggregateRepository(this AggregateRepository repository)
{
//Craziness as the MachineCache and LocalPackageRepository do not support IsLatestVersion
var repoList = Flatten(repository.Repositories);
return(new AggregateRepository(repoList.Where(r => r.GetType() != typeof(LocalPackageRepository) && r.GetType() != typeof(MachineCache))));
}
public void RepoFactory_NoEnabledSources_RepoCreated()
{
// Arrange
TestLogger logger = new TestLogger();
string configXml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<packageSources>
<add key=""local1_inactive"" value=""c:\inactiveCache\should.be.ignored"" />
<add key=""local2_inactive"" value=""c:\inactiveCache2\should.be.ignored"" />
<add key=""local3_inactive"" value=""c:\inactiveCache3\should.be.ignored"" />
</packageSources>
<disabledPackageSources>
<add key=""local1_inactive"" value=""true"" />
<add key=""local2_inactive"" value=""true"" />
<add key=""local3_inactive"" value=""true"" />
</disabledPackageSources>
</configuration>";
Settings settings = CreateSettingsFromXml(configXml);
// Act
IPackageRepository actualRepo = NuGetRepositoryFactory.CreateRepository(settings, logger);
// Assert
Assert.IsInstanceOfType(actualRepo, typeof(AggregateRepository));
AggregateRepository actualAggregateRepo = (AggregateRepository)actualRepo;
AssertExpectedPackageSources(actualAggregateRepo
/* no packages sources so no repositories */);
}
private HeartbeatCashoutRepository(INoSQLTableStorage <HeartbeatCashoutEntity> storage)
{
_aggregateRepository = new AggregateRepository <HeartbeatCashoutAggregate, HeartbeatCashoutEntity>(
storage,
mapAggregateToEntity: HeartbeatCashoutEntity.FromDomain,
mapEntityToAggregate: entity => Task.FromResult(entity.ToDomain()));
}
public void SupressErrorWorksForFindPackagesForRepositoriesThatThrowWhenInvoked()
{
// Arrange
var mockRepository = new Mock <IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Throws(new InvalidOperationException()).Verifiable();
var packageLookup = new Mock <IPackageLookup>(MockBehavior.Strict);
packageLookup.Setup(c => c.FindPackage(It.IsAny <string>(), It.IsAny <SemanticVersion>())).Throws(new Exception());
var mockRepositoryWithLookup = packageLookup.As <IPackageRepository>();
mockRepositoryWithLookup.Setup(c => c.GetPackages()).Throws(new InvalidOperationException());
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
},
mockRepositoryWithLookup.Object
});
repository.IgnoreFailingRepositories = true;
// Act
var package = repository.FindPackage("C", new SemanticVersion("1.0"));
// Assert
Assert.Null(package);
}
public void GetUpdates()
{
// Arrange
var r1 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A", "2.0"),
};
var r2 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
};
var r3 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A", "3.0"),
};
var r4 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
};
var repository = new AggregateRepository(new[] { r1, r2, r3, r4 });
// Act
var updates = repository.GetUpdates(new[] { PackageUtility.CreatePackage("A", "1.0") }, includePrerelease: false, includeAllVersions: false).ToList();
// Assert
Assert.Equal(1, updates.Count);
Assert.Equal("A", updates[0].Id);
Assert.Equal(new SemanticVersion("3.0"), updates[0].Version);
}
public void ShouldComposeSnapshotOfExactNumberOfEvents()
{
// ARRANGE
var eventRepository = new SqliteEventRepository(_connectionString);
var snapshotRepository = new SqliteSnapshotEventRepository(_connectionString);
var factory = new DefaultAggregateFactory();
var aggregateStore = new AggregateRepository(eventRepository, factory, snapshotRepository);
// Create a test aggregate.
var aggregateId = CombGuid.Generate();
var aggregate = aggregateStore.GetById <IncrementingAggregate>(aggregateId);
var snapshotSize = aggregate.SnapshotSize;
var numberOfTestEvents = 2 * snapshotSize + 1;
// Send test events to the aggregate.
Enumerable.Range(1, numberOfTestEvents)
.ToList()
.ForEach(x => aggregate.Tell(new IncrementingAggregate.Increment()));
// ACT
var orderedEvents = aggregateStore.Save(aggregate);
var snapshotVersion = snapshotRepository.GetVersionByAggregateId(aggregateId);
var snapshotOffer = (SnapshotOffer)snapshotRepository
.GetSnapshotEventByAggregateIdAndVersion(aggregateId, snapshotVersion ?? 0);
var newAggregate = aggregateStore.GetById <IncrementingAggregate>(aggregateId);
var newState = newAggregate.Ask <int>(new IncrementingAggregate.GetValue());
// ASSERT
Assert.AreEqual(numberOfTestEvents, orderedEvents.Length);
Assert.AreEqual(numberOfTestEvents - 1, snapshotOffer.Version);
Assert.AreEqual(numberOfTestEvents - 1, snapshotOffer.State);
Assert.AreEqual(numberOfTestEvents, newState);
}
/// <summary>
/// Determines the remote repository to be used based on the state of the solution and the Source parameter
/// </summary>
private IPackageRepository GetRemoteRepository()
{
IPackageRepository repository;
if (!String.IsNullOrEmpty(Source))
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(Source);
// If a Source parameter is explicitly specified, use it
repository = CreateRepositoryFromSource(_repositoryFactory, _packageSourceProvider, Source);
}
else if (SolutionManager.IsSolutionOpen)
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(_packageSourceProvider);
// If the solution is open, retrieve the cached repository instance
repository = PackageManager.SourceRepository;
}
else if (_packageSourceProvider.ActivePackageSource != null)
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(_packageSourceProvider);
// No solution available. Use the repository Url to create a new repository
repository = _repositoryFactory.CreateRepository(_packageSourceProvider.ActivePackageSource.Source);
}
else
{
// No active source has been specified.
throw new InvalidOperationException(Resources.Cmdlet_NoActivePackageSource);
}
if (IsRepositoryUsedForSearch(repository))
{
repository = new AggregateRepository(new [] { repository });
}
return(repository);
}
public InMemEventStore(IServiceProvider serviceProvider)
{
_aggregateRepository = new AggregateRepository(this);
_projectionRepository = new ProjectionRepository(serviceProvider);
_commandLog = new InMemCommandLog();
_sequences = new InMemSequenceStore();
}
/// <summary>
/// Deletes all files from a package
/// </summary>
/// <param name="installed">Insyalled package</param>
/// <param name="repositories">Repositories where to find the package</param>
private static void DeleteFiles(PackageInfo installed, ICollection <string> repositories, ILogger logger)
{
logger.Log("Deleting installed files... ");
var factory = new PackageRepositoryFactory();
IPackage package;
var globalRepo = new AggregateRepository(factory, repositories, true);
package = globalRepo.FindPackage(installed.Name, SemanticVersion.Parse(installed.Version), true, true);
if (package == null)
{
throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", installed.Name, installed.Version));
}
var fylesystem = new PhysicalFileSystem(installed.InstallationDirectory);
fylesystem.DeleteFiles(package.GetFiles(), installed.InstallationDirectory);
File.Delete(Path.Combine(installed.InstallationDirectory, installed.Name + "." + installed.Version + ".nupkg"));
foreach (var config in Directory.GetFiles(installed.InstallationDirectory, "*.config"))
{
File.Delete(config);
}
logger.Log("Installed files deleted");
}
/// <summary>
/// Downloads the specified package and installs it in the configured folder
/// </summary>
/// <param name="info">Pacakge informations</param>
private static void DownloadPackage(PackageInfo info, ICollection <string> repositories, ILogger logger)
{
logger.Log(String.Format("Downloading package for {0} version {1} ... ", info.Name, info.Version));
var factory = new PackageRepositoryFactory();
IPackage package;
var globalRepo = new AggregateRepository(factory, repositories, true);
package = globalRepo.FindPackage(info.Name, SemanticVersion.Parse(info.Version), true, true);
if (package == null)
{
throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", info.Name, info.Version));
}
var manager = new PackageManager(
globalRepo,
new CustomPathResolver()
{
BasePath = info.InstallationDirectory
},
new OverWritingPhysicalFilesystem(info.InstallationDirectory));
manager.InstallPackage(package, false, true);
logger.Log(String.Format("Package for {0} version {1} downloaded ... ", info.Name, info.Version));
}
public void GetUpdatesReturnsDistinctSetOfPackages()
{
// Arrange
var package_10 = PackageUtility.CreatePackage("A", "1.0");
var package_11 = PackageUtility.CreatePackage("A", "1.1");
var package_12 = PackageUtility.CreatePackage("A", "1.2");
var repo1 = new MockPackageRepository();
repo1.Add(package_12);
repo1.Add(package_11);
var repo2 = new MockPackageRepository();
repo2.Add(package_12);
var aggregateRepository = new AggregateRepository(new[] { repo1, repo2 });
// Act
var updates = aggregateRepository.GetUpdates(new[] { package_10 }, includePrerelease: false, includeAllVersions: true);
// Assert
Assert.Equal(2, updates.Count());
Assert.Same(package_11, updates.ElementAt(0));
Assert.Same(package_12, updates.ElementAt(1));
}
public void GetPackagesWithPagingTakesLowestNElements()
{
// Arrange
var r1 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
PackageUtility.CreatePackage("E"),
};
var r2 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("C"),
PackageUtility.CreatePackage("D"),
PackageUtility.CreatePackage("F"),
};
var repository = new AggregateRepository(new[] { r1, r2 });
// Act
var packages = repository.GetPackages().OrderBy(p => p.Id).Take(5).ToList();
// Assert
Assert.Equal(5, packages.Count);
Assert.Equal("A", packages[0].Id);
Assert.Equal("B", packages[1].Id);
Assert.Equal("C", packages[2].Id);
Assert.Equal("D", packages[3].Id);
Assert.Equal("E", packages[4].Id);
}
public void CreateRobots()
{
var appSettings = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddUserSecrets("oogi2")
.AddEnvironmentVariables()
.Build();
_con = new Connection(appSettings["endpoint"], appSettings["authorizationKey"], appSettings["database"], appSettings["collection"]);
_con.CreateCollection();
_repo = new Repository <Robot>(_con);
_aggregate = new AggregateRepository(_con);
foreach (var robot in _robots.Take(_robots.Count - 1))
{
_repo.Create(robot);
}
foreach (var robot in _robots.TakeLast(1))
{
_repo.Upsert(robot);
}
}
public void GetPackagesSupressesExceptionForConsecutiveCalls()
{
// Arrange
var repo1 = new Mock <IPackageRepository>();
repo1.Setup(r => r.GetPackages()).Returns(Enumerable.Repeat(PackageUtility.CreatePackage("Foo"), 50).AsQueryable()).Verifiable();
var repo2 = new Mock <IPackageRepository>();
repo2.Setup(r => r.GetPackages()).Throws(new Exception()).Verifiable();
var aggregateRepository = new AggregateRepository(new[] { repo1.Object, repo2.Object })
{
IgnoreFailingRepositories = true
};
// Act
for (int i = 0; i < 5; i++)
{
aggregateRepository.GetPackages();
}
// Assert
repo1.Verify(r => r.GetPackages(), Times.Exactly(5));
repo2.Verify(r => r.GetPackages(), Times.AtMostOnce());
}
public IEnumerable <NuGetPackageViewModel> FetchAvailableNuGetPackages(
string searchPattern,
bool incluePrerelease)
{
if (searchPattern == null)
{
searchPattern = string.Empty;
}
var connections = NuGetConnections;
var repo = new AggregateRepository(PackageRepositoryFactory.Default, connections.Select(s => s.Url), true);
var allPackages = repo.Search(searchPattern, new string[]
{
}
, incluePrerelease);
if (!incluePrerelease)
{
allPackages = allPackages
.Where(p => p.IsLatestVersion);
}
return(allPackages.OrderBy(p => p.Title)
.Take(20)
.ToList()
.Select(p => new NuGetPackageViewModel(p)));
}
public RepoHarness(TestAggregate aggregate, InMemoryEventStore eventStore, Mock <IAggregateEventPublisher> eventPublisher)
{
this.aggregate = aggregate;
this.eventStore = eventStore;
this.eventPublisher = eventPublisher;
this.repository = new AggregateRepository(eventStore, eventPublisher.Object);
}
public void SupressErrorWorksForGetPackagesForRepositoriesThatThrowWhenInvoked()
{
// Arrange
var mockRepository = new Mock <IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Throws(new InvalidOperationException()).Verifiable();
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
}
});
repository.IgnoreFailingRepositories = true;
// Act
var packages = repository.GetPackages().OrderBy(p => p.Id).ToList();
// Assert
Assert.Equal(2, packages.Count);
}
static CommandDispatcher SetupDispatcher()
{
var repository = new AggregateRepository();
var commandHandlerMap = new CommandHandlerMap(new Handlers(repository));
return(new CommandDispatcher(commandHandlerMap));
}
public static AggregateRepository <TAggregate> CreateEnvironment <TAggregate>(
out EventBus eventBus,
out EventStore eventStore,
int snapshotThreashold = 10)
where TAggregate : IAggregateRoot, new()
{
TestDatabase.Items.Clear();
var savedHandler = new TestAggregateSavedEventHandler();
var dependencyService = DependencyServiceMock.GetMock(new List <DependencyDescriptor>()
{
new DependencyDescriptor(typeof(IEventHandler <TestAggregateCreatedEvent>),
new TestAggregateCreatedEventHandler()),
new DependencyDescriptor(typeof(IEventHandler <TestAggregateChangedEvent>),
new TestAggregateChangedEventHandler()),
new DependencyDescriptor(typeof(IEventHandler <AggregateSavedEvent>), savedHandler)
});
eventBus = new EventBus(dependencyService);
eventStore = new EventStore(eventBus, new InMemoryEventStore(), PerformanceCounterMock.GetMock());
var snapshotStore = new SnapshotStore(new InMemorySnapshotStore());
var repository = new AggregateRepository <TAggregate>(eventStore, snapshotStore);
var snapshotProcessor = new SnapshotProcessor(snapshotStore,
new List <ISnapshotableRepository>()
{
repository
},
snapshotThreashold, PerformanceCounterMock.GetMock());
savedHandler.Processor = snapshotProcessor;
return(repository);
}
public async Task It_fires_after_node_restart()
{
var cmd = new ScheduleEventInFutureCommand(DateTime.Now.AddSeconds(10),
Guid.NewGuid(),
"test value");
GridNode.NewCommandWaiter()
.Expect <FutureEventScheduledEvent>(e => e.Event.SourceId == cmd.AggregateId)
.Create()
.Execute(cmd)
.Wait(Timeout);
await GridNode.Stop();
await GridNode.Start();
var waiter = GridNode.NewWaiter()
.Expect <FutureEventOccuredEvent>(e => e.SourceId == cmd.AggregateId)
.Create();
waiter.Wait(Timeout);
var repo = new AggregateRepository(new ActorSystemEventRepository(GridNode.System), GridNode.EventsAdaptersCatalog);
var aggregate = repo.LoadAggregate <TestAggregate>(cmd.AggregateId);
Assert.LessOrEqual(aggregate.ProcessedTime - cmd.RaiseTime, TimeSpan.FromSeconds(2));
}
public void RepoFactory_MultipleEnabledSources_RepoCreated()
{
// Arrange
TestLogger logger = new TestLogger();
// Create a valid config settings file that specifies the package sources to use
string configXml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<packageSources>
<add key=""local1_inactive"" value=""c:\inactiveCache\should.be.ignored"" />
<add key=""local2_active"" value=""d:\active_cache"" />
<add key=""local3_active"" value=""c:\another\active\cache"" />
</packageSources>
<disabledPackageSources>
<add key=""local1_inactive"" value=""true"" />
</disabledPackageSources>
</configuration>";
Settings settings = CreateSettingsFromXml(configXml);
// Act
IPackageRepository actualRepo = NuGetRepositoryFactory.CreateRepository(settings, logger);
// Assert
Assert.IsInstanceOfType(actualRepo, typeof(AggregateRepository));
AggregateRepository actualAggregateRepo = (AggregateRepository)actualRepo;
AssertExpectedPackageSources(actualAggregateRepo,
"d:\\active_cache",
"c:\\another\\active\\cache");
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
}
public PostgresEventStore(IServiceProvider serviceProvider, string connectionString, string databaseSchemaName, bool cleanAll = false)
{
_aggregateRepository = new AggregateRepository(this);
_projectionRepository = new ProjectionRepository(serviceProvider);
var options = new StoreOptions();
options.Connection(connectionString);
options.Projections.Add(new Projection(_projectionRepository));
// Serialize enums as strings
var serializer = new Marten.Services.JsonNetSerializer();
serializer.EnumStorage = Weasel.Core.EnumStorage.AsString;
options.Serializer(serializer);
// Can be overridden
options.AutoCreateSchemaObjects = Weasel.Postgresql.AutoCreate.All;
options.DatabaseSchemaName = databaseSchemaName;
_store = new DocumentStore(options);
if (cleanAll)
{
_store.Advanced.Clean.CompletelyRemoveAll();
}
_commandLog = new PostgresCommandLog(_store);
_sequences = new PostgresSequenceStore(connectionString, databaseSchemaName);
}
public void GetPackagesRemoveDuplicates()
{
// Arrange
var r1 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
PackageUtility.CreatePackage("C"),
PackageUtility.CreatePackage("D"),
};
var r2 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("D"),
PackageUtility.CreatePackage("E"),
PackageUtility.CreatePackage("F"),
};
var repository = new AggregateRepository(new[] { r1, r2 });
// Act
var packages = repository.GetPackages().OrderBy(p => p.Id).ToList();
// Assert
Assert.Equal(6, packages.Count);
Assert.Equal("A", packages[0].Id);
Assert.Equal("B", packages[1].Id);
Assert.Equal("C", packages[2].Id);
Assert.Equal("D", packages[3].Id);
Assert.Equal("E", packages[4].Id);
Assert.Equal("F", packages[5].Id);
}
public void GetPackagesRemoveDuplicates()
{
// Arrange
var r1 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
PackageUtility.CreatePackage("C"),
PackageUtility.CreatePackage("D"),
};
var r2 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("D"),
PackageUtility.CreatePackage("E"),
PackageUtility.CreatePackage("F"),
};
var repository = new AggregateRepository(new[] { r1, r2 });
// Act
var packages = repository.GetPackages().OrderBy(p => p.Id).ToList();
// Assert
Assert.Equal(6, packages.Count);
Assert.Equal("A", packages[0].Id);
Assert.Equal("B", packages[1].Id);
Assert.Equal("C", packages[2].Id);
Assert.Equal("D", packages[3].Id);
Assert.Equal("E", packages[4].Id);
Assert.Equal("F", packages[5].Id);
}
/// <summary>
/// Find the latest version of a package in the given aggregate repository.
/// </summary>
/// <param name="repo">The aggregate repository where to find the latest version of the package.</param>
/// <param name="id">The id of the package.</param>
/// <param name="allowPrereleaseVersions">Indicates if prerelease version is allowed.</param>
/// <returns>the latest version of the package; or null if the package doesn't exist
/// in the repo.</returns>
private static IPackage GetLatestVersionPackageByIdFromAggregateRepository(
AggregateRepository repo, string id,
bool allowPrereleaseVersions)
{
var tasks = repo.Repositories.Select(p => Task.Factory.StartNew(
state => GetLastestPackageVersion(p, id, allowPrereleaseVersions), p)).ToArray();
try
{
Task.WaitAll(tasks);
}
catch (AggregateException)
{
if (!repo.IgnoreFailingRepositories)
{
throw;
}
}
var versions = new List <IPackage>();
foreach (var task in tasks)
{
if (task.IsFaulted)
{
repo.LogRepository((IPackageRepository)task.AsyncState, task.Exception);
}
else if (task.Result != null)
{
versions.Add(task.Result);
}
}
return(versions.OrderByDescending(v => v.Version).FirstOrDefault());
}
public void GetUpdates()
{
// Arrange
var r1 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A", "2.0"),
};
var r2 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
};
var r3 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A", "3.0"),
};
var r4 = new MockPackageRepository()
{
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
};
var repository = new AggregateRepository(new[] { r1, r2, r3, r4 });
// Act
var updates = repository.GetUpdates(new[] { PackageUtility.CreatePackage("A", "1.0") }).ToList();
// Assert
Assert.AreEqual(1, updates.Count);
Assert.AreEqual("A", updates[0].Id);
Assert.AreEqual(new Version("3.0"), updates[0].Version);
}
private CashoutRegistrationRepository(INoSQLTableStorage <CashoutRegistrationEntity> storage)
{
_aggregateRepository = new AggregateRepository <CashoutRegistrationAggregate, CashoutRegistrationEntity>(
storage,
mapAggregateToEntity: CashoutRegistrationEntity.FromDomain,
mapEntityToAggregate: entity => Task.FromResult(entity.ToDomain()));
}
public void SupressErrorWorksForGetDependenciesForRepositoriesThatThrowWhenInvoked()
{
// Arrange
var mockRepository = new Mock <IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Throws(new InvalidOperationException()).Verifiable();
var mockRepoWithLookup = new Mock <IPackageRepository>();
mockRepository.As <IDependencyResolver>().Setup(c => c.ResolveDependency(It.IsAny <PackageDependency>(), It.IsAny <IPackageConstraintProvider>(), false, It.IsAny <bool>(), DependencyVersion.Lowest));
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
},
mockRepoWithLookup.Object
});
repository.IgnoreFailingRepositories = true;
// Act
var package = DependencyResolveUtility.ResolveDependency(
repository,
new PackageDependency("C"),
null,
allowPrereleaseVersions: false,
preferListedPackages: false,
dependencyVersion: DependencyVersion.Lowest);
// Assert
Assert.Null(package);
}
public void Setup()
{
var mfs = new Mock<MockFileSystem>() { CallBase = true };
var pr = new DefaultPackagePathResolver(mfs.Object);
var mc = MachineCache.Default;
var l = new LocalPackageRepository(pr, mfs.Object);
var r1 = new DataServicePackageRepository(new Uri(@"http://nuget.org"));
var r2 = new DataServicePackageRepository(new Uri(@"http://beta.nuget.org"));
ar = new AggregateRepository(new List<IPackageRepository>() { mc, l, r1, r2 });
}
public async Task SavingExistingAggregateWithoutChangesHasNoSideEffects()
{
// arrange
var eventStore = CreateEventStoreMock();
var repository = new AggregateRepository<Counter>(eventStore.Object);
var aggregate = factory.CreateNew(Guid.NewGuid().ToString());
// act
await repository.Save(aggregate);
// assert
eventStore.Verify(e =>
e.Append(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<IEnumerable<IAggregateEvent>>()),
Times.Never);
}
public void GetPackagesNoOrderByExpressionThrows()
{
// Arrange
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
}
});
// Act
ExceptionAssert.Throws<InvalidOperationException>(() => repository.GetPackages().ToList(), "Aggregate queries require at least one OrderBy.");
}
public static AggregateRepository CreateAggregateRepositoryFromSources(IPackageRepositoryFactory factory, IPackageSourceProvider sourceProvider, IEnumerable<string> sources)
{
AggregateRepository repository;
if (sources != null && sources.Any())
{
var repositories = sources.Select(s => sourceProvider.ResolveSource(s))
.Select(factory.CreateRepository)
.ToList();
repository = new AggregateRepository(repositories);
}
else
{
repository = sourceProvider.GetAggregate(factory, ignoreFailingRepositories: true);
}
return repository;
}
public void GetPackagesNoOrderByReadsDistinctPackages()
{
// Arrange
IPackage a = PackageUtility.CreatePackage("A"),
b = PackageUtility.CreatePackage("B"),
c = PackageUtility.CreatePackage("C");
var repository = new AggregateRepository(new[] {
new MockPackageRepository { c, a },
new MockPackageRepository { b, a }
});
// Act
var packages = repository.GetPackages().ToList();
// Assert
Assert.Equal(new[] { c, a, b }, packages);
}
public void GetPackagesComplexOrderByAndDuplicatesRemovesDuplicatesAndMaintainsOrder()
{
// Arrange
var r1 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "2.0"),
};
var r2 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", rating : 3),
};
var r3 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "3.0"),
};
var r4 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
};
var repository = new AggregateRepository(new[] { r1, r2, r3, r4 });
// Act
var packages = repository.GetPackages().OrderByDescending(p => p.Rating)
.ThenBy(p => p.Id)
.ToList();
// Assert
Assert.AreEqual(4, packages.Count);
Assert.AreEqual("A", packages[0].Id);
Assert.AreEqual(new Version("1.0"), packages[0].Version);
Assert.AreEqual("A", packages[1].Id);
Assert.AreEqual(new Version("2.0"), packages[1].Version);
Assert.AreEqual("A", packages[2].Id);
Assert.AreEqual(new Version("3.0"), packages[2].Version);
Assert.AreEqual("B", packages[3].Id);
}
public void CreatePackageManagerForPackageRestoreUsesAggregateRepository()
{
// Arrange
var mockRepositoryFactory = new Mock<IPackageRepositoryFactory>();
var mockSourceProvider = new Mock<IVsPackageSourceProvider>();
var mockFileSystemProvider = new Mock<IFileSystemProvider>();
var mockRepository1 = new MockPackageRepository("Source1");
var mockRepository2 = new MockPackageRepository("Source2");
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
var aggregateRepository = new AggregateRepository(new [] { mockRepository1, mockRepository2 });
//mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2 });
mockFileSystemProvider.Setup(f => f.GetFileSystem(It.IsAny<string>())).Returns(new MockFileSystem());
var packageManagerFactory = new Mock<VsPackageManagerFactory>(new Mock<ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, mockFileSystemProvider.Object, new Mock<IRepositorySettings>().Object, new Mock<VsPackageInstallerEvents>().Object, mockRepository1, null);
packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny<string>())).Returns(new MockFileSystem());
// Act
var packageManager = packageManagerFactory.Object.CreatePackageManagerWithAllPackageSources(aggregateRepository);
// Assert
Assert.IsType(typeof(AggregateRepository), packageManager.SourceRepository);
var sourceAggregateRepository = (AggregateRepository)packageManager.SourceRepository;
var repositories = sourceAggregateRepository.Repositories.ToList();
Assert.Equal(2, repositories.Count);
Assert.Equal(mockRepository1, repositories[0]);
Assert.Equal(mockRepository2, repositories[1]);
}
public void CreateFallbackRepositoryUsesResolvedSourceNameWhenEnsuringRepositoryIsNotAlreadyListedInAggregate()
{
// Arrange
var mockRepositoryFactory = new Mock<IPackageRepositoryFactory>();
var mockSourceProvider = new Mock<IVsPackageSourceProvider>();
var mockRepository1 = new MockPackageRepository();
var mockRepository2 = new MockPackageRepository("http://redirected");
var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 });
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var aggregateSource = AggregatePackageSource.Instance;
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource });
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny<string>())).Returns<string>(s =>
{
switch (s)
{
case "Source1": return mockRepository1;
case "Source2": return mockRepository2;
default: return null;
}
});
var packageManagerFactory = new VsPackageManagerFactory(new Mock<ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock<IFileSystemProvider>().Object, new Mock<IRepositorySettings>().Object, new Mock<VsPackageInstallerEvents>().Object);
// Act
FallbackRepository repository = (FallbackRepository)packageManagerFactory.CreateFallbackRepository(mockRepository2);
// Assert
var dependencyResolver = (AggregateRepository)repository.DependencyResolver;
Assert.Equal(2, dependencyResolver.Repositories.Count());
}
public void CreateFallbackRepositoryReturnsCurrentIfCurrentIsAggregateRepository()
{
// Arrange
var mockRepositoryFactory = new Mock<IPackageRepositoryFactory>();
var mockSourceProvider = new Mock<IVsPackageSourceProvider>();
var mockRepository1 = new MockPackageRepository();
var mockRepository2 = new MockPackageRepository();
var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 });
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var aggregateSource = AggregatePackageSource.Instance;
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource });
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny<string>())).Returns<string>(s =>
{
switch (s)
{
case "Source1": return mockRepository1;
case "Source2": return mockRepository2;
default: return null;
}
});
var packageManagerFactory = new VsPackageManagerFactory(new Mock<ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock<IFileSystemProvider>().Object, new Mock<IRepositorySettings>().Object, new Mock<VsPackageInstallerEvents>().Object);
// Act
var repository = packageManagerFactory.CreateFallbackRepository(aggregateRepo);
// Assert
Assert.Equal(aggregateRepo, repository);
}
public void SupressErrorWorksForGetPackagesForRepositoriesThatThrowWhenInvoked()
{
// Arrange
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Throws(new InvalidOperationException()).Verifiable();
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
}
});
repository.IgnoreFailingRepositories = true;
// Act
var packages = repository.GetPackages().OrderBy(p => p.Id).ToList();
// Assert
Assert.Equal(2, packages.Count);
}
public void FallbackRepositoryRetursNullIfPrimaryRepositoryDoesNotHaveDependencyAndDependencyResolverThrows()
{
// Arrange
var package = PackageUtility.CreatePackage("M1", "1.0");
var dependencyResolver = new Mock<IPackageRepository>(MockBehavior.Strict);
dependencyResolver.As<IDependencyResolver>()
.Setup(c => c.ResolveDependency(It.IsAny<PackageDependency>(), It.IsAny<IPackageConstraintProvider>(), false, It.IsAny<bool>()))
.Throws(new Exception("Connection failure."));
var aggregateRepository = new AggregateRepository(new[] { dependencyResolver.Object }) { IgnoreFailingRepositories = true };
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(package);
var fallbackRepository = new FallbackRepository(primaryRepository, aggregateRepository);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec { MinVersion = new SemanticVersion("1.0.1") }), false, false);
// Assert
Assert.Null(resolvedPackage);
}
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageC = PackageUtility.CreatePackage("C", "2.0.0");
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable();
var packageRepository = new AggregateRepository(new[] {
new MockPackageRepository {
packageA
},
mockRepository.Object,
new MockPackageRepository {
packageB
},
new MockPackageRepository {
packageC
},
});
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Execute();
cmdlet.Id = "C";
cmdlet.Execute();
// Assert
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(3, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageC, installedPackages[2], PackageEqualityComparer.IdAndVersion);
mockRepository.Verify();
}
/// <summary>
/// Gets the repository.
/// </summary>
/// <returns></returns>
private IPackageRepository GetRepository()
{
var repository = AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
bool ignoreFailingRepositories = repository.IgnoreFailingRepositories;
if (!NoCache)
{
repository = new AggregateRepository(new[] { CacheRepository, repository }){ IgnoreFailingRepositories = ignoreFailingRepositories, Logger = Console};
}
repository.Logger = Console;
return repository;
}
public void GetPackagesSupressesExceptionForConsecutiveCalls()
{
// Arrange
var repo1 = new Mock<IPackageRepository>();
repo1.Setup(r => r.GetPackages()).Returns(Enumerable.Repeat(PackageUtility.CreatePackage("Foo"), 50).AsQueryable()).Verifiable();
var repo2 = new Mock<IPackageRepository>();
repo2.Setup(r => r.GetPackages()).Throws(new Exception()).Verifiable();
var aggregateRepository = new AggregateRepository(new[] { repo1.Object, repo2.Object }) { IgnoreFailingRepositories = true };
// Act
for (int i = 0; i < 5; i++)
{
aggregateRepository.GetPackages();
}
// Assert
repo1.Verify(r => r.GetPackages(), Times.Exactly(5));
repo2.Verify(r => r.GetPackages(), Times.AtMostOnce());
}
public void ExistsReturnsTrueIfAnyRepositoryContainsPackage()
{
// Arrange
var package = PackageUtility.CreatePackage("Abc");
var repo1 = new MockPackageRepository();
var repo2 = new MockPackageRepository();
repo2.Add(package);
var aggregateRepository = new AggregateRepository(new[] { repo1, repo2 });
// Act
var exists = aggregateRepository.Exists("Abc", new SemanticVersion("1.0"));
// Assert
Assert.True(exists);
}
public void GetUpdatesReturnsDistinctSetOfPackages()
{
// Arrange
var package_10 = PackageUtility.CreatePackage("A", "1.0");
var package_11 = PackageUtility.CreatePackage("A", "1.1");
var package_12 = PackageUtility.CreatePackage("A", "1.2");
var repo1 = new MockPackageRepository();
repo1.Add(package_12);
repo1.Add(package_11);
var repo2 = new MockPackageRepository();
repo2.Add(package_12);
var aggregateRepository = new AggregateRepository(new[] { repo1, repo2 });
// Act
var updates = aggregateRepository.GetUpdates(new[] { package_10 }, includePrerelease: false, includeAllVersions: true);
// Assert
Assert.Equal(2, updates.Count());
Assert.Same(package_11, updates.ElementAt(0));
Assert.Same(package_12, updates.ElementAt(1));
}
public void RepositoriesPropertyThrowsIfIgnoreFlagIsNotSet()
{
// Arrange
var repositories = Enumerable.Range(0, 3).Select(e =>
{
if (e == 1)
{
throw new InvalidOperationException("Repository exception");
}
return new MockPackageRepository();
});
var aggregateRepository = new AggregateRepository(repositories);
// Act and Assert
ExceptionAssert.Throws<InvalidOperationException>(() => aggregateRepository.Repositories.Select(c => c.Source).ToList(), "Repository exception");
}
public void SupressErrorWorksForGetPackagesForRepositoriesThatThrowDuringEnumeration()
{
// Arrange
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable());
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
},
});
repository.IgnoreFailingRepositories = true;
// Act
var packages = repository.GetPackages();
// Assert
Assert.Equal(2, packages.Count());
}
public void SupressErrorWorksForGetDependenciesForRepositoriesThatThrowWhenInvoked()
{
// Arrange
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Throws(new InvalidOperationException()).Verifiable();
var mockRepoWithLookup = new Mock<IPackageRepository>();
mockRepository.As<IDependencyResolver>().Setup(c => c.ResolveDependency(It.IsAny<PackageDependency>(), It.IsAny<IPackageConstraintProvider>(), false, It.IsAny<bool>()));
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
},
mockRepoWithLookup.Object
});
repository.IgnoreFailingRepositories = true;
// Act
var package = repository.ResolveDependency(new PackageDependency("C"), null, allowPrereleaseVersions: false, preferListedPackages: false);
// Assert
Assert.Null(package);
}
public void SupressErrorWorksForFindPackagesForRepositoriesThatThrowWhenInvoked()
{
// Arrange
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Throws(new InvalidOperationException()).Verifiable();
var packageLookup = new Mock<PackageLookupBase>();
packageLookup.Setup(c => c.FindPackage(It.IsAny<string>(), It.IsAny<SemanticVersion>())).Throws(new Exception());
var mockRepositoryWithLookup = packageLookup.As<IPackageRepository>();
mockRepositoryWithLookup.Setup(c => c.GetPackages()).Throws(new InvalidOperationException());
var repository = new AggregateRepository(new[] {
new MockPackageRepository {
PackageUtility.CreatePackage("A"),
},
mockRepository.Object,
new MockPackageRepository {
PackageUtility.CreatePackage("B"),
},
mockRepositoryWithLookup.Object
});
repository.IgnoreFailingRepositories = true;
// Act
var package = repository.FindPackage("C", new SemanticVersion("1.0"));
// Assert
Assert.Null(package);
}
/// <summary>
/// Find the latest version of a package in the given aggregate repository.
/// </summary>
/// <param name="repo">The aggregate repository where to find the latest version of the package.</param>
/// <param name="id">The id of the package.</param>
/// <param name="allowPrereleaseVersions">Indicates if prerelease version is allowed.</param>
/// <returns>the latest version of the package; or null if the package doesn't exist
/// in the repo.</returns>
private static IPackage GetLatestVersionPackageByIdFromAggregateRepository(
AggregateRepository repo, string id,
bool allowPrereleaseVersions)
{
var tasks = repo.Repositories.Select(p => Task.Factory.StartNew(
state => GetLastestPackageVersion(p, id, allowPrereleaseVersions), p)).ToArray();
try
{
Task.WaitAll(tasks);
}
catch (AggregateException)
{
if (!repo.IgnoreFailingRepositories)
{
throw;
}
}
var versions = new List<IPackage>();
foreach (var task in tasks)
{
if (task.IsFaulted)
{
repo.LogRepository((IPackageRepository)task.AsyncState, task.Exception);
}
else if (task.Result != null)
{
versions.Add(task.Result);
}
}
return versions.OrderByDescending(v => v.Version).FirstOrDefault();
}
public void GetPackagesRemoveDuplicatesIfTheyAreTheSameVersion()
{
// Arrange
var r1 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "2.0"),
};
var r2 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
};
var r3 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "3.0"),
};
var r4 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
};
var repository = new AggregateRepository(new[] { r1, r2, r3, r4 });
// Act
var packages = repository.GetPackages().OrderBy(p => p.Id).ToList();
// Assert
Assert.Equal(4, packages.Count);
Assert.Equal("A", packages[0].Id);
Assert.Equal(new SemanticVersion("2.0"), packages[0].Version);
Assert.Equal("A", packages[1].Id);
Assert.Equal(new SemanticVersion("1.0"), packages[1].Version);
Assert.Equal("A", packages[2].Id);
Assert.Equal(new SemanticVersion("3.0"), packages[2].Version);
Assert.Equal("B", packages[3].Id);
}
public ClientService(AggregateRepository<Client> clientRepository, IAccountNumberService accountNumberService, IUnitOfWork unitOfWork)
{
this.clientRepository = clientRepository;
this.accountNumberService = accountNumberService;
this.unitOfWork = unitOfWork;
}
public void GetUpdates()
{
// Arrange
var r1 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "2.0"),
};
var r2 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
};
var r3 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "3.0"),
};
var r4 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
};
var repository = new AggregateRepository(new[] { r1, r2, r3, r4 });
// Act
var updates = repository.GetUpdates(new[] { PackageUtility.CreatePackage("A", "1.0") }).ToList();
// Assert
Assert.AreEqual(1, updates.Count);
Assert.AreEqual("A", updates[0].Id);
Assert.AreEqual(new Version("3.0"), updates[0].Version);
}
public void Setup() {
repository = new AggregateRepository<Produkt>("Server=(local);Database=CqrsReadOnly;Trusted_Connection=True;");
}
/// <summary>
/// Determines the remote repository to be used based on the state of the solution and the Source parameter
/// </summary>
private IPackageRepository GetRemoteRepository()
{
IPackageRepository repository;
if (!String.IsNullOrEmpty(Source))
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(Source);
// If a Source parameter is explicitly specified, use it
repository = CreateRepositoryFromSource(_repositoryFactory, _packageSourceProvider, Source);
}
else if (SolutionManager.IsSolutionOpen)
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(_packageSourceProvider);
// If the solution is open, retrieve the cached repository instance
repository = PackageManager.SourceRepository;
}
else if (_packageSourceProvider.ActivePackageSource != null)
{
_hasConnectedToHttpSource |= UriHelper.IsHttpSource(_packageSourceProvider);
// No solution available. Use the repository Url to create a new repository
repository = _repositoryFactory.CreateRepository(_packageSourceProvider.ActivePackageSource.Source);
}
else
{
// No active source has been specified.
throw new InvalidOperationException(Resources.Cmdlet_NoActivePackageSource);
}
if (IsRepositoryUsedForSearch(repository))
{
repository = new AggregateRepository(new [] { repository });
}
return repository;
}
public ClientPassedAwayHandler(AggregateRepository<Account> accountRepository, IUnitOfWork unitOfWork)
{
this.accountRepository = accountRepository;
}
public void GetUpdates()
{
// Arrange
var r1 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "2.0"),
};
var r2 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
};
var r3 = new MockPackageRepository() {
PackageUtility.CreatePackage("A", "3.0"),
};
var r4 = new MockPackageRepository() {
PackageUtility.CreatePackage("A"),
PackageUtility.CreatePackage("B"),
};
var repository = new AggregateRepository(new[] { r1, r2, r3, r4 });
// Act
var updates = repository.GetUpdates(new[] { PackageUtility.CreatePackage("A", "1.0") }, includePrerelease: false, includeAllVersions: false).ToList();
// Assert
Assert.Equal(1, updates.Count);
Assert.Equal("A", updates[0].Id);
Assert.Equal(new SemanticVersion("3.0"), updates[0].Version);
}
