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); }