private ScopeProvider GetScopeProvider(out Mock <IEventAggregator> eventAggregatorMock)
{
NullLoggerFactory loggerFactory = NullLoggerFactory.Instance;
var fileSystems = new FileSystems(
loggerFactory,
Mock.Of <IIOHelper>(),
Options.Create(new GlobalSettings()),
Mock.Of <IHostingEnvironment>());
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
loggerFactory.CreateLogger <MediaFileManager>(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
eventAggregatorMock = new Mock <IEventAggregator>();
return(new ScopeProvider(
Mock.Of <IUmbracoDatabaseFactory>(),
fileSystems,
Options.Create(new CoreDebugSettings()),
mediaFileManager,
loggerFactory.CreateLogger <ScopeProvider>(),
loggerFactory,
Mock.Of <IRequestCache>(),
eventAggregatorMock.Object
));
}
public void ConversionPipelineTest()
{
// arrange
var logFactory = new NullLoggerFactory();
var input = new InputFormat[1] {
new InputFormat("test13;4803;1835;1558")
};
// act
var formatA = Transformations.ConvertCSVToFormatA(input, logFactory.CreateLogger("mock"));
var formatB = Transformations.ConvertFormatAToFormatB(formatA, logFactory.CreateLogger("mock"));
// assert
Assert.AreEqual("test13", formatA[0].N, "Name property should be equal to first part of CSV line");
}
/// <summary>
/// Starts listening for new Websocket stream connections
/// </summary>
/// <param name="endpoint">The endpoint to listen to</param>
/// <param name="connectionAdded">A connection delegate that is called when a new client is connected</param>
/// <param name="bufferSize">Buffer sized used for receiving</param>
/// <param name="defaultPage">Default response to clients like browsers</param>
/// <returns></returns>
public Task StartAsync(IPEndPoint endpoint, Func <WsStream, Task> connectionAdded, int bufferSize = Config.InternalBufferSize, string defaultPage = Config.Version)
{
if (IsListening)
{
throw new InvalidOperationException("WsServer is already running!");
}
_stopSource = new CancellationTokenSource();
IsListening = true;
// setup kestrel parameters
var logger = new NullLoggerFactory();
var kestrelOptions = new KestrelServerOptions();
var lifetime = new ApplicationLifetime(logger.CreateLogger <ApplicationLifetime>());
var socketTransportFactory = new SocketTransportFactory(Options.Create(new SocketTransportOptions()), lifetime, logger);
// start kestrel
_server = new KestrelServer(Options.Create(kestrelOptions), socketTransportFactory, logger);
_server.Options.Listen(endpoint);
return(_server
.StartAsync(new KestrelRequestHandler(connectionAdded, bufferSize, _stopSource.Token, defaultPage),
CancellationToken.None).ContinueWith(
x =>
{
var addr = _server.Features.Get <IServerAddressesFeature>();
ListeningAddresses = addr.Addresses.ToArray();
}));
}
private ScopeProvider GetScopeProvider(NullLoggerFactory instance)
{
var fileSystems = new FileSystems(
instance,
Mock.Of <IIOHelper>(),
Options.Create(new GlobalSettings()),
Mock.Of <IHostingEnvironment>());
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
instance.CreateLogger <MediaFileManager>(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
return(new ScopeProvider(
Mock.Of <IUmbracoDatabaseFactory>(),
fileSystems,
Options.Create(new CoreDebugSettings()),
mediaFileManager,
Mock.Of <ILogger <ScopeProvider> >(),
instance,
Mock.Of <IRequestCache>(),
Mock.Of <IEventAggregator>()
));
}
public PlayerControllerTest()
{
PlayerRepository.InitializePlayerDataFromCsv(Resources.ControllerTestData);
ILoggerFactory mockFactory = new NullLoggerFactory();
_controller = new PlayerController(mockFactory.CreateLogger <PlayerController>(), new PlayerService());
}
private static RSocketClient CreateClient()
{
var factory = new NullLoggerFactory();
var transport = new ClientWebSocketTransport("ws://localhost:5000/api", factory.CreateLogger <WebSocketTransport>());
return(new RSocketClient(transport));
}
static LoggingFactory()
{
ILoggerFactory loggerFactory = new NullLoggerFactory()
.AddConsole()
.AddDebug();
_logger = loggerFactory.CreateLogger("DBSeed");
}
public PersonControllerTest(ITestOutputHelper testOutputHelper)
{
_testOutputHelper = testOutputHelper;
ILoggerFactory loggerFactory = new NullLoggerFactory();
_controller = new PersonController(loggerFactory.CreateLogger <PersonController>());
_person = new PersonDto(99999, "MyTest", "MyTest", "*****@*****.**", "test", "test",
"test", "03 87 87 87 87", 2, "Test", "Test");
}
public void ConvertMethod_ThrowsException_InCaseOfInvalidInput()
{
// arrange
var logFactory = new NullLoggerFactory();
var invalidInput = new InputFormat[1] {
new InputFormat("test13;4803;1835;zzz")
}; // Note zzzs at the end - should be integers
var actual = Transformations.ConvertCSVToFormatA(invalidInput, logFactory.CreateLogger("mock"));
}
public void NullLoggerTests()
{
ILoggerFactory factory = new NullLoggerFactory();
Assert.IsNotNull(factory);
ILogger logger = factory.CreateLogger();
Assert.IsNotNull(logger);
}
private static IServiceProvider MockFactory(Action <Mock <IServiceProvider> > setup = null)
{
// FIXME: use IUmbracoDatabaseFactory vs UmbracoDatabaseFactory, clean it all up!
var mock = new Mock <IServiceProvider>();
NullLoggerFactory loggerFactory = NullLoggerFactory.Instance;
ILogger logger = loggerFactory.CreateLogger("GenericLogger");
var globalSettings = new GlobalSettings();
var connectionStrings = new ConnectionStrings();
var mapperCollection = new NPocoMapperCollection(() => new[] { new NullableDateMapper() });
var f = new UmbracoDatabaseFactory(
loggerFactory.CreateLogger <UmbracoDatabaseFactory>(),
loggerFactory,
Options.Create(globalSettings),
Mock.Of <IOptionsMonitor <ConnectionStrings> >(x => x.CurrentValue == connectionStrings),
new MapperCollection(() => Enumerable.Empty <BaseMapper>()),
TestHelper.DbProviderFactoryCreator,
new DatabaseSchemaCreatorFactory(loggerFactory.CreateLogger <DatabaseSchemaCreator>(), loggerFactory, new UmbracoVersion(), Mock.Of <IEventAggregator>()),
mapperCollection);
var fs = new FileSystems(loggerFactory, IOHelper, Options.Create(globalSettings), Mock.Of <IHostingEnvironment>());
var coreDebug = new CoreDebugSettings();
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
Mock.Of <ILogger <MediaFileManager> >(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
IEventAggregator eventAggregator = Mock.Of <IEventAggregator>();
var scopeProvider = new ScopeProvider(f, fs, Options.Create(coreDebug), mediaFileManager, loggerFactory.CreateLogger <ScopeProvider>(), loggerFactory, NoAppCache.Instance, eventAggregator);
mock.Setup(x => x.GetService(typeof(ILogger))).Returns(logger);
mock.Setup(x => x.GetService(typeof(ILogger <ComponentCollection>))).Returns(loggerFactory.CreateLogger <ComponentCollection>);
mock.Setup(x => x.GetService(typeof(ILoggerFactory))).Returns(loggerFactory);
mock.Setup(x => x.GetService(typeof(IProfilingLogger))).Returns(new ProfilingLogger(loggerFactory.CreateLogger <ProfilingLogger>(), Mock.Of <IProfiler>()));
mock.Setup(x => x.GetService(typeof(IUmbracoDatabaseFactory))).Returns(f);
mock.Setup(x => x.GetService(typeof(IScopeProvider))).Returns(scopeProvider);
setup?.Invoke(mock);
return(mock.Object);
}
private CoreDependencies()
{
LoggerFactory = new NullLoggerFactory();
ServiceLogger = NullServiceLogger.Instance;
Tokenizer = new CodeWorksTokenizer(new NullTokenService());
RateLimiter = new InMemoryRateLimiter();
DistributedLockService = new InMemoryDistributedLock();
EnvironmentResolver = new NonProductionEnvironmentResolver();
RequestValidator = NullRequestValidator.Instance;
ChainedServiceResolver = new DefaultChainedServiceResolver(LoggerFactory.CreateLogger <DefaultChainedServiceResolver>());
UserResolver = NullUserResolver.Instance;
}
public async Task Create_SqliteDatabaseWithoutMigrationErrors()
{
var connectionString = $"Data Source={_databaseFilePath}";
ILoggerFactory loggerFactory = new NullLoggerFactory();
var dataContextFactory = new DataContextFactory(loggerFactory.CreateLogger <DataContextFactory>(), connectionString);
using (var dataContext = dataContextFactory.Create())
{
//Assert.IsTrue(await dataContext.Database.EnsureCreatedAsync(), "Database hos not been created");
Assert.IsTrue(dataContext.Database.IsSqlite(), "Is it not Sqlite database");
}
// Simple request
using (var dataContext = dataContextFactory.Create())
{
Assert.AreEqual(await dataContext.Clients.CountAsync(), 0);
}
var clientName = Guid.NewGuid().ToString();
Guid clientId;
// Create entity request
using (var dataContext = dataContextFactory.Create())
{
var clientEntity = new ClientEntity
{
Name = clientName
};
await dataContext.AddAsync(clientEntity);
await dataContext.SaveChangesAsync();
clientId = clientEntity.Id;
}
// Simple request
using (var dataContext = dataContextFactory.Create())
{
Assert.AreEqual(await dataContext.Clients.CountAsync(), 1);
var client = await dataContext.Clients.SingleOrDefaultAsync(x => x.Id == clientId);
Assert.IsNotNull(client);
Assert.AreEqual(client.Id, clientId);
Assert.AreEqual(client.Name, clientName);
}
}
static NpgsqlLoggingConfiguration()
{
var nullFactory = new NullLoggerFactory();
ConnectionLogger = nullFactory.CreateLogger("Npgsql.Connection");
CommandLogger = nullFactory.CreateLogger("Npgsql.Command");
TransactionLogger = nullFactory.CreateLogger("Npgsql.Transaction");
CopyLogger = nullFactory.CreateLogger("Npgsql.Copy");
ReplicationLogger = nullFactory.CreateLogger("Npgsql.Replication");
ExceptionLogger = nullFactory.CreateLogger("Npgsql.Exception");
}
public void ConvertMethod_ConvertsCSV_ToFormatA()
{
// arrange
var logFactory = new NullLoggerFactory();
var input = new InputFormat[1] {
new InputFormat("test13;4803;1835;1558")
};
// act
var conversion = Transformations.ConvertCSVToFormatA(input, logFactory.CreateLogger("mock"));
var actual = conversion[0];
// assert
Assert.AreEqual("test13", actual.N, "Name property should be equal to first part of CSV line");
Assert.AreEqual(4803, actual.F, "'First' property should equal 2nd part of CSV line");
Assert.AreEqual(1835, actual.S, "'Second' property should equal 3rd part of CSV line");
Assert.AreEqual(1558, actual.T, "'Third' property should equal 4th part of CSV line");
}
public void _Init()
{
var path = Path.GetFullPath(@"..\..\..\..\..\Programs\EBuEf2IVUPath\ebuef2ivupath-settings.example.xml");
var configBuilder = new ConfigurationBuilder();
configBuilder.AddXmlFile(
path: path,
optional: false,
reloadOnChange: false);
config = configBuilder.Build();
loggerFactory = new NullLoggerFactory();
var logger = loggerFactory.CreateLogger <Sender>();
var senderSettings = config
.GetSection(nameof(EBuEf2IVUPath.Settings.TrainPathSender))
.Get <EBuEf2IVUPath.Settings.TrainPathSender>();
var ignoreTrainTypes = senderSettings.IgnoreTrainTypes?.Split(
separator: EBuEf2IVUPath.Settings.TrainPathSender.SettingsSeparator,
options: StringSplitOptions.RemoveEmptyEntries);
sender = new Sender(logger);
sender.Initialize(
host: senderSettings.Host,
port: senderSettings.Port,
path: senderSettings.Path,
username: senderSettings.Username,
password: senderSettings.Password,
isHttps: senderSettings.IsHttps,
retryTime: senderSettings.RetryTime,
sessionKey: SessionKey,
sessionDate: DateTime.Today,
infrastructureManager: senderSettings.InfrastructureManager,
orderingTransportationCompany: senderSettings.OrderingTransportationCompany,
stoppingReasonStop: senderSettings.StoppingReasonStop,
stoppingReasonPass: senderSettings.StoppingReasonPass,
trainPathStateRun: senderSettings.TrainPathStateRun,
trainPathStateCancelled: senderSettings.TrainPathStateCancelled,
importProfile: senderSettings.ImportProfile,
preferPrognosis: senderSettings.PreferPrognosis,
ignoreTrainTypes: ignoreTrainTypes,
locationShortnames: default);
/// <summary>
/// The main entry point for the application.
/// </summary>
/// <param name="args">The arguments. </param>
internal static void Main(string[] args)
{
// todo: create with HostBuilder
var loggerFactory = new NullLoggerFactory().AddLog4Net(Log4NetConfigFilePath, true);
logger = loggerFactory.CreateLogger <Program>();
var addressResolver = IpAddressResolverFactory.DetermineIpResolver(args, loggerFactory);
var settings = new Settings("ChatServer.cfg");
var serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(ILoggerFactory), loggerFactory);
int chatServerListenerPort = settings.ChatServerListenerPort ?? 55980;
int exDbPort = settings.ExDbPort ?? 55906;
string exDbHost = settings.ExDbHost ?? "127.0.0.1";
try
{
// To make the chat server use our configured encryption key, we need to trick a bit. We add an endpoint with a special client version which is defined in the plugin.
var configuration = new ChatServerSettings();
configuration.Endpoints.Add(new ChatServerEndpoint {
ClientVersion = ConfigurableNetworkEncryptionPlugIn.Version, NetworkPort = chatServerListenerPort
});
var pluginManager = new PlugInManager(null, loggerFactory, serviceContainer);
pluginManager.DiscoverAndRegisterPlugInsOf <INetworkEncryptionFactoryPlugIn>();
var chatServer = new ChatServer(configuration, addressResolver, loggerFactory, pluginManager);
chatServer.Start();
var exDbClient = new ExDbClient(exDbHost, exDbPort, chatServer, chatServerListenerPort, loggerFactory);
logger.LogInformation("ChatServer started and ready");
while (Console.ReadLine() != "exit")
{
// keep application running
}
exDbClient.Disconnect();
chatServer.Shutdown();
}
catch (Exception ex)
{
logger.LogCritical(ex, "Unexpected error occured");
}
}
public void Setup()
{
var validators = new IManifestValueValidator[]
{
new RequiredValidator(Mock.Of <ILocalizedTextService>()),
new RegexValidator(Mock.Of <ILocalizedTextService>(), null),
new DelimitedValueValidator(),
};
_ioHelper = TestHelper.IOHelper;
NullLoggerFactory loggerFactory = NullLoggerFactory.Instance;
_parser = new ManifestParser(
AppCaches.Disabled,
new ManifestValueValidatorCollection(() => validators),
new ManifestFilterCollection(() => Enumerable.Empty <IManifestFilter>()),
loggerFactory.CreateLogger <ManifestParser>(),
_ioHelper,
TestHelper.GetHostingEnvironment(),
new JsonNetSerializer(),
Mock.Of <ILocalizedTextService>(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IDataValueEditorFactory>());
}
public ControllerUnitTests()
{
mockLoggerFactory = new NullLoggerFactory();
mockLogger = mockLoggerFactory.CreateLogger <MainController>();
}
public static ILogger CreateLogger(string categoryName) => LoggerFactory?.CreateLogger(categoryName) ?? NullLoggerFactory.CreateLogger(categoryName);
public static ILogger CreateLogger <T>() => LoggerFactory?.CreateLogger <T>() ?? NullLoggerFactory.CreateLogger <T>();
internal static EventHubClientFactory CreateFactory(IConfiguration configuration, EventHubOptions options, AzureComponentFactory componentFactory = null)
{
componentFactory ??= Mock.Of <AzureComponentFactory>();
var loggerFactory = new NullLoggerFactory();
var azureEventSourceLogForwarder = new AzureEventSourceLogForwarder(loggerFactory);
return(new EventHubClientFactory(
configuration,
componentFactory,
Options.Create(options),
new DefaultNameResolver(configuration),
azureEventSourceLogForwarder,
new CheckpointClientProvider(configuration, componentFactory, azureEventSourceLogForwarder, loggerFactory.CreateLogger <BlobServiceClient>())));
}
public void Setup()
{
var fakeAdminUser = UserFakes.GetFakeAdminUser();
var adminClaims = new List <Claim>();
adminClaims.Add(new Claim(ClaimTypes.NameIdentifier, fakeAdminUser.Id.ToString()));
adminClaims.Add(new Claim(ClaimTypes.Role, fakeAdminUser.Role.ToString()));
var adminHttpContext = GetHttpContext(adminClaims);
var adminHttpContextAccessorMock = new Mock <IHttpContextAccessor>();
adminHttpContextAccessorMock.Setup(x => x.HttpContext).Returns(adminHttpContext);
var fakeCustomerUser = UserFakes.GetFakeCustomerUser();
var customerClaims = new List <Claim>();
customerClaims.Add(new Claim(ClaimTypes.NameIdentifier, fakeCustomerUser.Id.ToString()));
customerClaims.Add(new Claim(ClaimTypes.Role, fakeCustomerUser.Role.ToString()));
var customerHttpContext = GetHttpContext(customerClaims);
var customerHttpContextAccessorMock = new Mock <IHttpContextAccessor>();
customerHttpContextAccessorMock.Setup(x => x.HttpContext).Returns(customerHttpContext);
var nullLoggerFactory = new NullLoggerFactory();
var nullLogger = nullLoggerFactory.CreateLogger("NullLogger");
var builder = new DbContextOptionsBuilder <UserContext>();
builder.UseInMemoryDatabase("CustomerLoans");
var options = builder.Options;
var userContext = new UserContext(options);
var inMemoryEFUserQueryable = new EntityFrameworkCodeFirstQueryable <User>(userContext);
var inMemoryUserQueryableRepository = new QueryableRepository <User>(inMemoryEFUserQueryable);
var inMemoryUserQueryableDomainService = new QueryableDomainService <User, int>(inMemoryUserQueryableRepository);
var inMemoryEFUserCommand = new EntityFrameworkCodeFirstCommand <User, int>(userContext);
var inMemoryUserCommandRepository = new CommandRepository <User>(inMemoryEFUserCommand);
var inMemoryUserCommandServiceAsync = new CommandDomainServiceAsync <User>(inMemoryUserCommandRepository, nullLogger);
var retryPolicy = new RetryNTimesPolicy(nullLogger, 3);
var exceptionHandler = new BasicPollyExceptionHandler(new IPolicy[] { retryPolicy }, nullLogger, true);
var myConfiguration = new Dictionary <string, string>
{
{ "Audience:Secret", "Y2F0Y2hlciUyMHdvbmclMjBsb3ZlJTIwLm5ldA==" },
{ "Audience:Iss", "Sandip Ray" },
{ "Audience:Aud", "All" },
};
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(myConfiguration)
.Build();
var configOptions = new OptionsWrapper <MemoryDistributedCacheOptions>(new MemoryDistributedCacheOptions());
var distributedCache = new MemoryDistributedCache(configOptions);
var tokenManagerMock = new Mock <TokenManager>(distributedCache);
_adminUserController = new UserController(adminHttpContextAccessorMock.Object,
inMemoryUserQueryableDomainService, inMemoryUserCommandServiceAsync,
exceptionHandler, configuration,
tokenManagerMock.Object);
_customerUserController = new UserController(customerHttpContextAccessorMock.Object,
inMemoryUserQueryableDomainService, inMemoryUserCommandServiceAsync,
exceptionHandler, configuration,
tokenManagerMock.Object);
}
public AuthenticationControllerUnitTests()
{
mockLoggerFactory = new NullLoggerFactory();
mockLogger = mockLoggerFactory.CreateLogger <AuthenticationController>();
}
static void Main(string[] args)
{
var loggerFactory = new NullLoggerFactory();
var transport = new ClientWebSocketTransport("ws://localhost:5000/api", loggerFactory.CreateLogger <WebSocketTransport>());
var client = new RSocketClient(transport);
var dataProvider = new ShopListApiDataProvider(client);
//var invoker = new DefaultCallInvoker(null);
var engine = new ShopMeEngine(dataProvider, null);
RetrieveListAsync(client, engine).Wait();
System.Console.WriteLine("Press key to close");
System.Console.ReadLine();
}
public void Setup()
{
var adminClaims = new List <Claim>();
adminClaims.Add(new Claim(ClaimTypes.NameIdentifier, "1"));
adminClaims.Add(new Claim(ClaimTypes.Role, "Admin"));
var adminHttpContext = GetHttpContext(adminClaims);
var adminHttpContextAccessorMock = new Mock <IHttpContextAccessor>();
adminHttpContextAccessorMock.Setup(x => x.HttpContext).Returns(adminHttpContext);
var customerClaims = new List <Claim>();
customerClaims.Add(new Claim(ClaimTypes.NameIdentifier, "2"));
customerClaims.Add(new Claim(ClaimTypes.Role, "Customer"));
var customerHttpContext = GetHttpContext(customerClaims);
var customerHttpContextAccessorMock = new Mock <IHttpContextAccessor>();
customerHttpContextAccessorMock.Setup(x => x.HttpContext).Returns(customerHttpContext);
var nullLoggerFactory = new NullLoggerFactory();
var nullLogger = nullLoggerFactory.CreateLogger("NullLogger");
var builder = new DbContextOptionsBuilder <LoanContext>();
builder.UseInMemoryDatabase("CustomerLoans");
var options = builder.Options;
var loanContext = new LoanContext(options);
var inMemoryEFLoanQueryable = new EntityFrameworkCodeFirstQueryable <Loan>(loanContext);
var inMemoryLoanQueryableRepository = new QueryableRepository <Loan>(inMemoryEFLoanQueryable);
var inMemoryLoanQueryableDomainService = new QueryableDomainService <Loan, int>(inMemoryLoanQueryableRepository);
var inMemoryEFLoanCommand = new EntityFrameworkCodeFirstCommand <Loan, int>(loanContext);
var inMemoryLoanCommandRepository = new CommandRepository <Loan>(inMemoryEFLoanCommand);
var inMemoryLoanCommandServiceAsync = new CommandDomainServiceAsync <Loan>(inMemoryLoanCommandRepository, nullLogger);
var retryPolicy = new RetryNTimesPolicy(nullLogger, 3);
var exceptionHandler = new BasicPollyExceptionHandler(new IPolicy[] { retryPolicy }, nullLogger, true);
var myConfiguration = new Dictionary <string, string>
{
{ "CustomerUrl", "CustomerUrl" }
};
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(myConfiguration)
.Build();
//var configOptions = new OptionsWrapper<MemoryDistributedCacheOptions>(new MemoryDistributedCacheOptions());
//var distributedCache = new MemoryDistributedCache(configOptions);
var tokenManagerMock = new Mock <ITokenManager>();
tokenManagerMock.Setup(x => x.GetTokenCacheDataAsync(It.IsAny <string>(), default)).Returns(Task.Run(() => new TokenCacheData {
Token = "TestToken"
}));
var httpClientFactoryMock = new Mock <IHttpClientFactory>();
httpClientFactoryMock.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(new HttpClient());
_adminLoanController = new LoanController(adminHttpContextAccessorMock.Object,
inMemoryLoanQueryableDomainService, inMemoryLoanCommandServiceAsync,
exceptionHandler, configuration,
tokenManagerMock.Object, httpClientFactoryMock.Object);
_customerLoanController = new LoanController(customerHttpContextAccessorMock.Object,
inMemoryLoanQueryableDomainService, inMemoryLoanCommandServiceAsync,
exceptionHandler, configuration,
tokenManagerMock.Object, httpClientFactoryMock.Object);
}
