public async Task OfflineConnectionMeasuringButtonsAvailbility()
{
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new OfflineConnection());
int isChanagedTriggered1 = 0;
var loadCommand = _measuringMonitorViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Loading").FragmentOptionCommandViewModels
.First(model => model.TitleKey == "Load")
.OptionCommand as RelayCommand;
var loadCycleCommand = _measuringMonitorViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Loading").FragmentOptionCommandViewModels
.First(model => model.TitleKey == "CycleLoading") as FragmentOptionToggleCommandViewModel;
Assert.False(loadCycleCommand.IsEnabled);
Assert.False(loadCommand.CanExecute(null));
loadCommand.CanExecuteChanged += (sender, args) => { isChanagedTriggered1++; };
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new MockConnection());
Assert.True(await TestsUtils.WaitUntil(
() =>
{
return(loadCycleCommand.IsEnabled && loadCommand.CanExecute(null) &&
isChanagedTriggered1 > 0);
}, 30000));
}
public async Task ChangeConnectionToOfflineConnectionStateCheck()
{
_configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.Clear();
await _configurationFragmentViewModel.SetFragmentOpened(false);
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new MockConnection());
Assert.True(await TestsUtils.WaitUntil(
() => _deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new OfflineConnection());
Assert.True(await TestsUtils.WaitUntil(
() => !_deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await _configurationFragmentViewModel.SetFragmentOpened(true);
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new MockConnection());
Assert.True(await TestsUtils.WaitUntil(
() => _deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new OfflineConnection());
Assert.True(await TestsUtils.WaitUntil(
() => !_deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
}
public async Task ConnectionLostOnWrite()
{
var prevConnection = new MockConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, prevConnection);
var applicationGlobalCommandsMock = ApplicationGlobalCommandsMock.Create().WithAskUserGlobalResult(true);
_typesContainer.RegisterInstance <IApplicationGlobalCommands>(applicationGlobalCommandsMock);
_configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.Clear();
var connection = new MockConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, connection);
Assert.True(await TestsUtils.WaitUntil(() => _readCommand.CanExecute(null), 30000));
Assert.True(await TestsUtils.WaitUntil(() => _readCommand.CanExecute(null), 30000));
_readCommand.Execute(null);
Assert.True(await TestsUtils.WaitUntil(() => _readCommand.CanExecute(null), 30000));
(_device.DataProvider.Item.TransactionCompleteSubscription as TransactionCompleteSubscription).ResetOnConnectionRetryCounter(true);
_device.DataProvider.Item.TransactionCompleteSubscription.Execute();
var defaultPropertyWithBoolFormatting = _configurationFragmentViewModel.RootConfigurationItemViewModels
.Cast <IConfigurationItemViewModel>().ToList()
.FindItemViewModelByName(model => model.Header == "boolTestDefaultProperty")
.Item as IRuntimePropertyViewModel;
(defaultPropertyWithBoolFormatting.LocalValue as EditableBoolValueViewModel).BoolValueProperty = true;
var writeCommand = _configurationFragmentViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Device").FragmentOptionCommandViewModels
.First(model => model.TitleKey == ConfigurationKeys.WRITE_LOCAL_VALUES_TO_DEVICE_STRING_KEY)
.OptionCommand as RelayCommand;
MockConnection.IsConnectionLost = true;
while (!applicationGlobalCommandsMock.IsAskUserGlobalTriggered)
{
writeCommand.Execute(null);
await TestsUtils.WaitUntil(() => writeCommand.CanExecute(null), 2000);
}
Assert.True(await TestsUtils.WaitUntil(
() => !_deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
Assert.True((prevConnection as MockConnection).IsDisposed);
Assert.True((connection as MockConnection).IsDisposed);
Assert.True(applicationGlobalCommandsMock.IsAskUserGlobalTriggered);
MockConnection.IsConnectionLost = false;
(defaultPropertyWithBoolFormatting.LocalValue as EditableBoolValueViewModel).BoolValueProperty = false;
Assert.True(await TestsUtils.WaitUntil(() => !_readCommand.CanExecute(null), 30000));
}
public async Task ConnectionLostUserSayGoOffline()
{
var prevConnection = new MockConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, prevConnection);
var applicationGlobalCommandsMock = ApplicationGlobalCommandsMock.Create().WithAskUserGlobalResult(true);
_typesContainer.RegisterInstance <IApplicationGlobalCommands>(applicationGlobalCommandsMock);
_configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.Clear();
var connection = new MockConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, connection);
Assert.True(await TestsUtils.WaitUntil(() => _readCommand.CanExecute(null), 30000));
MockConnection.IsConnectionLost = true;
Assert.True(await TestsUtils.WaitUntil(() => _readCommand.CanExecute(null), 30000));
_readCommand.Execute(null);
Assert.True(await TestsUtils.WaitUntil(
() => !_deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
Assert.True((prevConnection as MockConnection).IsDisposed);
MockConnection.IsConnectionLost = false;
Assert.True(await TestsUtils.WaitUntil(() => !_readCommand.CanExecute(null), 30000));
}
private async Task AutoLoadConfigurationTab(bool setting)
{
var setup = Program.RefreshProject();
var settings = StaticContainer.Container.Resolve <IApplicationSettingsService>();
var boolTestDefaultProperty = setup.configuration.RootConfigurationItemList
.FindItemByName(item => item.Name == "boolTestDefaultProperty")
.Item as IProperty;
settings.IsFragmentAutoLoadEnabled = setting;
var offlineConnection = new OfflineConnection();
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(setup.device, offlineConnection);
Assert.True(await TestsUtils.WaitUntil(
() => !setup.deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await setup.configurationViewModel.SetFragmentOpened(true);
await setup.configurationViewModel.SetFragmentOpened(false);
await setup.configurationViewModel.SetFragmentOpened(true);
var connection = new MockConnection();
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(setup.device, connection);
Assert.True(await TestsUtils.WaitUntil(
() => setup.deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await Task.Delay(5000);
Assert.True(await TestsUtils.WaitUntil(
() => setting ==
setup.device.DeviceMemory.DeviceMemoryValues.ContainsKey(boolTestDefaultProperty.Address)));
}
public async Task OpenProjectTryReconnectConnectionLost()
{
var app = Program.GetApp();
var shell = app.Container.Resolve <ShellViewModel>();
var typesContainer = app.Container.Resolve <ITypesContainer>();
var applicationGlobalCommandsMock = ApplicationGlobalCommandsMock.Create().WithAskUserGlobalResult(true);
typesContainer.RegisterInstance <IApplicationGlobalCommands>(applicationGlobalCommandsMock);
Program.RefreshProject();
MockConnection.IsConnectionLost = true;
var projectService = app.Container.Resolve <IUniconProjectService>();
await projectService.LoadProject("FileAssets/testProject.uniproj");
var deviceViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0];
Assert.True(await TestsUtils.WaitUntil(() => !deviceViewModel.ConnectionStateViewModel.IsDeviceConnected));
Assert.False(applicationGlobalCommandsMock.IsAskUserGlobalTriggered);
var deviceContainerService = app.Container.Resolve <IDevicesContainerService>();
var device = deviceContainerService.ConnectableItems[0] as DefaultDevice;
Assert.True(device.DeviceConnection is OfflineConnection);
MockConnection.IsConnectionLost = false;
projectService.CreateNewProject();
Program.RefreshProject();
}
public async Task Always_returns_NotFound_When_try_to_get_non_existing_PaymentDetails()
{
var client = new HttpClient {
BaseAddress = new Uri("https://localhost:5001")
};
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var clients = Enumerable.Repeat(client, 1);
var posts = clients.Select(c =>
{
var paymentRequest = TestsUtils.BuildPaymentRequest(Guid.NewGuid(), MerchantsRepository.Amazon);
var content = new StringContent(JsonConvert.SerializeObject(paymentRequest));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(c.GetAsync("api/PaymentsDetails/f31499cc-ece3-4974-8785-1620d8c506f6"));
});
foreach (var response in await Task.WhenAll(posts))
{
Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.NotFound);
}
}
private async Task CycleLoadingMeasuringTab(bool setting)
{
var setup = Program.RefreshProject();
var settings = StaticContainer.Container.Resolve <IApplicationSettingsService>();
settings.IsFragmentAutoLoadEnabled = setting;
await StaticContainer
.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(setup.device, new MockConnection());
Assert.True(await TestsUtils.WaitUntil(
() => setup.deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await setup.measuringMonitorViewModel.SetFragmentOpened(true);
Assert.True(await TestsUtils.WaitUntil(
() =>
setting == ((FragmentOptionToggleCommandViewModel)setup.measuringMonitorViewModel
.FragmentOptionsViewModel.GetCommand("Loading", "CycleLoading")).IsChecked, 30000));
await Task.Delay(5000);
await setup.measuringMonitorViewModel.SetFragmentOpened(false);
Assert.True(await TestsUtils.WaitUntil(
() =>
!((FragmentOptionToggleCommandViewModel)setup.measuringMonitorViewModel.FragmentOptionsViewModel
.GetCommand("Loading", "CycleLoading")).IsChecked, 30000));
}
public static async Task RequestPayments(int concurrentClientsCount)
{
const string baseUri = "https://localhost:5001";
var clients = BuildHttpClients(concurrentClientsCount, baseUri);
IEnumerable <Task <PaymentDto> > posts = clients.Select(async(c, index) =>
{
Console.WriteLine($"client {index}");
var paymentRequest = TestsUtils.BuildPaymentRequest(Guid.NewGuid(), MerchantsRepository.Amazon);
var content = new StringContent(JsonConvert.SerializeObject(paymentRequest));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await c.PostAsync("/api/Payments", content);
//Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.Accepted);
//Check.That(response.Headers.Location.ToString()).StartsWith($"{baseUri}/api/Payments/");
var payment = JsonConvert.DeserializeObject <PaymentDto>(await response.Content.ReadAsStringAsync());
//Check.That(payment.Status).IsEqualTo(Domain.PaymentStatus.Pending);
//Check.That(payment.AcquiringBankPaymentId).IsNull();
return(payment);
});
await Task.WhenAll(posts);
}
public async Task LoadAllFromDeviceJournal()
{
Program.CleanProject();
var serializerService = Program.GetApp().Container.Resolve <ISerializerService>();
var device = serializerService.DeserializeFromFile <IDevice>("FileAssets/МР301_JA.json") as DefaultDevice;
StaticContainer.Container.Resolve <IDevicesContainerService>()
.AddConnectableItem(device);
var shell = StaticContainer.Container.Resolve <ShellViewModel>();
var queryDefinitions = await QueryUtils.ReadQueryMockDefinitionFromFile("FileAssets/logFileForMR301JS.txt");
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new MockConnectionWithSetup(queryDefinitions));
var journalViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "UniconJournal(Журнал системы)") as
UniconJournalViewModel;
IDeviceViewModel deviceViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0];
var serializerServiceMock = new SerializerServiceMock();
var loadAllViewModel =
new LoadAllFromDeviceWindowViewModelFactory(StaticContainer.Container.Resolve <ILoadAllService>(),
serializerServiceMock)
.CreateLoadAllFromDeviceWindowViewModel(
device,
deviceViewModel);
Assert.True(loadAllViewModel.LoadFragmentViewModels.Count == 3);
loadAllViewModel.PathToFolderToSave = Directory.GetCurrentDirectory();
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerServiceMock.SerializedObjects.Count == 0);
loadAllViewModel.LoadFragmentViewModels.First(model => model.FragmentName == "UniconJournal(Журнал системы)").IsSelectedForLoading = true;
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerServiceMock.SerializedObjects.Count == 1);
Assert.True(((UniconJournal)serializerServiceMock.SerializedObjects[0]).JournalRecords.Count == 511);
}
public async Task OfflineConnectionMeasuringButtonsAvailbilityWhenCycleExecuting()
{
Program.GetApp().Container.Resolve <IDevicesContainerService>().Refresh();
var serializerService = Program.GetApp().Container.Resolve <ISerializerService>();
var device = serializerService.DeserializeFromFile <IDevice>("FileAssets/МР301_JA.json") as DefaultDevice;
StaticContainer.Container.Resolve <IDevicesContainerService>()
.AddConnectableItem(device);
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new MockConnection());
var measuringMonitorViewModel = StaticContainer.Container.Resolve <ShellViewModel>().ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "MeasuringMonitor") as
MeasuringMonitorViewModel;
var loadCommand = measuringMonitorViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Loading").FragmentOptionCommandViewModels
.First(model => model.TitleKey == "Load")
.OptionCommand as RelayCommand;
var loadCycleCommand = measuringMonitorViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Loading").FragmentOptionCommandViewModels
.First(model => model.TitleKey == "CycleLoading") as FragmentOptionToggleCommandViewModel;
Assert.True(await TestsUtils.WaitUntil(
() => loadCommand.CanExecute(null)));
Assert.True(loadCycleCommand.IsEnabled);
loadCycleCommand.IsChecked = true;
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new OfflineConnection());
Assert.True(await TestsUtils.WaitUntil(
() => !loadCycleCommand.IsChecked));
Assert.False(loadCycleCommand.IsEnabled);
Assert.False(loadCommand.CanExecute(null));
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new MockConnection());
Assert.True(loadCycleCommand.IsEnabled);
Assert.True(loadCommand.CanExecute(null));
Program.RefreshProject();
}
public async Task ConnectionFromOfflineToOnline()
{
var offlineConnection = new OfflineConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, offlineConnection);
Assert.True(await TestsUtils.WaitUntil(
() => !_deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
var connection = new MockConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, connection);
Assert.True(await TestsUtils.WaitUntil(
() => _deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
}
public async Task ChangeConnectionToOfflineIfFragmentClosedConfiguration()
{
_configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.Clear();
_configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues.Clear();
var boolTestDefaultProperty =
_configuration.RootConfigurationItemList.FindItemByName(item => item.Name == "boolTestDefaultProperty")
.Item as IProperty;
var defaultPropertyWithBoolFormatting = _configurationFragmentViewModel.RootConfigurationItemViewModels
.Cast <IConfigurationItemViewModel>().ToList()
.FindItemViewModelByName(model => model.Header == "boolTestDefaultProperty")
.Item as IRuntimePropertyViewModel;
await _configurationFragmentViewModel.SetFragmentOpened(true);
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new MockConnection());
var commandRead = _configurationFragmentViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Device").FragmentOptionCommandViewModels
.First(model => model.TitleKey == ApplicationGlobalNames.UiCommandStrings.READ_STRING_KEY)
.OptionCommand as RelayCommand;
Assert.False(commandRead.CanExecute(null));
Assert.True(await TestsUtils.WaitUntil(
() => commandRead.CanExecute(null), 30000));
await _configurationFragmentViewModel.SetFragmentOpened(false);
_configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues[
boolTestDefaultProperty.Address] = 1;
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new OfflineConnection());
Assert.False(commandRead.CanExecute(null));
Assert.False((defaultPropertyWithBoolFormatting.LocalValue as EditableBoolValueViewModel)
.BoolValueProperty);
await _configurationFragmentViewModel.SetFragmentOpened(true);
Assert.True((defaultPropertyWithBoolFormatting.LocalValue as EditableBoolValueViewModel).BoolValueProperty);
_configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues[
boolTestDefaultProperty.Address] = 0;
}
public async Task OfflineConnectionConfigurationButtonsAvailbility()
{
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new OfflineConnection());
int isChanagedTriggered = 0;
int isChanagedTriggered1 = 0;
int isChanagedTriggered2 = 0;
var optionCommands = new List <RelayCommand>()
{
_configurationFragmentViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Device").FragmentOptionCommandViewModels
.First(model => model.TitleKey == ApplicationGlobalNames.UiCommandStrings.READ_STRING_KEY)
.OptionCommand as RelayCommand,
_configurationFragmentViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Device").FragmentOptionCommandViewModels
.First(model => model.TitleKey == ConfigurationKeys.WRITE_LOCAL_VALUES_TO_DEVICE_STRING_KEY)
.OptionCommand as RelayCommand,
_configurationFragmentViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Device").FragmentOptionCommandViewModels
.First(model => model.TitleKey == ConfigurationKeys.TRANSFER_FROM_DEVICE_TO_LOCAL_STRING_KEY)
.OptionCommand as RelayCommand,
};
Assert.False(optionCommands.Any(command => command.CanExecute(null)));
optionCommands[0].CanExecuteChanged += (sender, args) => { isChanagedTriggered++; };
optionCommands[1].CanExecuteChanged += (sender, args) => { isChanagedTriggered1++; };
optionCommands[2].CanExecuteChanged += (sender, args) => { isChanagedTriggered2++; };
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new MockConnection());
await _configurationFragmentViewModel.SetFragmentOpened(true);
Assert.True(await TestsUtils.WaitUntil(
() => optionCommands.All(command => command.CanExecute(null)), 30000));
Assert.True(isChanagedTriggered > 0);
Assert.True(isChanagedTriggered1 > 0);
Assert.True(isChanagedTriggered2 > 0);
//open again and it must not start reading
await _configurationFragmentViewModel.SetFragmentOpened(true);
Assert.True(optionCommands.All(command => command.CanExecute(null)));
}
public async Task MeasuringMonitorLoad()
{
_device.DeviceMemory.DeviceMemoryValues.Clear();
var loadCommand = _measuringMonitorViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Loading").FragmentOptionCommandViewModels
.First(model => model.TitleKey == "Load")
.OptionCommand as RelayCommand;
loadCommand.Execute(null);
var analogSignal =
_measuringMonitorViewModel.MeasuringElementViewModels.First(model => model.Header == "analogSignal");
Assert.True(await TestsUtils.WaitUntil(() => analogSignal.FormattedValueViewModel != null));
Assert.True((analogSignal.FormattedValueViewModel as NumericValueViewModel).NumValue == "0");
}
public async Task OfflineConnectionValuesInit()
{
_configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.Clear();
_configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues.Clear();
var boolTestDefaultProperty =
_configuration.RootConfigurationItemList.FindItemByName(item => item.Name == "boolTestDefaultProperty")
.Item as IProperty;
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new OfflineConnection());
await _configurationFragmentViewModel.SetFragmentOpened(true);
Assert.True(await TestsUtils.WaitUntil(
() => _configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues[
boolTestDefaultProperty.Address] == 0, 30000));
Assert.False(
_configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.ContainsKey(
boolTestDefaultProperty.Address));
_configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues[
boolTestDefaultProperty.Address] = 1;
await _configurationFragmentViewModel.SetFragmentOpened(true);
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, new MockConnection());
Assert.True(
_configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues[
boolTestDefaultProperty.Address] == 1);
_configurationFragmentViewModel.DeviceContext.DeviceMemory.LocalMemoryValues[
boolTestDefaultProperty.Address] = 0;
Assert.True(await TestsUtils.WaitUntil(
() => _configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.ContainsKey(
boolTestDefaultProperty.Address), 30000));
}
private async Task AutoLoadJournalTab(bool setting)
{
Program.CleanProject();
var settings = StaticContainer.Container.Resolve <IApplicationSettingsService>();
settings.IsFragmentAutoLoadEnabled = setting;
var serializerService = Program.GetApp().Container.Resolve <ISerializerService>();
var device = serializerService.DeserializeFromFile <IDevice>("FileAssets/МР301_JA.json") as DefaultDevice;
StaticContainer.Container.Resolve <IDevicesContainerService>()
.AddConnectableItem(device);
var shell = StaticContainer.Container.Resolve <ShellViewModel>();
var queryDefinitions = await QueryUtils.ReadQueryMockDefinitionFromFile("FileAssets/logFileForMR301JS.txt");
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new MockConnectionWithSetup(queryDefinitions));
var journalViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "UniconJournal(Журнал системы)") as
UniconJournalViewModel;
var deviceViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0];
Assert.True(await TestsUtils.WaitUntil(
() => !deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await journalViewModel.SetFragmentOpened(true);
Assert.True(await TestsUtils.WaitUntil(
() => journalViewModel.FragmentOptionsViewModel.GetCommand("Device", "Load").OptionCommand
.CanExecute(null), 30000));
await Task.Delay(5000);
Assert.True(await TestsUtils.WaitUntil(
() => setting == journalViewModel.UniconJournal.JournalRecords.Any(), 30000));
}
public async Task OpenProjectTryReconnect()
{
var app = Program.GetApp();
Program.GetDevice();
var shell = app.Container.Resolve <ShellViewModel>();
var projectService = app.Container.Resolve <IUniconProjectService>();
await projectService.LoadProject("FileAssets/testProject.uniproj");
var deviceViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0];
var deviceContainerService = app.Container.Resolve <IDevicesContainerService>();
var device = deviceContainerService.ConnectableItems[0] as DefaultDevice;
Assert.True(await TestsUtils.WaitUntil(() => deviceViewModel.ConnectionStateViewModel.IsDeviceConnected));
Assert.True(device.DeviceConnection is MockConnection);
projectService.CreateNewProject();
Program.RefreshProject();
}
public async Task LoadMr301SystemJournalTest()
{
Program.CleanProject();
var serializerService = Program.GetApp().Container.Resolve <ISerializerService>();
var device = serializerService.DeserializeFromFile <IDevice>("FileAssets/МР301_JA.json") as DefaultDevice;
StaticContainer.Container.Resolve <IDevicesContainerService>()
.AddConnectableItem(device);
var shell = StaticContainer.Container.Resolve <ShellViewModel>();
var queryDefinitions = await QueryUtils.ReadQueryMockDefinitionFromFile("FileAssets/logFileForMR301JS.txt");
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new MockConnectionWithSetup(queryDefinitions));
var journalViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "UniconJournal(Журнал системы)") as
UniconJournalViewModel;
var commandViewModel = journalViewModel.FragmentOptionsViewModel.GetCommand("Device", "Load");
commandViewModel.OptionCommand.Execute(null);
await TestsUtils.WaitUntil(() => commandViewModel.OptionCommand.CanExecute(null));
var str = StaticContainer.Container.Resolve <ISerializerService>().SerializeInString(
journalViewModel.UniconJournal
);
var str1 = StaticContainer.Container.Resolve <ISerializerService>()
.DeserializeFromFile <UniconJournal>("FileAssets/Журнал(Журнал системы) МР301_JA.ujr");
Program.RefreshProject();
}
public async Task ConnectionLostUserSayGoOfflineWhenMeasuringInLoadingCycle()
{
var prevConnection = new MockConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, prevConnection);
var applicationGlobalCommandsMock = ApplicationGlobalCommandsMock.Create().WithAskUserGlobalResult(true);
_typesContainer.RegisterInstance <IApplicationGlobalCommands>(applicationGlobalCommandsMock);
_configurationFragmentViewModel.DeviceContext.DeviceMemory.DeviceMemoryValues.Clear();
var connection = new MockConnection();
await _typesContainer.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(_device, connection);
Assert.True(await TestsUtils.WaitUntil(() => _readCommand.CanExecute(null), 30000));
var loadCycleCommand = _measuringMonitorViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Loading").FragmentOptionCommandViewModels
.First(model => model.TitleKey == "CycleLoading") as FragmentOptionToggleCommandViewModel;
loadCycleCommand.IsChecked = true;
MockConnection.IsConnectionLost = true;
Assert.True(await TestsUtils.WaitUntil(() => _readCommand.CanExecute(null), 30000));
_readCommand.Execute(null);
Assert.True(await TestsUtils.WaitUntil(
() => !_deviceViewModel.ConnectionStateViewModel.IsDeviceConnected, 30000));
await Task.Delay(3000);
Assert.False(_measuringMonitorViewModel.HasErrors);
Assert.True(await TestsUtils.WaitUntil(
() => !loadCycleCommand.IsChecked));
MockConnection.IsConnectionLost = false;
}
public async Task LoadJournalStructureMustBeChecked()
{
Program.CleanProject();
var globalCommandsMock = ApplicationGlobalCommandsMock
.Create()
.WithSelectFileToOpenResult("FileAssets/Журнал(Журнал системы) МР301_JA.ujr")
.WithAskUserGlobalResult(false);
StaticContainer.Container.RegisterInstance <IApplicationGlobalCommands>(globalCommandsMock);
var serializerService = Program.GetApp().Container.Resolve <ISerializerService>();
var device = serializerService.DeserializeFromFile <IDevice>("FileAssets/МР301_JA.json") as DefaultDevice;
StaticContainer.Container.Resolve <IDevicesContainerService>()
.AddConnectableItem(device);
var shell = StaticContainer.Container.Resolve <ShellViewModel>();
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new OfflineConnection());
var journalViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "UniconJournal(Аварий)") as
UniconJournalViewModel;
var commandViewModel = journalViewModel.FragmentOptionsViewModel.GetCommand("Device", "Open");
commandViewModel.OptionCommand.Execute(null);
await TestsUtils.WaitUntil(() => commandViewModel.OptionCommand.CanExecute(null));
Assert.True(globalCommandsMock.IsAskUserGlobalTriggered);
Assert.False(journalViewModel.Table.Values.Any());
Program.RefreshProject();
}
public async Task LoadAllFromDevice()
{
var setup = Program.RefreshProject();
var boolTestDefaultProperty =
setup.configuration.RootConfigurationItemList
.FindItemByName(item => item.Name == "boolTestDefaultProperty")
.Item as IProperty;
var connection = new MockConnection();
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(setup.device, connection);
connection.MemorySlotDictionary.Add(boolTestDefaultProperty.Address, 1);
var serializerService = new SerializerServiceMock();
var loadAllViewModel =
new LoadAllFromDeviceWindowViewModelFactory(StaticContainer.Container.Resolve <ILoadAllService>(),
serializerService)
.CreateLoadAllFromDeviceWindowViewModel(
setup.device,
setup.deviceViewModel);
Assert.True(loadAllViewModel.LoadFragmentViewModels.Count == 1);
loadAllViewModel.PathToFolderToSave = Directory.GetCurrentDirectory();
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerService.SerializedObjects.Count == 0);
loadAllViewModel.LoadFragmentViewModels[0].IsSelectedForLoading = true;
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerService.SerializedObjects.Count == 1);
var memorySaved = serializerService.SerializedObjects[0] as Dictionary <ushort, ushort>;
Assert.True(memorySaved[boolTestDefaultProperty.Address] == 1);
Assert.True(serializerService.SerializedObjects[0] is Dictionary <ushort, ushort>);
connection.MemorySlotDictionary[boolTestDefaultProperty.Address] = 0;
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerService.SerializedObjects.Count == 2);
var memorySaved1 = serializerService.SerializedObjects[1] as Dictionary <ushort, ushort>;
Assert.True(memorySaved1[boolTestDefaultProperty.Address] == 0);
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(setup.device, new OfflineConnection());
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerService.SerializedObjects.Count == 2);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance <IAssetsReadModelRepository>(new MockedAssetsRepository(TestsUtils.GetAssetsRepository()));
builder.RegisterInstance <IAssetPairsReadModelRepository>(new MockedAssetPairsRepository(TestsUtils.GetAssetPairsRepository()));
}
