public void Setup()
{
monitorCache = mockMonitorCache.Object;
factory = mockFactory.Object;
publisher = mockPublisher.Object;
address = mockAddress.Object;
monitor = mockMonitor.Object;
mockFactory
.Setup(m => m.CreatePublisher(It.IsIn(address)))
.Returns(publisher);
mockFactory
.SetupGet(m => m.PublisherMonitor)
.Returns(monitor);
mockFactory
.SetupGet(m => m.PublisherType)
.Returns(typeof(IPublisher));
mockAddress
.Setup(m => m.ToString())
.Returns("address");
mockAddress
.Setup(m => m.GetHashCode())
.Returns(1);
}
public EventStoreSettings Build(
DbConnections connections,
IPublisherFactory publisherFactory,
IEventSerializer eventSerializer)
{
return(_builder.Build(connections, publisherFactory, eventSerializer));
}
public BookManager(LibraryContext context, IBookFactory bookFac, IAuthorFactory authorFac, IGenreFactory genreFac, IPublisherFactory publisherFac)
{
_context = context;
_bookFac = bookFac;
_authorFac = authorFac;
_genreFac = genreFac;
_publisherFac = publisherFac;
}
public CatalogContext(IPublisherFactory publisherFactory,
ITitleFactory titleFactory,
IIssueFactory issueFactory)
{
PublisherFactory = publisherFactory;
TitleFactory = titleFactory;
IssueFactory = issueFactory;
}
/// <summary>
/// Instantiates a <see cref="SubscriptionFactory"/>
/// </summary>
/// <param name="logger"></param>
/// <param name="repositoryFactory"></param>
/// <param name="marketDataProviders"></param>
/// <param name="stockListProviders"></param>
/// <param name="publisherFactory"></param>
public SubscriptionFactory(ILog logger,
IMarketDataRepositoryFactory repositoryFactory,
IEnumerable <IMarketDataProvider> marketDataProviders,
IEnumerable <IStockListProvider> stockListProviders,
IPublisherFactory publisherFactory)
{
_logger = logger;
_repositoryFactory = repositoryFactory;
_marketDataProviders = marketDataProviders;
_stockListProviders = stockListProviders;
_publisherFactory = publisherFactory;
}
/// <summary>
/// Instantiates a <see cref="SubscriptionFactory"/>
/// </summary>
/// <param name="logger"></param>
/// <param name="repositoryFactory"></param>
/// <param name="marketDataProviders"></param>
/// <param name="stockListProviders"></param>
/// <param name="publisherFactory"></param>
public SubscriptionFactory(ILog logger,
IMarketDataRepositoryFactory repositoryFactory,
IEnumerable<IMarketDataProvider> marketDataProviders,
IEnumerable<IStockListProvider> stockListProviders,
IPublisherFactory publisherFactory)
{
_logger = logger;
_repositoryFactory = repositoryFactory;
_marketDataProviders = marketDataProviders;
_stockListProviders = stockListProviders;
_publisherFactory = publisherFactory;
}
public Bus(
IModelFactory modelFactory,
IConsumerFactory consumerFactory,
IRequesterFactory requesterFactory,
IPublisherFactory publisherFactory,
ISubscriptionFactory subscriptionFactory)
{
this.modelFactory = modelFactory;
this.publisherFactory = publisherFactory;
this.requesterFactory = requesterFactory;
this.subscriptionFactory = subscriptionFactory;
this.consumerFactory = consumerFactory;
}
/// <summary>
/// Adds a <see cref="IPublisherFactory{TPublisher}"/> to the cache for configuration time creation of <see cref="IPublisher"/>s
/// </summary>
/// <param name="factory">Factory used to create <see cref="IPublisher"/>s at configuration time</param>
public void AddFactory(IPublisherFactory factory)
{
if (factory is null)
{
throw new ArgumentNullException(nameof(factory));
}
if (factories.ContainsKey(factory.PublisherType))
{
return;
}
factories.Add(factory.PublisherType, factory);
monitorCache.AddMonitor(factory.PublisherMonitor);
}
public EventStoreSettings Build(
DbConnections connections,
IPublisherFactory publisherFactory,
IEventSerializer eventSerializer)
{
if (connections == null)
{
throw new ArgumentNullException(nameof(connections));
}
if (publisherFactory == null)
{
throw new ArgumentNullException(nameof(publisherFactory));
}
if (eventSerializer == null)
{
throw new ArgumentNullException(nameof(eventSerializer));
}
var contexts = new Dictionary <string, IEventStoreContext>();
_aggregates.ForEach(a =>
{
if (a.Partitions > 1)
{
var(type, context) = CreateCategoryType(a.Type, a.Partitions, publisherFactory.Create(a.Topic));
contexts.Add(type, context);
}
else
{
var(type, context) = CreateCategoryType(a.Type, publisherFactory.Create(a.Topic));
contexts.Add(type, context);
}
});
var storeSettings = new StoreSettings(connections, contexts, eventSerializer);
var aggregateFactories = _aggregates.ToDictionary(k => k.FactoryType, v => v.Factory);
return(new EventStoreSettings(storeSettings, aggregateFactories));
}
public EventStoreSettings Build(
DbConnections connections,
IPublisherFactory publisherFactory,
IEventSerializer eventSerializer,
ISnapshotSerializer snapshotSerializer)
{
if (snapshotSerializer == null)
{
throw new ArgumentNullException(nameof(snapshotSerializer));
}
var tempSettings = Build(connections, publisherFactory, eventSerializer);
var snapshotsSettings = new SnapshotsSettings(_thresholdResolver, snapshotSerializer);
return(new EventStoreSettings(
tempSettings.Store,
tempSettings.AggregateFactories,
snapshotsSettings));
}
public static void Register(IPublisherFactory factory)
{
_publisherSetting.Register(factory);
}
public Publisher(IPublisherFactory publisherFactory) => this.factory = publisherFactory;
