public static void XUnitLoggerProvider_Creates_Logger(Constructor constructor)
{
// Arrange
var testOutputHelper = Mock.Of <ITestOutputHelper>();
var messageSink = Mock.Of <IMessageSink>();
var options = new XUnitLoggerOptions();
string categoryName = "MyLogger";
using var target = constructor switch
{
Constructor.ITestOutputHelper => new XUnitLoggerProvider(testOutputHelper, options),
Constructor.IMessageSink => new XUnitLoggerProvider(messageSink, options),
_ => throw new ArgumentOutOfRangeException(nameof(constructor), constructor, null),
};
// Act
ILogger actual = target.CreateLogger(categoryName);
// Assert
actual.ShouldNotBeNull();
var xunit = actual.ShouldBeOfType <XUnitLogger>();
xunit.Name.ShouldBe(categoryName);
xunit.Filter.ShouldBeSameAs(options.Filter);
xunit.MessageSinkMessageFactory.ShouldBeSameAs(options.MessageSinkMessageFactory);
xunit.IncludeScopes.ShouldBeFalse();
}
public UserRepository(ILogger <UserRepository> logger, MongoDbConfiguration configuration) : base(configuration)
{
logger.ShouldNotBeNull();
configuration.ShouldNotBeNull();
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="FileRepositoryContext"/> class.
/// </summary>
/// <param name="filePath">The path to the repository file.</param>
/// <param name="logger">The logger to use for logging.</param>
public FileRepositoryContext(string filePath, ILogger logger)
{
filePath.ShouldNotBeNullEmptyOrWhiteSpace(nameof(filePath));
logger.ShouldNotBeNull(nameof(logger));
this.filePath = filePath;
this.logger = logger;
}
/// <summary>
/// Initialises an instance of the <see cref="AmqpConnection"/> class.
/// </summary>
/// <param name="logger">
/// </param>
/// <param name="registration">
/// Details required to connect to the queued message server.
/// </param>
public AmqpConnection(ILogger logger, RegistrationData registration)
{
registration.ShouldNotBeNull();
logger.ShouldNotBeNull();
m_Address = registration.Address;
m_Logger = logger;
}
/// <summary>
/// Initialises an instance of a <see cref="MultiServiceHost"/> class.
/// </summary>
/// <param name="logger">
/// Logging provider.
/// </param>
public MultiServiceHost(ILogger logger)
{
logger.ShouldNotBeNull();
m_ServiceEntries = new Hashtable();
m_Logger = logger;
m_ResourceLoader = new ServicesResourceLoader();
}
/// <summary>
/// Initialises an instance of the <see cref="ArchiveDataService"/> class.
/// </summary>
/// <param name="logger"></param>
/// <param name="fileHelper"></param>
/// <param name="configuration"></param>
public ArchiveDataService(ILogger logger, IFileHelper fileHelper, BufferedConfiguration configuration) : base(logger, typeof(ArchiveDataService))
{
logger.ShouldNotBeNull();
fileHelper.ShouldNotBeNull();
configuration.ShouldNotBeNull();
m_FileHelper = fileHelper;
m_Configuration = configuration;
m_Logger = logger;
m_SyncObject = new object();
}
public StatisticsController(IStatisticsBusiness statisticsBusiness, ILogger <StatisticsController> logger,
IStatisticsProvider statisticsProvider)
{
statisticsBusiness.ShouldNotBeNull();
logger.ShouldNotBeNull();
statisticsProvider.ShouldNotBeNull();
_statisticsBusiness = statisticsBusiness;
_logger = logger;
_statisticsProvider = statisticsProvider;
}
public UserController(IUserRepository userRepository, ILogger <UserController> logger,
IUserBusiness userBusiness)
{
userRepository.ShouldNotBeNull();
logger.ShouldNotBeNull();
userBusiness.ShouldNotBeNull();
_userRepository = userRepository;
_logger = logger;
_userBusiness = userBusiness;
}
public MasterDataController(IMasterDataBusiness masterDataBusiness, ILogger <MasterDataController> logger,
IUserBusiness userBusiness, IDepartmentRepository departmentRepository)
{
masterDataBusiness.ShouldNotBeNull();
userBusiness.ShouldNotBeNull();
logger.ShouldNotBeNull();
departmentRepository.ShouldNotBeNull();
_masterDataBusiness = masterDataBusiness;
_logger = logger;
_userBusiness = userBusiness;
_departmentRepository = departmentRepository;
}
public ChatController(IChatRepository chatRepository, ILogger <ChatController> logger,
IChatBusiness chatBusiness, IMessageInterpreter messageInterpreter)
{
chatRepository.ShouldNotBeNull();
logger.ShouldNotBeNull();
chatBusiness.ShouldNotBeNull();
messageInterpreter.ShouldNotBeNull();
_chatRepository = chatRepository;
_logger = logger;
_chatBusiness = chatBusiness;
_messageInterpreter = messageInterpreter;
_messageInterpreter = messageInterpreter;
}
/// <summary>
/// Initialises an instance of the publisher.
/// </summary>
/// <param name="logger"></param>
/// <param name="connection">
/// The AMQP connection to use.
/// </param>
/// <param name="topicName">
/// The topic name to publish to.
/// </param>
/// <param name="name">
/// The unique name to associate with the link used to send messages on.
/// </param>
/// <param name="isDurable">
/// Indicates whether the messages should be durable (Persistent).
/// </param>
public AmqpMessagePublisher(ILogger logger, AmqpConnection connection, string topicName, string name, bool isDurable = true)
{
connection.ShouldNotBeNull();
topicName.ShouldNotBeEmpty();
name.ShouldNotBeEmpty();
logger.ShouldNotBeNull();
m_Logger = logger;
m_ConnectionId = string.Empty;
m_Connection = connection;
m_TopicName = topicName;
m_Name = name;
m_IsDurable = isDurable;
m_SendTimeoutInMilliseconds = 10000;
}
public static void XUnitLoggerProvider_Creates_Logger()
{
// Arrange
var outputHelper = Mock.Of <ITestOutputHelper>();
var options = new XUnitLoggerOptions();
string categoryName = "MyLogger";
using (var target = new XUnitLoggerProvider(outputHelper, options))
{
// Act
ILogger actual = target.CreateLogger(categoryName);
// Assert
actual.ShouldNotBeNull();
var xunit = actual.ShouldBeOfType <XUnitLogger>();
xunit.Name.ShouldBe(categoryName);
xunit.Filter.ShouldBeSameAs(options.Filter);
xunit.IncludeScopes.ShouldBeFalse();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ThreadedService"/> class.
/// </summary>
/// <param name="logger">
/// A logging provider.
/// </param>
protected ThreadedService(ILogger logger, Type serviceType) : this(serviceType)
{
logger.ShouldNotBeNull();
m_Logger = logger;
m_IsLoggingEnabled = true;
}
public KnowledgeRepository(MongoDbConfiguration configuration, ILogger <KnowledgeRepository> logger) : base(
configuration)
{
logger.ShouldNotBeNull();
_logger = logger;
}
/// <summary>
/// Initialises an instance of the publisher.
/// </summary>
/// <param name="connection">
/// The AMQP connection to use.
/// </param>
/// <param name="topicName">
/// The topic name to publish to.
/// </param>
/// <param name="name">
/// The unique name to associate with the link used to receive messages on.
/// </param>
/// <param name="handler">
/// Processes incoming messages from the AMQP server.
/// </param>
public AmqpMessageSubscriber(ILogger logger, AmqpConnection connection, string topicName, string name, IMessageHandler handler, int windowSize = 20)
{
connection.ShouldNotBeNull();
topicName.ShouldNotBeEmpty();
handler.ShouldNotBeNull();
name.ShouldNotBeEmpty();
logger.ShouldNotBeNull();
m_Logger = logger;
m_Connection = connection;
m_ConnectionId = string.Empty;
m_TopicName = topicName;
m_MessageHandler = handler;
m_WindowSize = windowSize;
m_Name = name;
}
/// <summary>
/// Initialises an instance of the <see cref="NetworkHelper"/> class.
/// </summary>
/// <param name="logger">
/// A logging provider.
/// </param>
public NetworkHelper(ILogger logger)
{
logger.ShouldNotBeNull();
m_Interfaces = NetworkInterface.GetAllNetworkInterfaces();
m_WaitForNetwork = new AutoResetEvent(false);
m_WaitForAddressChange = new AutoResetEvent(false);
m_SyncLock = new object();
m_Logger = logger;
m_WaitForNetworkEventInMilliseconds = 2000;
}
/// <summary>
/// Initialises an instance of the <see cref="BufferedLoggingService"/> class.
/// </summary>
/// <param name="fileHelper">
/// Helper for working with files.
/// </param>
/// <param name="configuration">
/// Configuration details for buffered data persistence.
/// </param>
public BufferedLoggingService(LogContainer container, ILogger logger, IFileHelper fileHelper, BufferedConfiguration configuration) : base(logger, typeof(BufferedLoggingService))
{
logger.ShouldNotBeNull();
fileHelper.ShouldNotBeNull();
configuration.ShouldNotBeNull();
m_LogEntries = container;
m_BatchSize = 2;
m_BufferSize = 512;
m_FileHelper = fileHelper;
m_WorkingFilePath = configuration.WorkingPath;
m_TargetFilePath = configuration.TargetPath;
m_TargetFileExtension = configuration.TargetFileExtension;
m_WorkingFileExtension = configuration.WorkingFileExtension;
}
