private (ApiModule requestApiModule, ApiModule responseApiModule) GetExistingOrCreateNewApiModulePair(
TCObject objectToExecuteOn,
XTestStep wseTestStep,
IWseArtifactsParser wseParser)
{
ApiModule requestApiModule = null;
ApiModule responseApiModule = null;
if (!IsModuleSearchCriteriaEmpty(wseParser))
{
(requestApiModule, responseApiModule) =
CommonUtilities.SearchExistingApiModule(objectToExecuteOn, wseParser, wseTestStep);
}
if (requestApiModule != null)
{
return(requestApiModule, responseApiModule);
}
FolderStructureHandler folderStructureHandler = new FolderStructureHandler();
(TCFolder apiModuleFolder, string moduleName) =
folderStructureHandler.CreateFolderForApiModules(objectToExecuteOn, wseTestStep, wseParser);
return(ApiModuleHandler.CreateApiModulePair(apiModuleFolder, moduleName, wseParser));
}
/// <summary>
/// Creates request module
/// </summary>
/// <param name="moduleFolder">Folder path reference to create Request module</param>
/// <param name="name">Name of Request module</param>
/// <param name="wseModuleParser">Contains transport information used to fill in Request Module</param>
/// <param name="correlationId">Uniquely identify the Request Module</param>
/// <returns></returns>
public static ApiModule CreateRequestModule(TCFolder moduleFolder,
string name,
IWseArtifactsParser wseModuleParser,
string correlationId)
{
//Module Properties
ApiModule requestApiModule =
SetModuleStandardProperties(moduleFolder,
name,
correlationId,
ScanTag.GetRequestScanTag(wseModuleParser));
//Request Properties
requestApiModule.AddTechnicalIdParam("Direction", Direction.Out.ToString());
requestApiModule.AddTechnicalIdParam("InactiveNodes", "Remove");
requestApiModule.AddTechnicalIdParam("IsRequest", "True");
requestApiModule.AddTechnicalIdParam("MessagesGenerated", "True");
requestApiModule.AddConfigurationParam("Executor", "HttpSend");
requestApiModule.AddTechnicalIdParam("Method", wseModuleParser.Method);
requestApiModule.AddTechnicalIdParam("Endpoint", wseModuleParser.Endpoint);
requestApiModule.AddTechnicalIdParam("Resource", wseModuleParser.Resource);
requestApiModule.AddQueryParams(wseModuleParser.QueryParams);
requestApiModule.AddPathParams(wseModuleParser.PathParams);
requestApiModule.AddHeaders(wseModuleParser.Headers);
if (!string.IsNullOrEmpty(wseModuleParser.RequestPayload))
{
requestApiModule.APISetMessagePayload(wseModuleParser.RequestPayload);
}
return(requestApiModule);
}
/// <summary>
/// Creates response module
/// </summary>
/// <param name="moduleFolder">Folder path reference to create Response module</param>
/// <param name="name">Name of Response module</param>
/// <param name="wseModuleParser">Contains transport information used to fill in Response Module</param>
/// <param name="correlationId">Uniquely identify the Response Module</param>
/// <returns></returns>
public static ApiModule CreateResponseModule(TCFolder moduleFolder,
string name,
IWseArtifactsParser wseModuleParser,
string correlationId
)
{
//tosca specific properties
ApiModule responseApiModule =
SetModuleStandardProperties(moduleFolder,
name,
correlationId,
ScanTag.GetResponseScanTag(wseModuleParser));
responseApiModule.AddTechnicalIdParam("Direction", Direction.In.ToString());
responseApiModule.AddTechnicalIdParam("InactiveNodes", "Keep");
responseApiModule.AddTechnicalIdParam("IsRequest", "False");
responseApiModule.AddConfigurationParam("Executor", "HttpReceive");
responseApiModule.AddHeaders(wseModuleParser.ResponseHeaders);
responseApiModule.AddTechnicalIdParam("StatusCode", wseModuleParser.ResponseStatus);
if (!string.IsNullOrEmpty(wseModuleParser.ResponsePayload))
{
responseApiModule.APISetMessagePayload(wseModuleParser.ResponsePayload);
}
return(responseApiModule);
}
/// <summary>
/// Creates Module Attribute
/// </summary>
/// <param name="apiModule">ApiModule</param>
/// <param name="name"> Name of the Module Attribute</param>
/// <param name="valueRange">ValueRange of the Module Attribute</param>
/// <param name="value">Default value of the Module Attribute</param>
/// <param name="pathType">pathType of the Module Attribute</param>
/// <param name="path">path of the Module Attribute</param>
/// <param name="actionMode">Default ActionMode of the Module Attribute</param>
/// <param name="dataType">Data Type of the Module Attribute</param>
/// <returns>Module Attribute</returns>
public static XModuleAttribute CreateModuleAttribute(this ApiModule apiModule,
string name,
string valueRange,
string value,
string pathType,
string path,
XTestStepActionMode actionMode =
XTestStepActionMode.Verify,
ModuleAttributeDataType dataType =
ModuleAttributeDataType.String)
{
XModuleAttribute xModuleAttribute =
apiModule.CreateModuleAttribute();
xModuleAttribute.Name = name;
xModuleAttribute.DefaultValue = value;
if (!string.IsNullOrEmpty(valueRange))
{
xModuleAttribute.ValueRange = valueRange;
}
xModuleAttribute.EnsureUniqueName();
xModuleAttribute.AddXParamToModuleAttribute("PathType", pathType, ParamTypeE.TechnicalID);
xModuleAttribute.AddXParamToModuleAttribute("Path", path, ParamTypeE.TechnicalID);
xModuleAttribute.AddXParamToModuleAttribute("ExplicitName", "True", ParamTypeE.Configuration);
xModuleAttribute.DefaultActionMode = actionMode;
xModuleAttribute.DefaultDataType = dataType;
return(xModuleAttribute);
}
/// <summary>
/// Add HTTP Headers to API Module
/// </summary>
/// <param name="apiModule">API Module</param>
/// <param name="headers">Dictionary of headers to be added</param>
public static void AddHeaders(this ApiModule apiModule, Dictionary <string, string> headers)
{
foreach (KeyValuePair <string, string> header in headers)
{
apiModule.APIAddMessageHeader(header.Key, header.Value);
}
}
/// <summary>
/// Add params of type Path to the Params section in tosca
/// </summary>
/// <param name="apiModule">API Module</param>
/// <param name="pathParams">Dictionary of Path params to be added</param>
public static void AddPathParams(this ApiModule apiModule, Dictionary <string, string> pathParams)
{
foreach (KeyValuePair <string, string> pathParam in pathParams)
{
apiModule.APIAddMessageParameter(pathParam.Key, pathParam.Value, "Path");
}
}
public void ProcessRequest(HttpContext context)
{
string moduleId = context.Request["module_id"];
if (string.IsNullOrEmpty(moduleId))
{
apiResp.msg = "module_id为必填项,请检查";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsNotFound;
bllApi.ContextResponse(context, apiResp);
return;
}
ApiModule model = bllApi.GetApiModule(int.Parse(moduleId));
if (model == null)
{
apiResp.msg = "模块不存在";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsNotFound;
bllApi.ContextResponse(context, apiResp);
return;
}
if (bllApi.Delete(model) > 0)
{
apiResp.status = true;
apiResp.msg = "ok";
}
else
{
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.OperateFail;
apiResp.msg = "操作出错";
}
bllApi.ContextResponse(context, apiResp);
}
/// <summary>
/// Sets basic authentication properties such as type, username, password and pre-authenticate in API module
/// </summary>
/// <param name="apiTestStep">returns module of apiTeststep</param>
/// <param name="wseTestStep">returns username, password, preauthenticate information of wseTestStep</param>
public void Execute(XTestStep apiTestStep, XTestStep wseTestStep)
{
try {
FileLogger.Instance.Info("Inside Basic Auth Credentials Migrator");
string userName = GetWseUsernameValue(wseTestStep);
string password = GetWsePasswordValue(wseTestStep);
string preAuthenticate = GetWsePreAuthenticateValue(wseTestStep);
if (!string.IsNullOrEmpty(userName) || !string.IsNullOrEmpty(password) ||
!string.IsNullOrEmpty(preAuthenticate))
{
ApiModule apiModule = (ApiModule)apiTestStep.Module;
apiModule.AddXParamToModuleAttribute("AuthenticationType", "Basic", ParamTypeE.TechnicalID);
apiModule.AddXParamToModuleAttribute("Username", userName, ParamTypeE.TechnicalID);
apiModule.AddXParamToModuleAttribute("Password", password, ParamTypeE.TechnicalID);
apiModule.AddXParamToModuleAttribute("PreAuthenticate",
preAuthenticate == "Yes" ? "true" : "false",
ParamTypeE.TechnicalID);
}
FileLogger.Instance.Info("Complete Basic Auth Credentials Migrator");
}
catch (Exception ex) {
FileLogger.Instance.Error(
$"Error occurred while migration of Auth Credentials for WSE TestStep : 'Name: {wseTestStep?.Name}' NodePath:'{wseTestStep?.NodePath}' Exception:'{ex.ToString()}'");
}
}
public void Configuration(IAppBuilder builder)
{
this.log.WriteWarning("Configuration started");
ApiModule.Configure(builder);
this.log.WriteWarning("Configuration finished");
}
public void Can_Not_Add_Swagger()
{
var serviceCollection = new ServiceCollection();
var apiModule = new ApiModule(null, new List <string>(), false);
apiModule.ConfigureServices(serviceCollection);
serviceCollection.Any(service => service.ServiceType == typeof(ISwaggerProvider)).Should().Be(false);
}
/// <summary>
/// Add params of type Query to the Params section in tosca
/// </summary>
/// <param name="apiModule">API Module</param>
/// <param name="pathParams">Dictionary of query params to be added</param>
public static void AddQueryParams(this ApiModule apiModule, Dictionary <string, string> queryParams)
{
foreach (KeyValuePair <string, string> queryParam in queryParams)
{
apiModule.APIAddMessageParameter(queryParam.Key, queryParam.Value, "Query");
}
apiModule.AddTechnicalIdParam("QueryParams", string.Join(";", queryParams));
}
private IContainer BuildContainer()
{
var builder = new ContainerBuilder();
var apiModule = new ApiModule();
builder.RegisterModule(apiModule);
builder.RegisterApiControllers(apiModule.GetType().Assembly);
return builder.Build();
}
/// <summary>
/// Creates module attribute for Query params in Api module.
/// </summary>
/// <param name="apiModule">apiModule under which module attribute gets created.</param>
/// <param name="wseTestStepValue">wsetesstep value to set in api module attribute</param>
/// <returns></returns>
protected override XModuleAttribute CreateModuleAttribute(ApiModule apiModule,
KeyValuePair <string, string> wseTestStepValue)
{
return(apiModule.CreateModuleAttribute(wseTestStepValue.Key,
String.Empty,
"UrlParam",
$"{wseTestStepValue.Key};Query;0",
XTestStepActionMode.Insert));
}
protected override string GetValueInApiModule(ApiModule apiModule)
{
try {
return(apiModule.GetPropertyValue("Endpoint"));
}
catch (Exception) {
return(string.Empty);
}
}
/// <summary>
/// Creates module attribute for response headers.
/// </summary>
/// <param name="apiModule">apiModule</param>
/// <param name="wseTestStepValue">testStepValue of WSE</param>
/// <returns>returns module attribute</returns>
protected override XModuleAttribute CreateModuleAttribute(ApiModule apiModule,
KeyValuePair <string, string> wseTestStepValue)
{
return(apiModule.CreateModuleAttribute(
wseTestStepValue.Key,
wseTestStepValue.Value,
wseTestStepValue.Value,
"Header",
wseTestStepValue.Key,
XTestStepActionMode.Insert));
}
private void AssertService(Type type, bool addSwagger = true, bool shouldContain = true)
{
if (_apiModule == null)
{
_apiModule = new ApiModule(null,
new List <string>(), addSwagger);
_apiModule.ConfigureServices(_serviceCollection);
}
_serviceCollection.Any(service => service.ServiceType == type).Should().Be(shouldContain);
}
CreateModuleAttribute(ApiModule apiModule, XTestStepValue wseTestStepValue)
{
return(apiModule.CreateModuleAttribute(
"StatusCode",
HttpStatusCodeExtension.ValueRange(),
wseTestStepValue.ModuleAttribute.DefaultValue,
"StatusCode",
"StatusCode",
wseTestStepValue.ModuleAttribute.DefaultActionMode,
wseTestStepValue.ModuleAttribute.DefaultDataType));
}
CreateModuleAttribute(ApiModule apiModule, XTestStepValue wseTestStepValue)
{
return(apiModule.CreateModuleAttribute(
"Endpoint",
GetRefinedWseTestStepValue(wseTestStepValue.Value),
GetRefinedWseTestStepValue(wseTestStepValue.Value),
"Endpoint",
"Endpoint",
wseTestStepValue.ModuleAttribute.DefaultActionMode,
wseTestStepValue.ModuleAttribute.DefaultDataType));
}
public void ProcessRequest(HttpContext context)
{
RequestModel requestModel = new RequestModel();
try
{
requestModel = ZentCloud.Common.JSONHelper.JsonToModel <RequestModel>(context.Request["data"]);
}
catch (Exception)
{
apiResp.msg = "JSON格式错误,请检查";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.PrimaryKeyIncomplete;
bllApi.ContextResponse(context, apiResp);
return;
}
if (requestModel.module_id <= 0)
{
apiResp.msg = "module_id参数为必填项,请检查";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsNotFound;
bllApi.ContextResponse(context, apiResp);
return;
}
if (string.IsNullOrEmpty(requestModel.module_name))
{
apiResp.msg = "module_name参数为必填项,请检查";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsNotFound;
bllApi.ContextResponse(context, apiResp);
return;
}
ApiModule model = bllApi.GetApiModule(requestModel.module_id);
if (model == null)
{
apiResp.msg = "模块不存在";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.IsNotFound;
bllApi.ContextResponse(context, apiResp);
return;
}
model.ModuleName = requestModel.module_name;
model.Description = requestModel.module_desc;
model.Sort = requestModel.sort;
if (bllApi.Update(model))
{
apiResp.msg = "ok";
apiResp.status = true;
}
else
{
apiResp.msg = "操作出错";
apiResp.code = (int)BLLJIMP.Enums.APIErrCode.OperateFail;
}
bllApi.ContextResponse(context, apiResp);
}
private static ApiModule SetModuleStandardProperties(TCFolder moduleFolder,
string name,
string correlationId,
string scanTag)
{
ApiModule requestApiModule = moduleFolder.CreateApiModule();
requestApiModule.Name = name;
requestApiModule.EnsureUniqueName();
requestApiModule.AddTechnicalIdParam("CorrelationId", correlationId);
requestApiModule.AddTechnicalIdParam("Version", AddOnConstants.ToscaVersion);
requestApiModule.AddConfigurationParam("Engine", "API");
requestApiModule.AddTechnicalIdParam("ScanTag", scanTag);
return(requestApiModule);
}
/// <summary>
/// Creates configuration param
/// </summary>
/// <param name="module">API Module</param>
/// <param name="name">Name of the configuration parameter</param>
/// <param name="value">Value of the configuration parameter</param>
public static void AddConfigurationParam(this ApiModule module, string name, string value)
{
if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(value))
{
return;
}
XParam newXParam = module.CreateConfigurationParam();
newXParam.Name = name;
newXParam.Value = value;
newXParam.ParamType = ParamTypeE.Configuration;
if (name == "Password")
{
newXParam.Visible = false;
}
}
CreateModuleAttribute(ApiModule apiModule, XTestStepValue wseTestStepValue)
{
return(apiModule.CreateModuleAttribute(
"Method",
HttpMethodExtension.ValueRangeString(),
wseTestStepValue
.ModuleAttribute.DefaultValue,
"Method",
"Method",
wseTestStepValue
.ModuleAttribute
.DefaultActionMode,
wseTestStepValue
.ModuleAttribute
.DefaultDataType));
}
public void Can_Add_Api()
{
Type[] serviceTypes =
{
typeof(ICorsService),
};
var serviceCollection = new ServiceCollection();
var apiModule = new ApiModule(null, new List <string>(), true);
apiModule.ConfigureServices(serviceCollection);
foreach (var serviceType in serviceTypes)
{
serviceCollection.Any(service => service.ServiceType == serviceType).Should().Be(true);
}
}
/// <summary>
/// Creates module attributes for payload
/// </summary>
/// <param name="wseTestStepValue">TestStepValues of WSE Teststep</param>
/// <param name="xpath">XPath and JsonPath for xml</param>
/// <param name="parent">xModule and xModuleAttribute of ApiEngine</param>
/// <param name="apiModule">ApiModule</param>
/// <param name="parentTest">TestStep and TestStepValues for ApiTestStep</param>
/// <param name="cardinality">Cardinality of WSE XModule</param>
/// <param name="isArray">True if Wse Xmodule attributes is array</param>
/// <returns>returns XtestTestValue of API</returns>
public XTestStepValue CreateModuleAttributeForPayload(XTestStepValue wseTestStepValue,
string xpath,
dynamic parent,
ApiModule apiModule,
dynamic parentTest,
string cardinality,
bool isArray = false)
{
return(BusinessParameterHandler.CreateBusinessParameterInTosca(wseTestStepValue,
xpath,
parent,
apiModule,
BusinessParameterPathTypes.XPATH,
parentTest,
cardinality,
isArray));
}
public static void AddXParamToModuleAttribute(this ApiModule module,
string name,
string value,
ParamTypeE xParamType)
{
var xparam = module.XParams.Where(x => x.Name == name);
if (xparam == null || !xparam.Any())
{
XParam newXParam = module.CreateConfigurationParam();
newXParam.Name = name;
newXParam.Value = value;
newXParam.ParamType = xParamType;
if (name == "Password")
{
newXParam.Visible = false;
}
}
}
/// <summary>
/// Creates request and response module pair
/// </summary>
/// <param name="apiModuleFolder">Folder path reference to create Request and Response module</param>
/// <param name="moduleName">Name of Request and Response module</param>
/// <param name="wseParser">Contains transport information like Endpoint, Headers, Payload used to fill in Request and Response Module</param>
/// <returns></returns>
public static (ApiModule, ApiModule) CreateApiModulePair(TCFolder apiModuleFolder,
string moduleName,
IWseArtifactsParser wseParser
)
{
string correlationId = Guid.NewGuid().ToString();
ApiModule requestApiModule =
CreateRequestModule(apiModuleFolder,
moduleName,
wseParser,
correlationId
);
ApiModule responseApiModule =
CreateResponseModule(apiModuleFolder,
$"{moduleName} Response",
wseParser,
correlationId
);
return(requestApiModule, responseApiModule);
}
private XTestStepValue CreateModuleAttributeForPayload(XTestStepValue wseTestStepValue,
string jsonPath,
dynamic parent,
ApiModule apiModule,
dynamic parentTest,
string cardinality,
bool isArray = false)
{
if (jsonPath.StartsWith("."))
{
jsonPath = jsonPath.Remove(0, 1);
}
return(BusinessParameterHandler.CreateBusinessParameterInTosca(wseTestStepValue,
jsonPath,
parent,
apiModule,
BusinessParameterPathTypes.JSONPATH,
parentTest,
cardinality,
isArray));
}
protected override string GetValueInApiModule(ApiModule apiModule, string key)
{
try {
if (apiModule?.Headers != null && apiModule.Headers.Length > 0)
{
var l = Deserialize <List <List <KeyValuePair <string, string> > > >(apiModule.Headers);
foreach (var keyvaluepairList in l)
{
var k = keyvaluepairList.First().Value;
if (k == key)
{
return(CommonUtilities.RemoveExtraDoubleQuotes(keyvaluepairList.Last().Value));
}
}
}
}
catch (Exception) {
// ignored
}
return(string.Empty);
}
public async static Task <IContainer> GetContainer(string settingsUrl)
{
var reader = new Lykke.SettingsReader.SettingsServiceReloadingManager <AppSettings <IconApiSettings> >(settingsUrl, (x) => { });
var reloadingManager = await reader.Reload();
var apiModule = new ApiModule <IconApiSettings>(reader);
var iconApiModule = new IconApiModule(reader);
var services = new ServiceCollection();
ContainerBuilder builder = new ContainerBuilder();
services.AddHttpClient();
builder.
RegisterInstance(reader)
.As <IReloadingManager <AppSettings <IconApiSettings> > >()
.SingleInstance();
builder.RegisterModule(iconApiModule);
builder.RegisterModule(apiModule);
builder.Populate(services);
var container = builder.Build();
return(container);
}
/// <summary>
/// Creates technical param in the property section of module
/// </summary>
/// <param name="module">API Module</param>
/// <param name="name">Name of the Technical parameter</param>
/// <param name="value">Value of the Technical parameter</param>
/// <param name="visibility">if the param will be visible in the property section</param>
public static void AddTechnicalIdParam(this ApiModule module,
string name,
string value,
bool visibility = true)
{
if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(value))
{
return;
}
XParam newXParam = module.CreateConfigurationParam();
newXParam.Name = name;
newXParam.Value = value;
newXParam.ParamType = ParamTypeE.TechnicalID;
if (!visibility)
{
newXParam.Visible = false;
}
if (name == "Password")
{
newXParam.Visible = false;
}
}
/// <summary>
/// Creates an instance of the response.
/// </summary>
/// <param name="module">The ApiModule from which the response will be sent.</param>
/// <param name="message">A human-readable message explaining the error.
/// If a value of null is supplied for this parameter then a default message will be provided.</param>
/// <param name="detail">A human-readable message that provides more detail and preferably
/// some indication of the action that the API consumer should take to remedy the error.
/// If a value of null is supplied for this parameter then default details will be provided.</param>
/// <param name="errorCode">An error code unique within the scope of an API's domain.
/// If a value of null is supplied for this parameter then a default error code will be provided.</param>
/// <param name="infoUrl">A url where further documentation is provided about the error.
/// If a value of null is supplied for this parameter then a default url will be provided.</param>
public UnauthorizedResponse(ApiModule module, string message, string detail,
string errorCode, string infoUrl)
: this(module.Context, message, detail, errorCode, infoUrl)
{
}
