public async Task ModuleToModuleDirectMethod( [Values] Protocol protocol) { if (OsPlatform.IsWindows() && (protocol == Protocol.AmqpWs || protocol == Protocol.MqttWs)) { Assert.Ignore("Module-to-module direct methods don't work over WebSocket on Windows"); } string senderImage = Context.Current.MethodSenderImage.Expect(() => new ArgumentException()); string receiverImage = Context.Current.MethodReceiverImage.Expect(() => new ArgumentException()); string methodSender = $"methodSender-{protocol.ToString()}"; string methodReceiver = $"methodReceiver-{protocol.ToString()}"; CancellationToken token = this.cts.Token; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { string clientTransport = protocol.ToTransportType().ToString(); builder.AddModule(methodSender, senderImage) .WithEnvironment( new[] { ("ClientTransportType", clientTransport), ("TargetModuleId", methodReceiver) });
public async Task PriorityQueueModuleToModuleMessages() { // TODO: Fix PriorityQueue E2E tests for Windows and ARM32 if (OsPlatform.IsWindows() || !OsPlatform.Is64Bit()) { Assert.Ignore("Priority Queue module to module messages test has been disabled for Windows and Arm32 until we can fix it."); } CancellationToken token = this.TestToken; string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Priority Queues test")); string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); string relayerImage = Context.Current.RelayerImage.Expect(() => new ArgumentException("relayerImage parameter is required for Priority Queues test")); string trackingId = Guid.NewGuid().ToString(); TestInfo testInfo = this.InitTestInfo(5, 1000, true); Action <EdgeConfigBuilder> addInitialConfig = this.BuildAddInitialConfig(trackingId, trcImage, loadGenImage, testInfo); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig, token); PriorityQueueTestStatus loadGenTestStatus = await this.PollUntilFinishedAsync(LoadGenModuleName, token); Action <EdgeConfigBuilder> addRelayerConfig = this.BuildAddRelayerConfig(relayerImage, loadGenTestStatus); deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig + addRelayerConfig, token, false); await this.PollUntilFinishedAsync(RelayerModuleName, token); await this.ValidateResultsAsync(); }
public async Task PriorityQueueTimeToLive() { CancellationToken token = this.TestToken; string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Priority Queues test")); string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); string relayerImage = Context.Current.RelayerImage.Expect(() => new ArgumentException("relayerImage parameter is required for Priority Queues test")); string trackingId = Guid.NewGuid().ToString(); TestInfo testInfo = this.InitTestInfo(5, 20); Action <EdgeConfigBuilder> addLoadGenConfig = this.BuildAddLoadGenConfig(trackingId, loadGenImage, testInfo, false); Action <EdgeConfigBuilder> addTrcConfig = TestResultCoordinatorUtil.BuildAddTestResultCoordinatorConfig(trackingId, trcImage, LoadGenModuleName, RelayerModuleName, false); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(addLoadGenConfig + addTrcConfig, token, Context.Current.NestedEdge); PriorityQueueTestStatus loadGenTestStatus = await this.PollUntilFinishedAsync(LoadGenModuleName, token); await Profiler.Run( () => Task.Delay(testInfo.TtlThreshold * 1000), "Waited for message TTL to expire"); Action <EdgeConfigBuilder> addRelayerConfig = this.BuildAddRelayerConfig(relayerImage, loadGenTestStatus); deployment = await this.runtime.DeployConfigurationAsync(addLoadGenConfig + addTrcConfig + addRelayerConfig, token, Context.Current.NestedEdge); await this.PollUntilFinishedAsync(RelayerModuleName, token); Assert.True(await TestResultCoordinatorUtil.IsResultValidAsync()); }
public async Task PriorityQueueTimeToLive() { // TODO: Fix PriorityQueue TTL E2E tests for Windows and ARM32 if (OsPlatform.IsWindows() || !OsPlatform.Is64Bit()) { Assert.Ignore("Priority Queue time to live test has been disabled for Windows and Arm32 until we can fix it."); } CancellationToken token = this.TestToken; string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Priority Queues test")); string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); string relayerImage = Context.Current.RelayerImage.Expect(() => new ArgumentException("relayerImage parameter is required for Priority Queues test")); string trackingId = Guid.NewGuid().ToString(); TestInfo testInfo = this.InitTestInfo(5, 20); Action <EdgeConfigBuilder> addInitialConfig = this.BuildAddInitialConfig(trackingId, trcImage, loadGenImage, testInfo); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig, token); PriorityQueueTestStatus loadGenTestStatus = await this.PollUntilFinishedAsync(LoadGenModuleName, token); // Wait long enough for TTL to expire for some of the messages Log.Information($"Waiting for {testInfo.TtlThreshold} seconds for TTL's to expire"); await Task.Delay(testInfo.TtlThreshold * 1000); Action <EdgeConfigBuilder> addRelayerConfig = this.BuildAddRelayerConfig(relayerImage, loadGenTestStatus); deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig + addRelayerConfig, token, false); await this.PollUntilFinishedAsync(RelayerModuleName, token); await this.ValidateResultsAsync(); }
public async Task PriorityQueueTimeToLive() { CancellationToken token = this.TestToken; string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Priority Queues test")); string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); string relayerImage = Context.Current.RelayerImage.Expect(() => new ArgumentException("relayerImage parameter is required for Priority Queues test")); string trackingId = Guid.NewGuid().ToString(); TestInfo testInfo = this.InitTestInfo(5, 20); Action <EdgeConfigBuilder> addInitialConfig = this.BuildAddInitialConfig(trackingId, RelayerModuleName, trcImage, loadGenImage, testInfo, false); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig, token, Context.Current.NestedEdge); PriorityQueueTestStatus loadGenTestStatus = await this.PollUntilFinishedAsync(LoadGenModuleName, token); // Wait long enough for TTL to expire for some of the messages Log.Information($"Waiting for {testInfo.TtlThreshold} seconds for TTL's to expire"); await Task.Delay(testInfo.TtlThreshold * 1000); Action <EdgeConfigBuilder> addRelayerConfig = this.BuildAddRelayerConfig(relayerImage, loadGenTestStatus); deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig + addRelayerConfig, token, Context.Current.NestedEdge); await this.PollUntilFinishedAsync(RelayerModuleName, token); await this.ValidateResultsAsync(); }
public async Task CertRenew(Protocol protocol) { CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.GetModule(ModuleName.EdgeHub).WithEnvironment(("ServerCertificateRenewAfterInMs", "6000")); builder.GetModule(ModuleName.EdgeHub).WithEnvironment(new[] { ("UpstreamProtocol", protocol.ToString()) });
public async Task TempSensor() { var tempSensorModule = TempSensorModule.GetInstance(); CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(tempSensorModule.Name, tempSensorModule.Image) .WithEnvironment(new[] { ("MessageCount", "1") });
public async Task TempSensor() { string sensorImage = Context.Current.TempSensorImage.GetOrElse(DefaultSensorImage); CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(SensorName, sensorImage) .WithEnvironment(new[] { ("MessageCount", "1") });
public async Task TempSensor() { Assert.Ignore("Temporarily disabling flaky test while we figure out what is wrong"); string sensorImage = Context.Current.TempSensorImage.GetOrElse(DefaultSensorImage); CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(SensorName, sensorImage) .WithEnvironment(new[] { ("MessageCount", "1") });
public async Task TempFilter() { string sensorImage = Context.Current.TempSensorImage.GetOrElse(DefaultSensorImage); string filterImage = Context.Current.TempFilterImage.Expect(() => new ArgumentException()); CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule("tempSensor", sensorImage); builder.AddModule("tempFilter", filterImage) .WithEnvironment(new[] { ("TemperatureThreshold", "19") });
public async Task BridgeConfigUpdateTest() { CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.GetModule(ModuleName.EdgeHub) .WithEnvironment(new[] { ("experimentalFeatures__enabled", "true"), ("experimentalFeatures__mqttBrokerEnabled", "true"), })
public async Task PlugAndPlayDeviceClient(Protocol protocol, bool brokerOn) { CancellationToken token = this.TestToken; string leafDeviceId = DeviceId.Current.Generate(); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { if (brokerOn) { this.AddBrokerToDeployment(builder); } builder.GetModule(ModuleName.EdgeHub).WithEnvironment(new[] { ("UpstreamProtocol", protocol.ToString()) });
public async Task TempFilter() { string filterImage = Context.Current.TempFilterImage.Expect(() => new ArgumentException("tempFilterImage parameter is required for TempFilter test")); const string filterModuleName = "tempFilter"; var tempSensorModule = TempSensorModule.GetInstance(); CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(tempSensorModule.Name, tempSensorModule.Image); builder.AddModule(filterModuleName, filterImage) .WithEnvironment(new[] { ("TemperatureThreshold", "19") });
// [Category("FlakyOnArm")] // [Category("FlakyOnRelease")] public async Task TestIfSignedDeploymentIsSuccessful() { // Edge Daemon is configured with a good root CA and manifest is signed. this.SetLaunchSettingsWithRootCa(Context.Current.ManifestSigningDefaultLaunchSettings, Context.Current.ManifestSigningGoodRootCaPath); ManifestSettings inputManifestSettings = new ManifestSettings(Context.Current.ManifestSigningDeploymentPath, Context.Current.ManifestSigningSignedDeploymentPath, Context.Current.ManifestSigningGoodRootCaPath, Context.Current.ManifestSignerClientDirectory, Context.Current.ManifestSignerClientProjectPath); await this.SetConfigToEdgeDaemon(Context.Current.ManifestSigningGoodRootCaPath, this.TestToken); // This is a temporary solution see ticket: 9288683 if (!Context.Current.ISA95Tag) { EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(SensorName, this.sensorImage) .WithEnvironment(new[] { ("MessageCount", "-1") });
public async Task TempSensor() { string sensorImage = Context.Current.TempSensorImage.GetOrElse(DefaultSensorImage); CancellationToken token = this.TestToken; EdgeModule sensor; DateTime startTime; // This is a temporary solution see ticket: 9288683 if (!Context.Current.ISA95Tag) { EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(SensorName, sensorImage) .WithEnvironment(new[] { ("MessageCount", "-1") });
public async Task AuthorizationPolicyUpdateTest() { CancellationToken token = this.TestToken; string deviceId1 = DeviceId.Current.Generate(); string deviceId2 = DeviceId.Current.Generate(); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.GetModule(ModuleName.EdgeHub) .WithEnvironment(new[] { ("experimentalFeatures__enabled", "true"), ("experimentalFeatures__mqttBrokerEnabled", "true"), })
public async Task PlugAndPlayModuleClient(Protocol protocol) { CancellationToken token = this.TestToken; string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); Action <EdgeConfigBuilder> config = this.BuildAddEdgeHubConfig(protocol) + this.BuildAddLoadGenConfig(protocol, loadGenImage); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( config, token, Context.Current.NestedEdge); EdgeModule filter = deployment.Modules[LoadGenModuleName]; await filter.WaitForEventsReceivedAsync(deployment.StartTime, token); await this.ValidateIdentity(this.runtime.DeviceId, Option.Some(LoadGenModuleName), TestModelId, token); }
public async Task GenericMqttTelemetry() { CancellationToken token = this.TestToken; string networkControllerImage = Context.Current.NetworkControllerImage.Expect(() => new ArgumentException("networkControllerImage parameter is required for Generic Mqtt test")); string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Generic Mqtt test")); string genericMqttTesterImage = Context.Current.GenericMqttTesterImage.Expect(() => new ArgumentException("genericMqttTesterImage parameter is required for Generic Mqtt test")); string trackingId = Guid.NewGuid().ToString(); Action <EdgeConfigBuilder> addMqttBrokerConfig = MqttBrokerUtil.BuildAddBrokerToDeployment(false); Action <EdgeConfigBuilder> addNetworkControllerConfig = TestResultCoordinatorUtil.BuildAddNetworkControllerConfig(trackingId, networkControllerImage); Action <EdgeConfigBuilder> addTestResultCoordinatorConfig = TestResultCoordinatorUtil.BuildAddTestResultCoordinatorConfig(trackingId, trcImage, GenericMqttInitiatorModuleName, GenericMqttInitiatorModuleName); Action <EdgeConfigBuilder> addGenericMqttTesterConfig = this.BuildAddGenericMqttTesterConfig(trackingId, trcImage, genericMqttTesterImage); Action <EdgeConfigBuilder> config = addMqttBrokerConfig + addNetworkControllerConfig + addTestResultCoordinatorConfig + addGenericMqttTesterConfig; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(config, token, Context.Current.NestedEdge); await ValidateScenarioAsync(TimeSpan.FromSeconds(VerificationTolerance), GenericMqttTesterMaxMessages); }
public async Task PriorityQueueModuleToHubMessages() { // TODO: Add Windows and ARM32. Windows won't be able to work for this test until we add NetworkController Windows implementation if (OsPlatform.IsWindows() || !OsPlatform.Is64Bit()) { Assert.Ignore("Priority Queue module to module messages test has been disabled for Windows and Arm32 until we can fix it."); } CancellationToken token = this.TestToken; string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Priority Queues test")); string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); string relayerImage = Context.Current.RelayerImage.Expect(() => new ArgumentException("relayerImage parameter is required for Priority Queues test")); string networkControllerImage = Context.Current.NetworkControllerImage.Expect(() => new ArgumentException("networkControllerImage parameter is required for Priority Queues test")); string trackingId = Guid.NewGuid().ToString(); TestInfo testInfo = this.InitTestInfo(5, 1000, true); var testResultReportingClient = new TestResultReportingClient { BaseUrl = "http://localhost:5001" }; Action <EdgeConfigBuilder> addInitialConfig = this.BuildAddInitialConfig(trackingId, "hubtest", trcImage, loadGenImage, testInfo, true); Action <EdgeConfigBuilder> addNetworkControllerConfig = this.BuildAddNetworkControllerConfig(trackingId, networkControllerImage); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig + addNetworkControllerConfig, token); bool networkOn = true; await this.ToggleConnectivity(!networkOn, NetworkControllerModuleName, token); await Task.Delay(TimeSpan.Parse(LoadGenTestDuration) + TimeSpan.Parse(LoadGenTestStartDelay) + TimeSpan.FromSeconds(10)); await this.ToggleConnectivity(networkOn, NetworkControllerModuleName, token); PriorityQueueTestStatus loadGenTestStatus = await this.PollUntilFinishedAsync(LoadGenModuleName, token); ConcurrentQueue <MessageTestResult> messages = new ConcurrentQueue <MessageTestResult>(); await this.ReceiveEventsFromIotHub(deployment.StartTime, messages, loadGenTestStatus, token); while (messages.TryDequeue(out MessageTestResult messageTestResult)) { await testResultReportingClient.ReportResultAsync(messageTestResult.ToTestOperationResultDto()); } await this.ValidateResultsAsync(); }
// [Test] public async Task TestContentTrustDeployment() { // Create the input dictionary of the mapping of container registry name and its corresponding root CA var contentTrustInput = new Dictionary <string, string>(); contentTrustInput.Add(Context.Current.ContentTrustRegistryName.OrDefault(), Context.Current.ContentTrustRootCaPath.OrDefault()); // Edge Daemon is configured with a content trust root CA await this.SetConfigToEdgeDaemon(Option.Some(contentTrustInput), this.TestToken); // This is a temporary solution see ticket: 9288683 if (!Context.Current.ISA95Tag) { EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(SignedImageModuleName, this.signedImage) .WithEnvironment(new[] { ("MessageCount", "-1") });
public async Task TempSensor() { const string DefaultImage = "mcr.microsoft.com/azureiotedge-simulated-temperature-sensor:1.0"; string sensorImage = Context.Current.TempSensorImage.GetOrElse(DefaultImage); CancellationToken token = this.cts.Token; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule("tempSensor", sensorImage); }, token); EdgeModule sensor = deployment.Modules["tempSensor"]; await sensor.WaitForEventsReceivedAsync(deployment.StartTime, token); await sensor.UpdateDesiredPropertiesAsync( new { properties = new { desired = new { SendData = true, SendInterval = 10 } } }, token); await sensor.WaitForReportedPropertyUpdatesAsync( new { properties = new { reported = new { SendData = true, SendInterval = 10 } } }, token); }
public async Task PlugAndPlayDeviceClient(Protocol protocol, bool brokerOn) { CancellationToken token = this.TestToken; string leafDeviceId = DeviceId.Current.Generate(); // If broker is on, MQTT will be used by default in nested environment. And new MQTT won't work for P&P if (Context.Current.NestedEdge && brokerOn) { Assert.Ignore(); } EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { if (brokerOn) { this.AddBrokerToDeployment(builder); } builder.GetModule(ModuleName.EdgeHub).WithEnvironment(new[] { ("UpstreamProtocol", protocol.ToString()) });
public async Task PriorityQueueModuleToHubMessages() { CancellationToken token = this.TestToken; string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Priority Queues test")); string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); string relayerImage = Context.Current.RelayerImage.Expect(() => new ArgumentException("relayerImage parameter is required for Priority Queues test")); string networkControllerImage = Context.Current.NetworkControllerImage.Expect(() => new ArgumentException("networkControllerImage parameter is required for Priority Queues test")); string trackingId = Guid.NewGuid().ToString(); TestInfo testInfo = this.InitTestInfo(5, 1000, true, "00:00:40"); var testResultReportingClient = new TestResultReportingClient { BaseUrl = "http://localhost:5001" }; Action <EdgeConfigBuilder> addLoadGenConfig = this.BuildAddLoadGenConfig(trackingId, loadGenImage, testInfo, true); Action <EdgeConfigBuilder> addTrcConfig = TestResultCoordinatorUtil.BuildAddTestResultCoordinatorConfig(trackingId, trcImage, LoadGenModuleName, "hubtest"); Action <EdgeConfigBuilder> addNetworkControllerConfig = TestResultCoordinatorUtil.BuildAddNetworkControllerConfig(trackingId, networkControllerImage); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(addLoadGenConfig + addTrcConfig + addNetworkControllerConfig, token, Context.Current.NestedEdge); bool networkOn = true; await this.ToggleConnectivity(!networkOn, NetworkControllerModuleName, token); await Task.Delay(TimeSpan.Parse(LoadGenTestDuration) + TimeSpan.Parse(testInfo.LoadGenStartDelay) + TimeSpan.FromSeconds(10)); await this.ToggleConnectivity(networkOn, NetworkControllerModuleName, token); PriorityQueueTestStatus loadGenTestStatus = await this.PollUntilFinishedAsync(LoadGenModuleName, token); ConcurrentQueue <MessageTestResult> messages = new ConcurrentQueue <MessageTestResult>(); await this.ReceiveEventsFromIotHub(deployment.StartTime, messages, loadGenTestStatus, trackingId, token); while (messages.TryDequeue(out MessageTestResult messageTestResult)) { await testResultReportingClient.ReportResultAsync(messageTestResult.ToTestOperationResultDto()); } await TestResultCoordinatorUtil.ValidateResultsAsync(); }
public async Task TempSensor() { var tempSensorModule = TempSensorModule.GetInstance(); CancellationToken token = this.TestToken; EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( builder => { builder.AddModule(tempSensorModule.Name, tempSensorModule.Image); }, token); EdgeModule sensor = deployment.Modules[tempSensorModule.Name]; await sensor.WaitForEventsReceivedAsync(deployment.StartTime, token); await sensor.UpdateDesiredPropertiesAsync( new { properties = new { desired = new { SendData = true, SendInterval = 10 } } }, token); await sensor.WaitForReportedPropertyUpdatesAsync( new { properties = new { reported = new { SendData = true, SendInterval = 10 } } }, token); }
public async Task PriorityQueueModuleToModuleMessages() { CancellationToken token = this.TestToken; string trcImage = Context.Current.TestResultCoordinatorImage.Expect(() => new ArgumentException("testResultCoordinatorImage parameter is required for Priority Queues test")); string loadGenImage = Context.Current.LoadGenImage.Expect(() => new ArgumentException("loadGenImage parameter is required for Priority Queues test")); string relayerImage = Context.Current.RelayerImage.Expect(() => new ArgumentException("relayerImage parameter is required for Priority Queues test")); string trackingId = Guid.NewGuid().ToString(); TestInfo testInfo = this.InitTestInfo(5, 1000, true); Action <EdgeConfigBuilder> addInitialConfig = this.BuildAddInitialConfig(trackingId, RelayerModuleName, trcImage, loadGenImage, testInfo, false); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig, token, Context.Current.NestedEdge); PriorityQueueTestStatus loadGenTestStatus = await this.PollUntilFinishedAsync(LoadGenModuleName, token); Action <EdgeConfigBuilder> addRelayerConfig = this.BuildAddRelayerConfig(relayerImage, loadGenTestStatus); deployment = await this.runtime.DeployConfigurationAsync(addInitialConfig + addRelayerConfig, token, Context.Current.NestedEdge); await this.PollUntilFinishedAsync(RelayerModuleName, token); await this.ValidateResultsAsync(); }
public async Task PlugAndPlayDeviceClient(Protocol protocol) { CancellationToken token = this.TestToken; string leafDeviceId = DeviceId.Current.Generate(); Action <EdgeConfigBuilder> config = this.BuildAddEdgeHubConfig(protocol); EdgeDeployment deployment = await this.runtime.DeployConfigurationAsync( config, token, Context.Current.NestedEdge); var leaf = await LeafDevice.CreateAsync( leafDeviceId, protocol, AuthenticationType.Sas, Option.Some(this.runtime.DeviceId), false, this.ca, this.IotHub, Context.Current.Hostname.GetOrElse(Dns.GetHostName().ToLower()), token, Option.Some(TestModelId), Context.Current.NestedEdge); await TryFinally.DoAsync( async() => { DateTime seekTime = DateTime.Now; await leaf.SendEventAsync(token); await leaf.WaitForEventsReceivedAsync(seekTime, token); await this.ValidateIdentity(leafDeviceId, Option.None <string>(), TestModelId, token); }, async() => { await leaf.DeleteIdentityAsync(token); }); }