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);
});
}
