// Only exists for easier testing
public void Populate(object target, IRequestData data)
{
Populate(new BindResult
{
Value = target
}, target.GetType(), data);
}
public MovieViewModelJsonBehavior(IOutputWriter writer, IFubuRequest request, IRequestData requestData)
: base(PartialBehavior.Executes)
{
this.writer = writer;
this.request = request;
this.requestData = requestData;
}
public SamlEndpoint(IRequestData requestData, SamlResponseRedirector redirector, IUrlRegistry urls, ISamlResponseWriter writer)
{
_requestData = requestData;
_redirector = redirector;
_urls = urls;
_writer = writer;
}
public AjaxAuthenticationRedirect(IRequestData data, IJsonWriter jsonWriter, IOutputWriter outputWriter, IUrlRegistry urls)
{
_data = data;
_jsonWriter = jsonWriter;
_outputWriter = outputWriter;
_urls = urls;
}
public FubuSmartRequest(IRequestData data, IObjectConverter converter, IFubuRequest request)
: base(data, converter)
{
_data = data;
_converter = converter;
_request = request;
}
public BootstrapAuthorizationFailureHandler(IOutputWriter writer, IRequestData requestData, IUrlRegistry urlRegistry, IHttpRequest currentHttpRequest)
{
_writer = writer;
_requestData = requestData;
_urlRegistry = urlRegistry;
_currentHttpRequest = currentHttpRequest;
}
public virtual BindResult BindModel(Type type, IRequestData data)
{
// TODO: Throw descriptive error if no binder can be foundow
// TODO: Throw descriptive error on a type that cannot be resolved or has errors
IModelBinder binder = _binders.First(x => x.Matches(type));
return binder.Bind(type, data);
}
public RequestLogBuilder(IUrlRegistry urls, ISystemTime systemTime, ICurrentHttpRequest request, ICurrentChain currentChain, IRequestData requestData)
{
_urls = urls;
_systemTime = systemTime;
_request = request;
_currentChain = currentChain;
_requestData = requestData;
}
public SamlAuthenticationStrategy(IRequestData requestData, ISamlDirector director, ISamlResponseReader reader, IEnumerable<ISamlValidationRule> rules, ILogger logger, IEnumerable<ISamlResponseHandler> strategies)
{
_requestData = requestData;
_director = director;
_reader = reader;
_rules = rules;
_logger = logger;
_strategies = strategies;
}
public DebugDetector(IRequestData request)
{
_test = new Lazy<bool>(() =>
{
bool returnValue = false;
request.Value(FLAG, o => returnValue = true);
return returnValue;
});
}
public AntiForgeryValidator(IAntiForgeryTokenProvider tokenProvider, IAntiForgerySerializer serializer,
ICookies cookies, IFubuApplicationFiles fubuApplicationFiles,
IRequestData requestData)
{
_tokenProvider = tokenProvider;
_serializer = serializer;
_cookies = cookies;
_fubuApplicationFiles = fubuApplicationFiles;
_requestData = requestData;
}
public static IEnumerable<IRequestData> For(IRequestData data, string prefix)
{
var indexer = new Indexer(prefix);
while (data.HasChildRequest(indexer.Prefix))
{
yield return data.GetChildRequest(indexer.Prefix);
indexer.Increment();
}
}
public BindResult Bind(Type type, object instance, IRequestData data)
{
var result = new BindResult
{
Value = instance
};
Populate(result, type, data);
return result;
}
public AntiForgeryService(IOutputWriter outputWriter,
IAntiForgeryTokenProvider tokenProvider,
IAntiForgerySerializer serializer,
ISecurityContext securityContext,
IRequestData requestData)
{
_outputWriter = outputWriter;
_tokenProvider = tokenProvider;
_serializer = serializer;
_securityContext = securityContext;
_requestData = requestData;
}
public static string FindPath(IRequestData dictionary)
{
var routeData = dictionary.ValuesFor(RequestDataSource.Route);
var list = new List<string>();
for (var i = 0; i < 10; i++)
{
routeData.Value("Part" + i, o => list.Add(o.RawValue.ToString()));
}
return list.Join("/");
}
public BindResult BindModel(Type type, IRequestData data)
{
try
{
_report.StartModelBinding(type);
BindResult result = _resolver.BindModel(type, data);
_report.EndModelBinding(result.Value);
return result;
}
catch (Exception)
{
_report.EndModelBinding(null);
throw;
}
}
public BindResult BindModel(Type type, IRequestData data)
{
try
{
_report.StartModelBinding(type);
BindResult result = _resolver.BindModel(type, data);
_report.EndModelBinding(result.Value);
return result;
}
catch (Exception exc)
{
_report.AddBindingDetail(new ModelBindingException
{
StackTrace = exc.StackTrace
});
_report.EndModelBinding(null);
throw;
}
}
public RestResponse DoRequest(IRequestData data)
{
var client = GetClient();
var request = new RestRequest("cloudadmin/{model}", data.Method);
SimpleJson.CurrentJsonSerializerStrategy = new RestJsonSerializationStrategy();
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "*/*");
request.RequestFormat = DataFormat.Json;
request.AddUrlSegment("model", data.ModelName);
if (data.Method == Method.POST)
request.AddParameter("dataEncoded", data.Encode());
else
request.AddBody(new RequestBody { DataEncoded = data.Encode() });
request.AddParameter("XDEBUG_SESSION_START", "13413", ParameterType.QueryString);
var response = client.Execute(request);
return response.Decode();
}
public void Extend(IRequestData target, WorkflowPosition workflowPosition)
{
target.Data = Data;
}
public virtual BindResult BindModel(Type type, IRequestData data)
{
var context = new BindingContext(data, _services);
return BindModel(type, context);
}
/// <summary>
/// Sends a HelloCashAPI request defined by the RequestData parameter
/// <para>Returns the servers object of type T</para>
/// <para>Returns default(T) if the Deserialization failed</para>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Authenticator">Authentication token to be used for API call</param>
/// <param name="RequestData">Defines type and payload of API request</param>
/// <exception cref="Exception">Incomplete input values | Deserializing failed | Invoice not found</exception>
/// <exception cref="Exceptions.InDemoNotAvailableException">The API is not available in the demo mode. The account has to be at least in the free mode</exception>
/// <exception cref="System.Security.Authentication.AuthenticationException"></exception>
/// <returns>API response deserialized into Task <typeparam name="T"></typeparam> object</returns>
public async Task <T> SendRequestAsync <T>(Authentication.HelloCashAuthenticator Authenticator, IRequestData RequestData)
{
//Check input values
if (RequestData == null)
{
throw new Exception($"RequestData must not be null at Invocation of {nameof(SendRequestAsync)}");
}
if (Authenticator == null)
{
throw new Exception($"Authenticator must not be null at Invocation of {nameof(SendRequestAsync)}");
}
string responseData = "";
//Send Request
using (var httpClient = new HttpClient {
BaseAddress = Config.BaseAddress
})
{
//Authenticate user
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("authorization", $"Basic {Authenticator.GetAuthenticationString()}");
if (RequestData.ToJson() == "")
{
//Requests without json content to upload
using (var response = await httpClient.GetAsync(RequestData.GetPostRequestLink()))
{
responseData = await response.Content.ReadAsStringAsync();
}
}
else
{
//Requests with json content to upload
using (var content = new StringContent(RequestData.ToJson(), System.Text.Encoding.Default, "application/json"))
{
using (var response = await httpClient.PostAsync(RequestData.GetPostRequestLink(), content))
{
responseData = await response.Content.ReadAsStringAsync();
}
}
}
}
//Wrong authentication
if (responseData.Contains("{\"error\":\"Invalid Basic authentication:"))
{
throw new System.Security.Authentication.AuthenticationException($"UserAuthentication failed. Response: {responseData}");
}
if (responseData.Contains("[\"Rechnung nicht gefunden\"]"))
{
throw new Exception($"Invoice not found. Server Response: {responseData}");
}
if (responseData == "")
{
throw new Exception($"Response string was null or empty in HelloCash call. Target deserialization type: \"{typeof(T)}\"");
}
if (responseData.Contains("\"An Error occurred\""))
{
throw new ArgumentException($"An Error occurred. Requested Id: {RequestData.ToJson()}. Server Response: {responseData}");
}
if (responseData.Contains("{\"error\":\"The API is not available in demo mode\"}"))
{
throw new Exceptions.InDemoNotAvailableException();
}
if (responseData.Contains("{\"error\":\""))
{
throw new Exception($"An error occurred. Server Response: {responseData}");
}
//Attempt to deserialize API response into T
try
{
var returnObject = new JavaScriptSerializer().Deserialize <T>(responseData);
return(returnObject);
}
catch (Exception ex)
{
throw new Exception($"HelloCash response could not be deserialized into {typeof(T)} object, inner message: {ex.Message}, not parsable json: \"{responseData}\"", ex);
}
}
public ParallelProxyExecutionManager(IRequestData requestData, Func <IProxyExecutionManager> actualProxyManagerCreator, int parallelLevel)
: base(actualProxyManagerCreator, parallelLevel, true)
{
this.requestData = requestData;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyExecutionManager"/> class.
/// </summary>
/// <param name="requestData">The Request Data for providing services and data for Run.</param>
/// <param name="requestSender">Test request sender instance.</param>
/// <param name="testHostManager">Test host manager for this proxy.</param>
public ProxyExecutionManager(IRequestData requestData, ITestRequestSender requestSender, ITestRuntimeProvider testHostManager) :
this(requestData, requestSender, testHostManager, JsonDataSerializer.Instance, new FileHelper())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DiscoveryRequest"/> class.
/// </summary>
/// <param name="requestData">The Request Data instance providing common services and data for discovery</param>
/// <param name="criteria">Discovery criterion.</param>
/// <param name="discoveryManager">Discovery manager instance.</param>
internal DiscoveryRequest(IRequestData requestData, DiscoveryCriteria criteria, IProxyDiscoveryManager discoveryManager)
{
this.DiscoveryCriteria = criteria;
this.DiscoveryManager = discoveryManager;
this.requestData = requestData;
}
public FakeJsonBehavior(IFormatter writer, IFubuRequest request, IRequestData data)
{
Writer = writer;
Request = request;
Data = data;
}
/// <summary>
/// Log Command Line switches for Telemetry purposes
/// </summary>
/// <param name="requestData">Request Data providing common discovery/execution services.</param>
private void LogCommandsTelemetryPoints(IRequestData requestData)
{
var commandsUsed = new List <string>();
var parallel = this.commandLineOptions.Parallel;
if (parallel)
{
commandsUsed.Add("/Parallel");
}
var platform = this.commandLineOptions.ArchitectureSpecified;
if (platform)
{
commandsUsed.Add("/Platform");
}
var enableCodeCoverage = this.commandLineOptions.EnableCodeCoverage;
if (enableCodeCoverage)
{
commandsUsed.Add("/EnableCodeCoverage");
}
var inIsolation = this.commandLineOptions.InIsolation;
if (inIsolation)
{
commandsUsed.Add("/InIsolation");
}
var useVsixExtensions = this.commandLineOptions.UseVsixExtensions;
if (useVsixExtensions)
{
commandsUsed.Add("/UseVsixExtensions");
}
var frameworkVersionSpecified = this.commandLineOptions.FrameworkVersionSpecified;
if (frameworkVersionSpecified)
{
commandsUsed.Add("/Framework");
}
var settings = this.commandLineOptions.SettingsFile;
if (!string.IsNullOrEmpty(settings))
{
var extension = Path.GetExtension(settings);
if (string.Equals(extension, ".runsettings", StringComparison.OrdinalIgnoreCase))
{
commandsUsed.Add("/settings//.RunSettings");
}
else if (string.Equals(extension, ".testsettings", StringComparison.OrdinalIgnoreCase))
{
commandsUsed.Add("/settings//.TestSettings");
}
else if (string.Equals(extension, ".vsmdi", StringComparison.OrdinalIgnoreCase))
{
commandsUsed.Add("/settings//.vsmdi");
}
else if (string.Equals(extension, ".testrunConfig", StringComparison.OrdinalIgnoreCase))
{
commandsUsed.Add("/settings//.testrunConfig");
}
}
requestData.MetricsCollection.Add(TelemetryDataConstants.CommandLineSwitches, string.Join(",", commandsUsed.ToArray()));
}
/// <summary>
/// Initializes a new instance of the <see cref="DiscovererEnumerator"/> class.
/// </summary>
/// <param name="requestData">The request data for providing discovery services and data.</param>
/// <param name="discoveryResultCache"> The discovery result cache. </param>
/// <param name="metricsCollector">Metric Collector</param>
public DiscovererEnumerator(IRequestData requestData, DiscoveryResultCache discoveryResultCache) : this(requestData, discoveryResultCache, TestPlatformEventSource.Instance)
{
}
public ParallelProxyDiscoveryManager(IRequestData requestData, Func <IProxyDiscoveryManager> actualProxyManagerCreator, int parallelLevel, bool sharedHosts)
: base(actualProxyManagerCreator, parallelLevel, sharedHosts)
{
this.requestData = requestData;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyDataCollectionManager"/> class.
/// </summary>
/// <param name="requestData">
/// Request Data providing common execution/discovery services.
/// </param>
/// <param name="settingsXml">
/// The settings xml.
/// </param>
/// <param name="processHelper">
/// The process helper.
/// </param>
internal ProxyDataCollectionManager(IRequestData requestData, string settingsXml, IProcessHelper processHelper) : this(requestData, settingsXml, new DataCollectionRequestSender(), processHelper, DataCollectionLauncherFactory.GetDataCollectorLauncher(processHelper, settingsXml))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyDataCollectionManager"/> class.
/// </summary>
/// <param name="requestData">
/// Request Data providing common execution/discovery services.
/// </param>
/// <param name="settingsXml">
/// Runsettings that contains the datacollector related configuration.
/// </param>
public ProxyDataCollectionManager(IRequestData requestData, string settingsXml)
: this(requestData, settingsXml, new ProcessHelper())
{
}
public AdminService(IMapper mapper, IRequestData requestData, IAdminRepository adminRepository, IAttachmentRepository attachmentRepository)
: base(mapper, requestData)
{
this.adminRepository = adminRepository;
this.attachmentRepository = attachmentRepository;
}
public AjaxAwareJsonWriter(IOutputWriter outputWriter, IRequestData requestData)
{
_outputWriter = outputWriter;
_requestData = requestData;
}
internal DataCollectionTelemetryManager(IRequestData requestData)
{
this.requestData = requestData;
}
public FubuSmartRequest(IRequestData data, IObjectConverter converter, IFubuRequest request) : base(data, converter)
{
_data = data;
_converter = converter;
_request = request;
}
public TestableProxyOperationManager(IRequestData requestData,
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager) : base(requestData, requestSender, testHostManager)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyDiscoveryManager"/> class.
/// </summary>
/// <param name="requestData">The Request Data for providing discovery services and data.</param>
/// <param name="testRequestSender">Test request sender instance.</param>
/// <param name="testHostManager">Test host manager instance.</param>
public ProxyDiscoveryManager(IRequestData requestData, ITestRequestSender testRequestSender, ITestRuntimeProvider testHostManager)
: this(requestData, testRequestSender, testHostManager, JsonDataSerializer.Instance, CrossPlatEngine.Constants.ClientConnectionTimeout)
{
this.testHostManager = testHostManager;
}
/// <summary> /// Called to write the response to the originator of the request. /// </summary> /// <param name="request">The request data.</param> /// <param name="response">The response data to send.</param> /// <returns>A task that represents the asynchronous operation.</returns> protected internal abstract Task WriteResponse(IRequestData request, IResponseData response);
//public bool IncludeValuesWithoutPrefix { get { return _includeValuesWithNoPrefix; } }
//public bool CaseSensitive { get { return _isCaseSensitive; } }
public BindingContext(IRequestData requestData)
{
_requestData = requestData;
}
public void SetUp()
{
theRequestData = new InMemoryRequestData();
theRedirect = new AjaxAuthenticationRedirect(theRequestData, null, null);
}
internal ParallelProxyDiscoveryManager(IRequestData requestData, Func <IProxyDiscoveryManager> actualProxyManagerCreator, IDataSerializer dataSerializer, int parallelLevel, bool sharedHosts)
: base(actualProxyManagerCreator, parallelLevel, sharedHosts)
{
this.requestData = requestData;
this.dataSerializer = dataSerializer;
}
public ContextValues(IObjectConverter converter, List <Func <string, string> > namingStrategies, IRequestData rawData, IBindingLogger logger)
{
_converter = converter;
_namingStrategies = namingStrategies;
_rawData = rawData;
_logger = logger;
}
//constructors
/// <summary>
/// creats a twitter feed item service that query's the given IRequestData
/// </summary>
public TwitterFeedItemService(IRequestData requestData) {
this.requestData = requestData;
}
/// <summary>
/// Invokes the SendRequestAsync Method synchronously
/// <para>Throws the same exceptions as the SendRequestAsync method</para>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Authenticator"></param>
/// <param name="RequestData"></param>
/// <returns></returns>
public T SendRequest <T>(Authentication.HelloCashAuthenticator Authenticator, IRequestData RequestData)
{
try
{
var result = HelloCashAPIWrapper.HelperClasses.AsyncHelper.RunSync <T>(() => SendRequestAsync <T>(Authenticator, RequestData));
return(result);
}
catch (Exception ex)
{
//The async helper wrapps exceptions
throw ex.InnerException;
}
}
public ParallelProxyDiscoveryManager(IRequestData requestData, Func <IProxyDiscoveryManager> actualProxyManagerCreator, int parallelLevel, bool sharedHosts)
: this(requestData, actualProxyManagerCreator, JsonDataSerializer.Instance, parallelLevel, sharedHosts)
{
}
public void Extend(IRequestData target, WorkflowPosition workflowPosition)
{
target.Data = Data;
}
/// <summary>
/// Used for unit testing only.
/// </summary>
/// <param name="requestData"></param>
/// <param name="adapterSourceMap"></param>
/// <param name="package">The user input test source(package) if it differ from actual test source otherwise null.</param>
/// <param name="runSettings"></param>
/// <param name="testExecutionContext"></param>
/// <param name="testCaseEventsHandler"></param>
/// <param name="testRunEventsHandler"></param>
/// <param name="executorUriVsSourceList"></param>
/// <param name="testRunCache"></param>
internal RunTestsWithSources(IRequestData requestData, Dictionary <string, IEnumerable <string> > adapterSourceMap, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, IEnumerable <string> > executorUriVsSourceList)
: base(requestData, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, TestPlatformEventSource.Instance)
{
this.adapterSourceMap = adapterSourceMap;
this.executorUriVsSourceList = executorUriVsSourceList;
}
public PrefixedRequestData(IRequestData inner, string prefix)
{
_inner = inner;
_prefix = prefix;
}
public TestableRunTestsWithSources(Dictionary <string, IEnumerable <string> > adapterSourceMap, string runSettings,
TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, IRequestData requestData)
: base(requestData, adapterSourceMap, null, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler)
{
}
public TestableProxyExecutionManagerWithDataCollection(IRequestData requestData, ITestRequestSender testRequestSender, ITestRuntimeProvider testHostManager, IProxyDataCollectionManager proxyDataCollectionManager) : base(requestData, testRequestSender, testHostManager, proxyDataCollectionManager)
{
}
internal TestableRunTestsWithSources(Dictionary <string, IEnumerable <string> > adapterSourceMap, string runSettings,
TestExecutionContext testExecutionContext,
ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, IEnumerable <string> > executorUriVsSourceList, IRequestData requestData)
: base(requestData, adapterSourceMap, null, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, executorUriVsSourceList)
{
}
public SubstitutedRequestData(IRequestData inner, IKeyValues substitutions)
{
_inner = inner;
_substitutions = substitutions;
}
internal TestRunRequest(IRequestData requestData, TestRunCriteria testRunCriteria, IProxyExecutionManager executionManager, ITestLoggerManager loggerManager) :
this(requestData, testRunCriteria, executionManager, loggerManager, JsonDataSerializer.Instance)
{
}
protected OwnerOfHandler(IRequestData requestData) => this.RequestData = requestData;
public AjaxAwareJsonWriter(IOutputWriter outputWriter, IRequestData requestData)
{
_outputWriter = outputWriter;
_requestData = requestData;
}
public void Extend(IRequestData target)
{
target.Data = Data;
}
/// <summary>
/// Initializes a new instance of the <see cref="DiscovererEnumerator"/> class.
/// </summary>
/// <param name="requestData">The request data for providing discovery services and data.</param>
/// <param name="discoveryResultCache"> The discovery result cache. </param>
public DiscovererEnumerator(IRequestData requestData, DiscoveryResultCache discoveryResultCache, CancellationToken token)
: this(requestData, discoveryResultCache, TestPlatformEventSource.Instance, token)
{
}
private static XElement SerializeXml(RequestTypes type, IRequestData data)
{
switch (type)
{
case RequestTypes.METAR:
var metarData = data as METAR;
if (metarData != null)
{
XAttribute id = metarData.Icao == null
? new XAttribute("p", metarData.Coordinates.ToString("p"))
: new XAttribute("icao", metarData.Icao);
XAttribute count = metarData.Count == 0 ? null : new XAttribute("count", metarData.Count);
XAttribute maxAge = metarData.MaxAge == 0 ? null : new XAttribute("maxage", metarData.MaxAge);
var element = new XElement("Metar",
id,
count,
maxAge);
return element;
}
break;
case RequestTypes.AvailableEpochs:
return new XElement("AvailableEpochs");
case RequestTypes.AvailableLevels:
return new XElement("AvailableLevels");
case RequestTypes.AvailableGeoMagModels:
return new XElement("AvailableGeomagModels");
case RequestTypes.Wind:
var windData = data as Wind;
if (windData != null)
{
var coords = new XAttribute("p", windData.Coordinates.ToString("p"));
var altitude = new XAttribute("z", windData.Altitude);
var unit = new XAttribute("u", Altitude.EnumToUnitCode(windData.Unit));
var epoch = new XAttribute("e", windData.Epoch.ToNWXString());
XAttribute id = windData.Id == null ? null : new XAttribute("id", windData.Id);
return new XElement("Wind",
coords,
altitude,
unit,
epoch,
id);
}
break;
case RequestTypes.Chart:
var chartData = data as Chart;
if (chartData != null)
{
var id = chartData.Id != null ? new XAttribute("id", chartData.Id) : null;
var width = new XAttribute("x", chartData.Width);
var height = new XAttribute("y", chartData.Height);
var level = new XAttribute("z", chartData.Level);
var epoch = new XAttribute("e", chartData.Epoch.ToNWXString());
var lat0 = new XAttribute("lat0", chartData.LowerLeftCoordinates.Latitude);
var lat1 = new XAttribute("lat1", chartData.UpperRightCoordinates.Latitude);
var lon0 = new XAttribute("lon0", chartData.LowerLeftCoordinates.Longitude);
var lon1 = new XAttribute("lon1", chartData.UpperRightCoordinates.Longitude);
var transparentBg = chartData.TransparentBackground
? new XAttribute("background", "transparent")
: null;
var layout = chartData.MapLayout ? new XAttribute("layout", "map") : null;
return new XElement("Chart",
id,
width,
height,
level,
epoch,
lat0,
lat1,
lon0,
lon1,
transparentBg,
layout,
from feature in chartData.Features
select new XElement("theme", feature));
}
break;
case RequestTypes.TAF:
var TAFData = data as TAF;
if (TAFData != null)
{
XAttribute id = TAFData.Icao == null
? new XAttribute("p", TAFData.Coordinates.ToString("p"))
: new XAttribute("icao", TAFData.Icao);
XAttribute count = TAFData.Count == 0 ? null : new XAttribute("count", TAFData.Count);
XAttribute maxAge = TAFData.MaxAge == 0 ? null : new XAttribute("maxage", TAFData.MaxAge);
var element = new XElement("Taf",
id,
count,
maxAge);
return element;
}
break;
}
return null;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyExecutionManager"/> class.
/// </summary>
/// <param name="requestData">The Request Data for providing services and data for Run.</param>
/// <param name="requestSender">Test request sender instance.</param>
/// <param name="testHostManager">Test host manager for this proxy.</param>
public ProxyExecutionManager(IRequestData requestData, ITestRequestSender requestSender, ITestRuntimeProvider testHostManager) :
this(requestData, requestSender, testHostManager, JsonDataSerializer.Instance, Constants.ClientConnectionTimeout)
{
}
public AjaxRenderStrategy(IRequestData requestData)
{
_requestData = requestData;
}
public RunTestsWithSources(IRequestData requestData, Dictionary <string, IEnumerable <string> > adapterSourceMap, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler)
: this(requestData, adapterSourceMap, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, null)
{
}
