public Session(
Application app, MessageStoreFactory storeFactory, SessionID sessID, DataDictionaryProvider dataDictProvider,
SessionSchedule sessionSchedule, int heartBtInt, LogFactory logFactory, IMessageFactory msgFactory, string senderDefaultApplVerID)
{
this.Application = app;
this.SessionID = sessID;
this.DataDictionaryProvider = new DataDictionaryProvider(dataDictProvider);
this.schedule_ = sessionSchedule;
this.msgFactory_ = msgFactory;
this.SenderDefaultApplVerID = senderDefaultApplVerID;
this.SessionDataDictionary = this.DataDictionaryProvider.GetSessionDataDictionary(this.SessionID.BeginString);
if (this.SessionID.IsFIXT)
this.ApplicationDataDictionary = this.DataDictionaryProvider.GetApplicationDataDictionary(this.SenderDefaultApplVerID);
else
this.ApplicationDataDictionary = this.SessionDataDictionary;
Log log;
if (null != logFactory)
log = logFactory.Create(sessID);
else
log = new NullLog();
state_ = new SessionState(log, heartBtInt)
{
MessageStore = storeFactory.Create(sessID)
};
this.PersistMessages = true;
this.ResetOnDisconnect = false;
this.SendRedundantResendRequests = false;
this.ValidateLengthAndChecksum = true;
this.CheckCompID = true;
this.MillisecondsInTimeStamp = true;
this.EnableLastMsgSeqNumProcessed = false;
this.MaxMessagesInResendRequest = 0;
this.SendLogoutBeforeTimeoutDisconnect = false;
this.IgnorePossDupResendRequests = false;
if (!IsSessionTime)
Reset("Out of SessionTime at construction");
else if (IsNewSession)
Reset("New session");
lock (sessions_)
{
sessions_[this.SessionID] = this;
}
this.Application.OnCreate(this.SessionID);
this.Log.OnEvent("Created session");
}
/// FIXME
public Session(
Application app, MessageStoreFactory storeFactory, SessionID sessID, DataDictionaryProvider dataDictProvider,
SessionSchedule sessionSchedule, int heartBtInt, LogFactory logFactory, IMessageFactory msgFactory)
{
this.Application = app;
this.SessionID = sessID;
this.DataDictionaryProvider = new DataDictionaryProvider(dataDictProvider);
this.schedule_ = sessionSchedule;
this.msgFactory_ = msgFactory;
this.SessionDataDictionary = this.DataDictionaryProvider.GetSessionDataDictionary(this.SessionID.BeginString);
if (this.SessionID.IsFIXT)
this.ApplicationDataDictionary = this.DataDictionaryProvider.GetApplicationDataDictionary(this.SenderDefaultApplVerID);
else
this.ApplicationDataDictionary = this.SessionDataDictionary;
Log log;
if (null != logFactory)
log = logFactory.Create(sessID);
else
log = new NullLog();
state_ = new SessionState(log, heartBtInt);
state_.MessageStore = storeFactory.Create(sessID);
this.PersistMessages = true;
this.ResetOnDisconnect = false;
this.SendRedundantResendRequests = false;
this.ValidateLengthAndChecksum = true;
this.CheckCompID = true;
if (!CheckSessionTime())
Reset();
lock (sessions_)
{
sessions_[this.SessionID] = this;
}
this.Application.OnCreate(this.SessionID);
this.Log.OnEvent("Created session");
}
public static IContainer CreateIntegrationContainer()
{
var builder = new ContainerBuilder();
var appSettings = LoadAppSettings();
builder.RegisterInstance(LogFactory.Create().AddUnbufferedConsole())
.As <ILogFactory>()
.As <LogFactory>()
.SingleInstance();
builder.RegisterModule(new JobModule(appSettings));
builder.RegisterModule(new RepositoriesModule(appSettings));
builder.RegisterModule(new BlockchainsModule(appSettings));
builder.RegisterModule(new CqrsTestModule(
appSettings.CurrentValue.BlockchainCashinDetectorJob.Cqrs, "test"));
var testContainer = builder.Build();
return(testContainer);
}
public async Task TryToInitServiceTwice_InvalidOperation_ExceptionIsThrown()
{
var snapshotRepo = Mock.Of <ITokensSnapshotRepository>();
var lastTokensTotalAmountRepo = Mock.Of <ILastKnownStatsRepository>();
var pbfClient = Mock.Of <IPrivateBlockchainFacadeClient>();
TokensStatisticsService tokensStatisticsService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
tokensStatisticsService = new TokensStatisticsService(logFactory,
pbfClient,
snapshotRepo,
lastTokensTotalAmountRepo);
}
await tokensStatisticsService.Initialize();
await Assert.ThrowsAsync <InvalidOperationException>(() => tokensStatisticsService.Initialize());
}
public async Task Handle(SimDirectiveResult result)
{
if (result.IsExecOk && result.Status)
{
SuccessHandler?.Invoke(result);
}
else if (_retryTimes < 5)
{
LogFactory.Create().Info("sim resend times:" + _retryTimes);
this._retryTimes++;
await Task.Delay(500);
SimWorker.Instance.Enqueue(this);
}
else
{
LogFactory.Create().Info("sim resend failed");
}
}
private ILogFactory InitLogFactory(LoggerBuilderSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (string.IsNullOrEmpty(settings.AppName))
{
throw new ArgumentNullException(nameof(settings.AppName));
}
if (string.IsNullOrEmpty(settings.TableName))
{
throw new ArgumentNullException(nameof(settings.TableName));
}
return(LogFactory.Create()
.AddConsole()
.AddAzureTable(settings.ConnectionString, settings.TableName)
.AddEssentialSlackChannels(settings.SlackNotificationsConnectionString, settings.SlackNotificationsQueueName));
}
public IntegrationTestBase(
ITestOutputHelper outputHelper,
WebApplicationFactory <Startup> factory)
{
var loggerFactory = LogFactory.Create(outputHelper);
loggerFactory.AddProvider(new TestOutputLoggerProvider(outputHelper));
var httpClient = factory.CreateClient();
RequestService = new TestRequestService(httpClient, loggerFactory);
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddJsonFile("appsettings.Development.json", optional: true)
.Build();
MicroserviceSettings = configuration.GetSection(nameof(MicroserviceSettings)).Get <MicroserviceSettings>();
}
private static void Restore()
{
var files = new DirectoryInfo(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)).GetFiles("*.zip");
foreach (var file in files)
{
try
{
var task = new RestorePortalTask(LogFactory.Create("ASC"), ToAbsolute("TeamLabSvc.exe.config"), file.FullName);
task.ProgressChanged += (sender, args) => log.Info(args.Progress);
task.UnblockPortalAfterCompleted = true;
task.ReplaceDate = true;
task.RunJob();
}
catch (Exception error)
{
log.Error(error);
}
}
}
public async Task UserTriesToConfirmEmail_WithVerificationCodeThatNotExistsInTheSrorage_VerificationCodeMismatchReturned()
{
var verificationEmailRepository = new Mock <IEmailVerificationCodeRepository>();
var verificationEmailGetResponse = GetMockedVerificationCode();
var confirmEmailResponse = new ConfirmVerificationCodeResultModel
{
Error = VerificationCodeError.VerificationCodeMismatch,
IsVerified = true
};
verificationEmailRepository
.Setup(x => x.GetByValueAsync(It.IsAny <string>()))
.ReturnsAsync(verificationEmailGetResponse.Object);
verificationEmailRepository
.Setup(x => x.CreateOrUpdateAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(verificationEmailGetResponse.Object);
var publisherCodeVerified = new Mock <IRabbitPublisher <AdminEmailVerifiedEvent> >();
EmailVerificationService emailVerificationService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
emailVerificationService = new EmailVerificationService(
verificationEmailRepository.Object,
publisherCodeVerified.Object,
_notificationsServiceMock.Object,
_adminUserServiceMock.Object,
logFactory
);
}
var result =
await emailVerificationService.ConfirmCodeAsync("123456".ToBase64());
Assert.Equal(confirmEmailResponse.Error.ToString(), result.Error.ToString());
Assert.False(result.IsVerified);
}
public async Task UserTriesToLogIn_WithInvalidFormatEmail_InvalidEmailOrPasswordFormatErrorReturned()
{
var sessionsServiceClient = new Mock <ISessionsServiceClient>();
var credentialsClient = new Mock <ICredentialsClient>();
var adminUsersService = new Mock <IAdminUserService>();
var exception = new ClientApiException(HttpStatusCode.BadRequest, new ErrorResponse());
var adminUsersServiceResponse = new AdminUserResult
{
Error = AdminUserErrorCodes.None,
Profile = new AdminUser
{
IsActive = true
}
};
credentialsClient
.Setup(x => x.Admins.ValidateAsync(It.IsAny <CredentialsValidationRequest>()))
.Throws(exception);
adminUsersService
.Setup(x => x.GetByEmailAsync(It.IsAny <string>(), null))
.ReturnsAsync(adminUsersServiceResponse);
AuthService authService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
authService = new AuthService(
sessionsServiceClient.Object,
credentialsClient.Object,
adminUsersService.Object,
logFactory);
}
var result = await authService.AuthAsync("email", "password");
Assert.Equal(ServicesError.InvalidEmailOrPasswordFormat.ToString(), result.Error.ToString());
Assert.Null(result.CustomerId);
Assert.Null(result.Token);
}
public void Simple_Test()
{
InitializeDependencies();
_indexCalculator = new IndexCalculator(
LyCi,
ShortLyCi,
true,
_timerInterval,
_settingsService,
_indexStateRepository,
_indexHistoryRepository,
_tickPricesService,
_coinMarketCapService,
_tickPricePublisher,
_warningRepository,
_firstStateAfterResetTimeRepository,
_indexHandler,
LogFactory.Create());
_indexCalculator.Start();
_indexCalculator.Rebuild();
var stepsCount = GetPrices(0).Count - 1; // without header
var counter = 0;
while (_step != stepsCount)
{
counter++;
Thread.Sleep(1000);
if (counter > 10)
{
throw new TimeoutException("Debug IndexCalculator.CalculateThenSaveAndPublishAsync() to find exception.");
}
}
_indexCalculator.Stop();
}
public async Task LogsDeleted_When_TwoLogsExist()
{
// Arrange
var logs = LogFactory.Create(2);
_logRepositoryMock.Setup(x => x.GetAllAsync()).Returns(Task.FromResult(logs));
var exceptionLogDumpCreator = new DistributeLogDumpCreator(
_logRepositoryMock.Object,
_dateTimeProvider.Object,
_fileProvider.Object,
_directoryProvider.Object,
_pathProvider.Object,
_consoleProvider.Object,
_reflectionProvider.Object);
// Act
await exceptionLogDumpCreator.DeleteAllDumpsAsync();
// Assert
_logRepositoryMock.Verify(x => x.DeleteAsync(logs), Times.AtLeastOnce());
}
public async Task TryingToDeleteProfileContactByLocationId_ValidLocationId_SuccessfullyDeleted()
{
var partnerContactRepository = new Mock <IPartnerContactRepository>();
partnerContactRepository
.Setup(x => x.DeleteIfExistsAsync(It.IsAny <string>()))
.Verifiable();
PartnerContactService partnerContactService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
partnerContactService = new PartnerContactService(
partnerContactRepository.Object,
logFactory);
}
await partnerContactService.RemoveIfExistsAsync("testContactId");
partnerContactRepository.Verify();
}
protected ISignServiceApi CreateClientApi <TStartup>(string integrationName, string localhost, TimeSpan?timeout = null) where TStartup : class
{
IServiceCollection collection = new ServiceCollection();
var testServer = CreateTestServer <TStartup>();
var client = testServer.CreateClient();
collection.AddSingleton(LogFactory.Create().AddConsole());
collection.AddSignServiceClient(options =>
{
options.Timeout = timeout;
options.AddDelegatingHandler(new RedirectToTestHostMessageHandler(client));
options.AddIntegration(integrationName, integrationOptions =>
{
integrationOptions.Url = localhost;
});
});
var provider = collection.BuildServiceProvider();
var api = provider.GetRequiredService <ISignServiceApiProvider>().GetApi(integrationName);
return(api);
}
private void ReceiveCallback(IAsyncResult result)
{
try
{
var ts = (Socket)result.AsyncState;
var len = ts.EndReceive(result);
result.AsyncWaitHandle.Close();
if (len > 0)
{
byte[] bufferTemp = new byte[len];
ByteMencpy(bufferTemp, buffer, len);
LogFactory.Create().Info("receive ->" + Common.Utility.Common.BytesToString(bufferTemp) + "<- receive end");
}
ts.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), ts);
}
catch (SocketException e)
{
LogFactory.Create().Info("接收异常:" + e.Message);
}
}
private async Task StartNextLoop(Tuple <DateTime, double, double> next)
{
if (next != null)
{
var interval = (int)((DateTime)next.Item1 - DateTime.Now).TotalMilliseconds;
LogFactory.Create().Info($"StartNextLoop pump{PumpCultivation.Device.DeviceId} starttime{next.Item1:yyyy-MM-dd HH:mm:ss}, interval{interval}");
if (interval < 0)
{
interval = 0;
}
try
{
await Task.Delay(interval, CancellationTokenSource.Token);
await ExecStart(next.Item2, next.Item3);
}
catch (Exception)
{
LogFactory.Create().Info($"DEVICE{Device.DeviceId} StartNextLoop is cancel");
}
}
}
public async Task UserTriesToConfirmEmail_WithVerificationCodeThatHasAlreadyExpired_VerificationCodeExpiredReturned()
{
var verificationEmailRepository = new Mock <IEmailVerificationCodeRepository>();
var verificationEmailGetResponse = GetMockedVerificationCode();
verificationEmailGetResponse.SetupProperty(_ => _.ExpireDate, DateTime.UtcNow.AddYears(-1000));
var confirmEmailResponse = new ConfirmVerificationCodeResultModel
{
Error = VerificationCodeError.VerificationCodeExpired,
IsVerified = true
};
verificationEmailRepository
.Setup(x => x.GetByValueAsync(It.IsAny <string>()))
.ReturnsAsync(verificationEmailGetResponse.Object);
verificationEmailRepository
.Setup(x => x.CreateOrUpdateAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync((IVerificationCode)null);
var publisherCodeVerified = new Mock <IRabbitPublisher <AdminEmailVerifiedEvent> >();
EmailVerificationService emailVerificationService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
emailVerificationService = new EmailVerificationService(
verificationEmailRepository.Object,
publisherCodeVerified.Object,
logFactory
);
}
var result = await emailVerificationService.ConfirmCodeAsync("DDD666".ToBase64());
Assert.Equal(confirmEmailResponse.Error.ToString(), result.Error.ToString());
Assert.False(result.IsVerified);
}
public async Task Session_Should_Be_Refreshed_WithGet()
{
_client = new RedisSessionsClient(
_connectionMultiplexer,
"Sessions",
TimeSpan.FromSeconds(1),
TimeSpan.FromMinutes(5),
LogFactory.Create(),
_startedPublisher,
_endedPublisher);
var session = await _client.Authenticate(Guid.NewGuid().ToString(), "SomeInfo");
await Task.Delay(TimeSpan.FromSeconds(0.8));
await _client.GetAsync(session.SessionToken);
await Task.Delay(TimeSpan.FromSeconds(0.8));
var result = await _client.GetAsync(session.SessionToken);
Assert.NotNull(result);
}
public async Task UserTriesToLogIn_WithInvalidFormatEmail_InvalidPasswordFormatErrorReturned()
{
var sessionsServiceClient = new Mock <ISessionsServiceClient>();
var credentialsClient = new Mock <ICredentialsClient>();
var customerProfileClient = new Mock <ICustomerProfileClient>();
var modelError = new ErrorResponse
{
ModelErrors = new Dictionary <string, List <string> >
{
{ nameof(CredentialsValidationRequest.Password), new List <string>() }
}
};
var exception = new ClientApiException(HttpStatusCode.BadRequest, modelError);
credentialsClient
.Setup(x => x.Api.ValidateCredentialsAsync(It.IsAny <CredentialsValidationRequest>()))
.Throws(exception);
var customerService = new Mock <ICustomersService>();
AuthService authService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
authService = new AuthService(
sessionsServiceClient.Object,
credentialsClient.Object,
customerProfileClient.Object,
customerService.Object,
logFactory);
}
var result = await authService.AuthAsync("email", "password");
Assert.Equal(CustomerManagementError.InvalidPasswordFormat.ToString(), result.Error.ToString());
Assert.Null(result.CustomerId);
Assert.Null(result.Token);
}
public void Send(byte[] buffer, CancellationToken token)
{
//运行过程中串口异常
try
{
LogFactory.Create().Info($"send ->{Shunxi.Common.Utility.Common.BytesToString(buffer)}<- send end");
SerialPort.Write(buffer, 0, buffer.Length);
}
catch (Exception ex)
{
if (SerialPort != null)
{
SerialPort.DataReceived -= SerialPort_DataReceived;
SerialPort.ErrorReceived -= SerialPort_ErrorReceived;
}
Status = SerialPortStatus.Initialled;
SerialPort?.Close();
SerialPort?.Dispose();
LogFactory.Create().Error("usb serial port send msg error" + ex.Message);
}
}
public async Task Should_Not_Return_UserIds()
{
_client = new RedisSessionsClient(
_connectionMultiplexer,
"Sessions",
TimeSpan.FromSeconds(1),
TimeSpan.FromMinutes(5),
LogFactory.Create(),
_startedPublisher,
_endedPublisher);
var user1 = Guid.NewGuid().ToString();
var user2 = Guid.NewGuid().ToString();
await _client.Authenticate(user1, "SomeInfo");
await _client.Authenticate(user2, "SomeInfo");
await Task.Delay(TimeSpan.FromSeconds(2));
var result = await _client.GetActiveClientIdsAsync();
Assert.Empty(result);
}
public static void RunIt(RabbitMqSubscriptionSettings settingsAssetsInfo, RabbitMqSubscriptionSettings settingsThresholds)
{
var logFactory = LogFactory.Create();
logFactory.AddProvider(new ConsoleLoggerProvider((itm1, itm2) => true, true));
_connector = new RabbitMqSubscriber <string>(logFactory, settingsAssetsInfo, new DefaultErrorHandlingStrategy(logFactory, settingsAssetsInfo))
.SetMessageDeserializer(new DefaultStringDeserializer())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.CreateDefaultBinding()
.Subscribe(HandleMessage)
.Start();
_thresholds = new RabbitMqSubscriber <string>(logFactory, settingsThresholds, new DefaultErrorHandlingStrategy(logFactory, settingsThresholds))
.SetMessageDeserializer(new DefaultStringDeserializer())
.SetMessageReadStrategy(new MessageReadWithTemporaryQueueStrategy())
.CreateDefaultBinding()
.Subscribe(HandleThresholdsMessage)
.Start();
}
public async Task GetBatchOfCustomerBlockStatuses_InvalidInputParameter_ErrorReturned()
{
var customerProfileClient = new Mock <ICustomerProfileClient>();
var credentialsClient = new Mock <ICredentialsClient>();
var postProcessService = new Mock <IPostProcessService>();
var customerFlagsRepository = new Mock <ICustomerFlagsRepository>();
var sessionsServiceClient = new Mock <ISessionsServiceClient>();
CustomersService customersService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
customersService = new CustomersService(
credentialsClient.Object,
postProcessService.Object,
customerProfileClient.Object,
customerFlagsRepository.Object,
sessionsServiceClient.Object,
_passwordSuccessfulChangeEmailTemplateId,
_passwordSuccessfulChangeEmailSubjectTemplateId,
logFactory,
MaxBatchValue,
_publisher.Object,
_customerBlockEmailTemplateId,
_customerUnBlockEmailTemplateId,
_customerBlockSubjectTemplateId,
_customerUnBlockSubjectTemplateId,
_customerSupportPhoneNumber);
}
var result =
await customersService.GetBatchOfCustomersBlockStatusAsync(Enumerable.Repeat("a", 101).ToArray());
Assert.Equal(BatchCustomerStatusesErrorCode.InvalidCustomerIdsCount, result.Error);
}
private static async Task SendByHttp(string url, CnetScan cnetScans, Action <string> cb)
{
using (HttpClient client = new HttpClient())
{
try
{
var uri = new Uri($"http://{Config.SERVER_ADDR}:{Config.SERVER_PORT}/api/sim/location?mcc={cnetScans.MCC}&mnc={cnetScans.MNC}&lac={cnetScans.Lac}&ci={cnetScans.Cellid}&deviceid={Common.Utility.Common.GetUniqueId()}");
HttpResponseMessage response = await client.GetAsync(uri);
if (response.EnsureSuccessStatusCode().StatusCode.ToString().ToLower() == "ok")
{
string responseBody = await response.Content.ReadAsStringAsync();
cb?.Invoke(responseBody);
}
}
catch (HttpRequestException ex)
{
LogFactory.Create().Info(ex.Message);
}
}
}
public async Task UserTriesToLogIn_UnexpectedErrorInValidation_InvalidOperationIsThrown()
{
var sessionsServiceClient = new Mock <ISessionsServiceClient>();
var credentialsClient = new Mock <ICredentialsClient>();
var adminUsersService = new Mock <IAdminUserService>();
var response = new AdminCredentialsValidationResponse {
Error = CredentialsError.LoginAlreadyExists
};
var adminUsersServiceResponse = new AdminUserResult
{
Error = AdminUserErrorCodes.None,
Profile = new AdminUser
{
IsActive = true
}
};
credentialsClient
.Setup(x => x.Admins.ValidateAsync(It.IsAny <CredentialsValidationRequest>()))
.ReturnsAsync(response);
adminUsersService
.Setup(x => x.GetByEmailAsync(It.IsAny <string>(), null))
.ReturnsAsync(adminUsersServiceResponse);
AuthService authService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
authService = new AuthService(
sessionsServiceClient.Object,
credentialsClient.Object,
adminUsersService.Object,
logFactory);
}
await Assert.ThrowsAsync <InvalidOperationException>(() => authService.AuthAsync("email", "password"));
}
public void InstanceSystemStatusChangeEvent(object sender, RunStatusChangeEventArgs e)
{
LogFactory.Create().Info($"==================sys->{e.SysStatus}==================");
Dispatcher.Invoke(() =>
{
SwitchCommandStatus(e.SysStatus);
txtStatus.Text = e.SysStatus.ToString().ToLower();
if (e.SysStatus == SysStatusEnum.Starting)
{
UpdatePumpIn();
UpdatePumpOut();
}
else if (e.SysStatus == SysStatusEnum.Completed)
{
//new ModalDialog().Show("细胞培养流程已完成");
LogFactory.Create().Info("细胞培养流程已完成");
//await ReStart();
}
});
}
public async Task TryingToGetProfileContactByLocationId_InvalidLocationId_ErrorCodeIsReturned()
{
var partnerContactRepository = new Mock <IPartnerContactRepository>();
partnerContactRepository
.Setup(x => x.GetByLocationIdAsync(It.IsAny <string>()))
.ReturnsAsync((IPartnerContact)null);
PartnerContactService partnerContactService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
partnerContactService = new PartnerContactService(
partnerContactRepository.Object,
logFactory);
}
var actual = await partnerContactService.GetByLocationIdAsync("testContactId");
Assert.Equal(PartnerContactErrorCodes.PartnerContactDoesNotExist, actual.ErrorCode);
Assert.Null(actual.PartnerContact);
}
public async Task UserTriesToConfirmEmail_WithNewAdmin_Successfully()
{
var verificationEmailRepository = new Mock <IEmailVerificationCodeRepository>();
var verificationEmailGetResponse = GetMockedVerificationCode();
var confirmEmailResponse = new ConfirmVerificationCodeResultModel
{
Error = VerificationCodeError.None,
IsVerified = true
};
verificationEmailRepository
.Setup(x => x.GetByValueAsync(It.IsAny <string>()))
.ReturnsAsync(verificationEmailGetResponse.Object);
verificationEmailRepository
.Setup(x => x.CreateOrUpdateAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync((IVerificationCode)null);
var publisherCodeVerified = new Mock <IRabbitPublisher <AdminEmailVerifiedEvent> >();
EmailVerificationService emailVerificationService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
emailVerificationService = new EmailVerificationService(
verificationEmailRepository.Object,
publisherCodeVerified.Object,
logFactory
);
}
var result = await emailVerificationService.ConfirmCodeAsync("DDD666".ToBase64());
Assert.Equal(confirmEmailResponse.Error.ToString(), result.Error.ToString());
Assert.True(result.IsVerified);
}
public (IContainer resolver, ILog logToConsole) GetResolver(string horizonUrl, string passPhrase)
{
ContainerBuilder containerBuilder = new ContainerBuilder();
IServiceCollection collection = new Microsoft.Extensions.DependencyInjection.ServiceCollection();
var consoleLogger = LogFactory.Create();
consoleLogger.AddConsole(options => { options.IncludeScopes = true; });
var log = consoleLogger.CreateLog(this);
collection.AddSingleton <ILog>(log);
collection.AddHttpClient();
containerBuilder.RegisterType <HorizonService>()
.As <IHorizonService>()
.WithParameter("network", passPhrase)
.WithParameter("horizonUrl", horizonUrl)
.SingleInstance();
containerBuilder.Populate(collection);
var resolver = containerBuilder.Build();
return(resolver, log);
}
public async Task TryToGetTokensSnapshot_SnapshotDoesNotExists_ResultWithBusinessError()
{
var lastTokensTotalAmountRepo = Mock.Of <ILastKnownStatsRepository>();
var pbfClient = Mock.Of <IPrivateBlockchainFacadeClient>();
var snapshotRepo = new Mock <ITokensSnapshotRepository>();
snapshotRepo.Setup(x => x.GetTokensSnapshotByDate(It.IsAny <string>()))
.ReturnsAsync((DailyTokensSnapshot)null);
TokensStatisticsService tokensStatisticsService;
using (var logFactory = LogFactory.Create().AddUnbufferedConsole())
{
tokensStatisticsService = new TokensStatisticsService(logFactory,
pbfClient,
snapshotRepo.Object,
lastTokensTotalAmountRepo);
}
var result = await tokensStatisticsService.GetTokensSnapshotForDate(DateTime.UtcNow.AddDays(-1));
Assert.Equal(TokensErrorCodes.StatisticsNotFound, result.ErrorCode);
}
public override void ProcessPausingResult(DirectiveData data, CommunicationEventArgs comEventArgs)
{
var ret = data as PumpDirectiveData;
if (ret != null && ret.FlowRate <= 0)
{
comEventArgs.DeviceStatus = DeviceStatusEnum.Idle;
comEventArgs.Description = IdleDesc.Paused.ToString();;
this.SetStatus(DeviceStatusEnum.Idle);
StopEvent.TrySetResult(new DeviceIOResult(true));
StopTime = DateTime.Now;
PreUnfinishedVolume = CalcPreUnfinishedVolume();
LogFactory.Create().Info($"device{Device.DeviceId} PreUnfinishedVolume is {PreUnfinishedVolume}");
OnCommunicationChange(comEventArgs);
}
else
{
comEventArgs.DeviceStatus = DeviceStatusEnum.Pausing;
StartPauseLoop();
}
}
public async Task Open(SerialEnum serialType)
{
await Task.Yield();
if (Status == SerialPortStatus.Initialled)
{
try
{
Status = SerialPortStatus.Opening;
client.Connect(ADDR, PORT);
Status = SerialPortStatus.Opened;
_readCancellationTokenSource = new CancellationTokenSource();
Listen().IgnorCompletion();
}
catch (Exception e)
{
LogFactory.Create().Info("net serial open error" + e.Message);
Status = SerialPortStatus.Initialled;
}
}
}