public WithTemplatedUrlPathProviderTests()
{
parameters = new List <ParameterDescriptor>();
mockSelector = new Mock <IQueryNameSelector>();
mockSelector
.Setup(x => x.Select(It.IsAny <PropertyInfo[]>()))
.Returns(new List <string>(new[] { "Filter", "VersionNumber" }));
mockProvider = new Mock <IActionDescriptorCollectionProvider>();
SetupProvider();
mockUrlHelper = new Mock <IUrlHelper>();
mockUrlHelperBuilder = new Mock <IUrlHelperBuilder>();
mockUrlHelperBuilder
.Setup(x => x.Build())
.Returns(mockUrlHelper.Object);
templatedRequest = LinkRequestBuilder.CreateWithRouteName(TestRouteName).SetIsTemplated();
nonTemplatedRequest = LinkRequestBuilder.CreateWithRouteName(TestRouteName);
sut = new WithTemplatedUrlPathProvider(
mockSelector.Object,
mockProvider.Object,
mockUrlHelperBuilder.Object);
}
public LinkResult GetClickedLinks(int campaignId)
{
var url = $"{this._baseUrl}/campaigns/listClicks/";
var request = new LinkRequest
{
ApiKey = this._apiKey,
CampaignId = campaignId
};
var xmlRequest = this._parser.Serialize(request);
var httpResponse = this._httpClient.Request(url, xmlRequest);
if (httpResponse.Status != HttpStatus.Successful)
{
return(new LinkResult
{
Status = Status.Error,
Message = "Http error"
});
}
var linkResult = this._parser.Deserialize <LinkResult>(httpResponse.Result);
return(linkResult);
}
public void SetWorkflow(LinkDeviceActionType action)
{
LinkRequest linkRequest = new LinkRequest()
{
MessageID = RandomGenerator.BuildRandomString(12),
Actions = new List <LinkActionRequest>()
{
new LinkActionRequest()
{
Action = LinkAction.DALAction,
DeviceActionRequest = new LinkDeviceActionRequest()
{
DeviceAction = action
},
DeviceRequest = new LinkDeviceRequest()
{
DeviceIdentifier = new XO.Device.LinkDeviceIdentifier()
{
Manufacturer = TargetDevices[0].DeviceInformation?.Manufacturer,
Model = TargetDevices[0].DeviceInformation?.Model,
SerialNumber = TargetDevices[0].DeviceInformation?.SerialNumber
}
}
}
}
};
SendDeviceCommand(JsonConvert.SerializeObject(linkRequest));
}
public Uri Provide(LinkRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var routeName = request.GetRouteName();
if (string.IsNullOrWhiteSpace(routeName))
{
throw new ArgumentException($"Parameter '{nameof(request)}' must contain a '{LinkRequestBuilder.RouteNameKey}' value.");
}
if (request.IsTemplated())
{
var template = GetTemplate(routeName);
if (string.IsNullOrWhiteSpace(template))
{
throw new InvalidOperationException($"The given '{LinkRequestBuilder.RouteNameKey}' to retrieve the URL template returned a null or empty value. Value of '{LinkRequestBuilder.RouteNameKey}': {routeName}");
}
return(new Uri($"/{template}", UriKind.Relative));
}
return(nonTemplatedUrlPathProvider.Provide(request));
}
public async override Task DoWork()
{
if (Controller.DidTimeoutOccur || Controller.DeviceEvent != DeviceEvent.None)
{
// recover device to idle
IDeviceCancellationBroker cancellationBroker = Controller.GetDeviceCancellationBroker();
LinkRequest linkRequest = StateObject as LinkRequest;
LinkDeviceIdentifier deviceIdentifier = linkRequest.GetDeviceIdentifier();
ICardDevice cardDevice = FindTargetDevice(deviceIdentifier);
if (cardDevice != null)
{
var timeoutPolicy = await cancellationBroker.ExecuteWithTimeoutAsync <bool>(
_ => cardDevice.DeviceRecovery(),
DeviceConstants.DeviceRecoveryTimeout,
this.CancellationToken);
if (timeoutPolicy.Outcome == Polly.OutcomeType.Failure)
{
//_ = Controller.LoggingClient.LogErrorAsync("Unable to recover device.");
Console.WriteLine("Unable to recover device.");
}
}
}
if (StateObject != null)
{
Controller.SaveState(StateObject);
}
_ = Complete(this);
}
public LinkRequestTests()
{
sut = new LinkRequest(new Dictionary <string, object>
{
{ TestKey, TestValue }
});
}
public void Can_Generate_Api_Xml_With_CopyControl()
{
//Arrange
string expected =
new XElement("LinkRequest",
new XAttribute("name", "foo"),
new XAttribute("targetLocation", "bar"),
new XElement("CopyControls",
new XAttribute("copyLocalAttributes", "true"))).ToString();
var request = new LinkRequest("foo", "bar")
{
CopyControl = new CopyControl(new List <ICopyControlFilter> {
Filter.CopyLocalAttributesFromSource()
})
};
//Act
var actual = request.ToAdsml();
var batchRequest = new BatchRequest(request);
Console.WriteLine(actual.ToString());
//Assert
Assert.That(actual.ToString(), Is.EqualTo(expected));
Assert.DoesNotThrow(() => batchRequest.ToAdsml().ValidateAdsmlDocument("adsml.xsd"));
}
public override async Task DoWork()
{
if (StateObject is null)
{
//_ = Controller.LoggingClient.LogErrorAsync("Unable to find a state object while attempting to get device status.");
Console.WriteLine("Unable to find a state object while attempting to get security configuration.");
_ = Error(this);
}
else
{
LinkRequest linkRequest = StateObject as LinkRequest;
IDeviceCancellationBroker cancellationBroker = Controller.GetDeviceCancellationBroker();
List <LinkRequest> devicesRequest = new List <LinkRequest>();
foreach (var device in Controller.TargetDevices)
{
devicesRequest.Add(JsonConvert.DeserializeObject <LinkRequest>(JsonConvert.SerializeObject(linkRequest)));
var timeoutPolicy = await cancellationBroker.ExecuteWithTimeoutAsync <LinkRequest>(
_ => device.GetSecurityConfiguration(devicesRequest.Last()),
DeviceConstants.CardCaptureTimeout,
System.Threading.CancellationToken.None);
if (timeoutPolicy.Outcome == Polly.OutcomeType.Failure)
{
//_ = Controller.LoggingClient.LogErrorAsync($"Unable to obtain device status - '{Controller.DeviceEvent}'.");
Console.WriteLine($"Unable to obtain security configuration - '{Controller.DeviceEvent}'.");
BuildSubworkflowErrorResponse(linkRequest, device.DeviceInformation, Controller.DeviceEvent);
}
}
/*if (linkRequest.LinkObjects.LinkActionResponseList[0].DALResponse == null)
* {
* linkRequest.LinkObjects.LinkActionResponseList[0].DALResponse = new LinkDeviceResponse();
* }
*
* if (linkRequest.LinkObjects.LinkActionResponseList[0].DALResponse.Devices == null)
* {
* linkRequest.LinkObjects.LinkActionResponseList[0].DALResponse.Devices = new List<LinkDeviceResponse>();
* }
*
* foreach (var response in devicesRequest)
* {
* if (response.LinkObjects.LinkActionResponseList[0].DALResponse?.Devices != null)
* {
* linkRequest.LinkObjects.LinkActionResponseList[0].DALResponse.Devices.Add(new LinkDeviceResponse
* {
* Manufacturer = response.LinkObjects.LinkActionResponseList[0].DALResponse?.Devices[0].Manufacturer,
* Model = response.LinkObjects.LinkActionResponseList[0].DALResponse?.Devices[0].Model,
* SerialNumber = response.LinkObjects.LinkActionResponseList[0].DALResponse?.Devices[0].SerialNumber
* });
* }
* }*/
Controller.SaveState(linkRequest);
_ = Complete(this);
}
}
public void Can_Generate_Api_Xml_With_RequestFilter()
{
//Arrange
string expected =
new XElement("LinkRequest",
new XAttribute("name", "foo"),
new XAttribute("targetLocation", "bar"),
new XAttribute("returnNoAttributes", "true")).ToString();
var request = new LinkRequest("foo", "bar")
{
RequestFilters = new List <ILinkRequestFilter> {
Filter.ReturnNoAttributes()
}
};
//Act
var actual = request.ToAdsml();
var batchRequest = new BatchRequest(request);
Console.WriteLine(actual.ToString());
//Assert
Assert.That(actual.ToString(), Is.EqualTo(expected));
Assert.DoesNotThrow(() => batchRequest.ToAdsml().ValidateAdsmlDocument("adsml.xsd"));
}
public LinkRequest GetSecurityConfiguration(LinkRequest linkRequest)
{
LinkActionRequest linkActionRequest = linkRequest?.Actions?.First();
Console.WriteLine($"simulator: GET SECURITY CONFIGURATION for SN='{linkActionRequest?.DeviceRequest?.DeviceIdentifier?.SerialNumber}'");
return(linkRequest);
}
public void GetStatus_ReturnsExpectedValue_WhenCalled()
{
LinkRequest expectedValue = new LinkRequest();
LinkRequest actualValue = subject.GetStatus(expectedValue);
Assert.Equal(expectedValue, actualValue);
}
public LinkRequest AbortCommand(LinkRequest linkRequest)
{
LinkActionRequest linkActionRequest = linkRequest?.Actions?.First();
Console.WriteLine($"simulator: ABORT COMMAND for SN='{linkActionRequest?.DeviceRequest?.DeviceIdentifier?.SerialNumber}'");
return(linkRequest);
}
public override Task DoWork()
{
if (StateObject != null)
{
LinkRequest response = StateObject as LinkRequest;
string serializedResponse = JsonConvert.SerializeObject(response);
//_ = Controller.LoggingClient.LogInfoAsync($"Request completed. Sending to Listener.");
Console.WriteLine($"Request completed. Sending to Listener.");
//_ = Controller.Connector.Publish(serializedResponse, new TopicOption[] { TopicOption.Servicer }).ConfigureAwait(false);
}
else
{
// TODO: What should you do here in the event that you have no response?
// TODO: Furthermore, this is a cutoff state action which means that you have
// nowhere else to go when this completes.. This is the one point where you
// get to decide whether or not we throw a Completion (Manage Path) or an
// Error (Device Recovery Path). I'll leave it to you to decide what you'll expect
// to receive in the state object to make that determination.
//
// Perhaps, the state object can be different in order to illuminate the type
// of flow you'll take going forward.
}
Complete(this);
return(Task.CompletedTask);
}
public override Reply Handle(string tag, LinkRequest request)
{
return(new Reply()
{
Content = "LINK RESULT"
});
}
public static void SetSessionID(LinkRequest myRequest, string SessionID)
{
foreach (var action in myRequest.Actions)
{
action.SessionID = SessionID;
}
}
public LinkRequest ResetDevice(LinkRequest linkRequest)
{
LinkActionRequest linkActionRequest = linkRequest?.Actions?.First();
Console.WriteLine($"simulator: RESET DEVICE for SN='{linkActionRequest?.DeviceRequest?.DeviceIdentifier?.SerialNumber}'");
return(linkRequest);
}
// ------------------------------------------------------------------------
// Methods that are mapped for usage in their respective sub-workflows.
// ------------------------------------------------------------------------
#region --- subworkflow mapping
public LinkRequest GetStatus(LinkRequest linkRequest)
{
LinkActionRequest linkActionRequest = linkRequest?.Actions?.First();
Console.WriteLine($"simulator: GET STATUS for SN='{linkActionRequest?.DeviceRequest?.DeviceIdentifier?.SerialNumber}'");
return(linkRequest);
}
public Uri Provide(LinkRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var routeName = request.GetRouteName();
if (string.IsNullOrWhiteSpace(routeName))
{
throw new ArgumentException($"Parameter '{nameof(request)}' must contain a '{LinkRequestBuilder.RouteNameKey}' value.");
}
var routeValues = request.GetRouteValues();
var url = routeValues == null?
urlHelper.Value.RouteUrl(routeName) :
urlHelper.Value.RouteUrl(routeName, routeValues);
url = FormatUrlPath(url);
if (string.IsNullOrWhiteSpace(url) || !Uri.IsWellFormedUriString(url, UriKind.RelativeOrAbsolute))
{
throw new InvalidOperationException($"The given '{LinkRequestBuilder.RouteNameKey}' to retrieve the URL did not provide a valid value. Value of '{LinkRequestBuilder.RouteNameKey}': {routeName}");
}
return(new Uri(url, UriKind.RelativeOrAbsolute));
}
public DeviceSanityCheckSubStateActionTests()
{
linkRequest = new LinkRequest()
{
//LinkObjects = new LinkRequestIPA5Object
//{
// LinkActionResponseList = new List<XO.Responses.LinkActionResponse>()
//},
Actions = new List <LinkActionRequest>()
{
new LinkActionRequest()
{
MessageID = RandomGenerator.BuildRandomString(8),
Timeout = 10000,
DeviceRequest = new LinkDeviceRequest()
{
DeviceIdentifier = new LinkDeviceIdentifier()
{
Manufacturer = "DeviceMockerInc",
Model = "DeviceMokerModel",
SerialNumber = "CEEEDEADBEEF"
}
}
}
}
};
//linkRequest.LinkObjects = SampleBuilder.LinkObjectsForEvents();
//linkRequest.LinkObjects.LinkActionResponseList[0].MessageID = "Authentication";
//linkRequest.LinkObjects.LinkActionResponseList[0].DeviceResponse.Devices = new List<LinkDeviceResponse>()
//{
// new LinkDeviceResponse()
// {
// Manufacturer = "NoDevice",
// CardWorkflowControls = new LinkCardWorkflowControls()
// {
// CardCaptureTimeout = 10,
// ManualCardTimeout = 5
// }
// }
//};
//mockLoggingClient = new Mock<ILoggingServiceClient>();
mockDeviceCancellationBroker = new Mock <IDeviceCancellationBroker>();
mockSubController = new Mock <IDeviceSubStateController>();
//mockSubController.SetupGet(e => e.LoggingClient).Returns(mockLoggingClient.Object);
mockSubController.Setup(e => e.GetDeviceCancellationBroker()).Returns(mockDeviceCancellationBroker.Object);
subject = new DeviceSanityCheckSubStateAction(mockSubController.Object);
asyncManager = new DeviceSubStateMachineAsyncManager(ref mockSubController, subject);
using (kernel = new StandardKernel())
{
kernel.Bind <DeviceGetStatusSubStateAction>().ToSelf();
kernel.Inject(subject);
}
}
public void IsTemplatedShouldReturnCorrectValue(bool isTemplated)
{
LinkRequest request = LinkRequestBuilder.CreateWithRouteName(TestRouteName).Set(IsTemplatedEnricher.TemplatedKey, isTemplated);
var result = request.IsTemplated();
result.Should().Be(isTemplated);
}
public void Validate_Throws_ApiSerializationValidationException_If_Target_Is_Empty()
{
//Arrange
var req = new LinkRequest("foo", string.Empty);
//Act
req.ToAdsml();
}
public void IsTemplatedShouldReturnFalseWhenRequestContainsAnInvalidTemplatedValue()
{
LinkRequest request = LinkRequestBuilder.CreateWithRouteName(TestRouteName).Set(IsTemplatedEnricher.TemplatedKey, "yes");
var result = request.IsTemplated();
result.Should().BeFalse();
}
public void IsTemplatedShouldReturnFalseWhenRequestDoesNotContainAValueForTemplated()
{
LinkRequest request = LinkRequestBuilder.CreateWithRouteName(TestRouteName);
var result = request.IsTemplated();
result.Should().BeFalse();
}
public async Task <LinkShortDTO> Post([FromBody] LinkRequest request)
{
if (!ModelState.IsValid || !IsValidUri(request.Url))
{
throw new InvalidArgumentException("Incorrect URL");
}
return(await _linkService.CreateLink(request.Url, ClientId));
}
public void GetRouteNameShouldReturnRouteNameWhenRouteNameExists()
{
LinkRequest request = LinkRequestBuilder.CreateWithRouteName(TestRouteName);
var result = request.GetRouteName();
result.Should().Be(TestRouteName);
}
public void GetRouteValuesShouldReturnNullWhenRouteValuesDoesNotExist()
{
LinkRequest request = LinkRequestBuilder.CreateWithRouteName(TestRouteName);
var result = request.GetRouteValues();
result.Should().BeNull();
}
public override Task <LinkReply> AddLink(LinkRequest request, ServerCallContext context)
{
_logger.LogInformation($"got a SayHello from {request.ClientAddr}");
return(Task.FromResult(new LinkReply
{
Message = "Hello " + request.ClientAddr
}));
}
public IsTemplatedEnricherTests()
{
request = LinkRequestBuilder.CreateWithRouteName(TestRouteName);
context = new LinkFactoryContext();
writer = new LinkDataWriter(context);
sut = new IsTemplatedEnricher();
}
public DeviceInitializeDeviceCommunicationStateActionTest()
{
linkRequest = new LinkRequest()
{
//LinkObjects = new LinkRequestIPA5Object
//{
// LinkActionResponseList = new List<XO.Responses.LinkActionResponse>()
//},
Actions = new List <LinkActionRequest>()
{
new LinkActionRequest()
{
MessageID = RandomGenerator.BuildRandomString(8),
Timeout = 10000,
DeviceRequest = new LinkDeviceRequest()
{
DeviceIdentifier = new LinkDeviceIdentifier()
{
Manufacturer = "DeviceMockerInc",
Model = "DeviceMokerModel",
SerialNumber = "CEEEDEADBEEF"
}
}
}
}
};
deviceSection = new DeviceSection();
//mockLoggingClient = new Mock<ILoggingServiceClient>();
mockDevicePluginLoader = new Mock <IDevicePluginLoader>();
mockCancellationBroker = new Mock <IDeviceCancellationBroker>();
mockController = new Mock <IDeviceStateController>();
//mockController.SetupGet(e => e.LoggingClient).Returns(mockLoggingClient.Object);
mockController.SetupGet(e => e.DevicePluginLoader).Returns(mockDevicePluginLoader.Object);
mockController.SetupGet(e => e.Configuration).Returns(deviceSection);
mockController.SetupGet(e => e.PluginPath).Returns(pluginPath);
mockController.Setup(e => e.GetCancellationBroker()).Returns(mockCancellationBroker.Object);
deviceInformation = new DeviceInformation()
{
Manufacturer = linkRequest.Actions[0].DeviceRequest.DeviceIdentifier.Manufacturer,
Model = linkRequest.Actions[0].DeviceRequest.DeviceIdentifier.Model,
SerialNumber = linkRequest.Actions[0].DeviceRequest.DeviceIdentifier.SerialNumber,
};
fakeDeviceOne.Setup(e => e.DeviceInformation).Returns(deviceInformation);
deviceInformation.SerialNumber = "CEEEBEEFDEAD";
fakeDeviceTwo.Setup(e => e.DeviceInformation).Returns(deviceInformation);
moqCardDevices.AddRange(new ICardDevice[] { fakeDeviceOne.Object, fakeDeviceTwo.Object });
mockController.SetupGet(e => e.TargetDevices).Returns(moqCardDevices);
subject = new DeviceInitializeDeviceCommunicationStateAction(mockController.Object);
asyncManager = new DeviceStateMachineAsyncManager(ref mockController, subject);
}
public void GetRouteValuesShouldReturnRouteValuesWhenRouteValuesExists()
{
var routeValues = new object();
LinkRequest request = LinkRequestBuilder.CreateWithRouteName(TestRouteName).SetRouteValuesIfNotNull(routeValues);
var result = request.GetRouteValues();
result.Should().Be(routeValues);
}
private void RequestLink(LinkRequest request)
{
lock (locker) requests.Add(request);
Program.main.Spring.UnitSyncWrapper.Downloader.RequestLinksForHash(request.Hash);
}
public LinkRequestHandler(IContainerManager containerManager, IJobManager jobManager, Request request)
: base(containerManager, jobManager, request)
{
this.request = (LinkRequest)request;
}
