/// <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>
/// Create API Modules Folder Name on the basis of SoapAction, Resource, Endpoint and Method(HttpVerbs)
/// </summary>
/// <param name="xTestStep">Wse Teststep</param>
/// <param name="parserResult">Contains transport info(Endpoint, Method, Resource, Headers)</param>
/// <returns>FolderName</returns>
public static string CreateModuleFolderName(XTestStep xTestStep, IWseArtifactsParser parserResult)
{
try {
var soapAction = GetSoapAction(parserResult.Headers);
if (!string.IsNullOrEmpty(soapAction))
{
var action = soapAction.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Last();
if (!string.IsNullOrEmpty(action))
{
return(AppendMethod(action, parserResult.Method));
}
}
if (!string.IsNullOrEmpty(parserResult.Resource))
{
return(AppendMethod(parserResult.Resource, parserResult.Method));
}
if (!string.IsNullOrEmpty(parserResult.Endpoint))
{
return(AppendMethod(parserResult.Endpoint, parserResult.Method));
}
}
catch (Exception) {
// ignored
}
return("UnknownResource");
}
/// <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);
}
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>
/// Get Request/Response API Module on the basis of scanTag.
/// </summary>
/// <param name="objectToExecuteOn">TcObjects</param>
/// <param name="wseArtifactsParser">Contains Transport information</param>
/// <param name="wseTestStep">WSE TestSteps</param>
/// <returns>Request/Response API Module</returns>
public static (ApiModule, ApiModule) SearchExistingApiModule(TCObject objectToExecuteOn,
IWseArtifactsParser wseArtifactsParser,
XTestStep wseTestStep)
{
if (SpecializationHelper.IsUsingEmbeddedResource(wseTestStep, out TCFolder searchFolder))
{
var requestModule = SearchRequestModule(searchFolder, wseArtifactsParser);
var responseModule = SearchResponseModule(searchFolder, wseArtifactsParser);
if (requestModule != null)
{
return(requestModule, responseModule);
}
}
return(SearchRequestModule(objectToExecuteOn, wseArtifactsParser),
SearchResponseModule(objectToExecuteOn, wseArtifactsParser));
}
/// <summary>
/// Create ScanTag for uniquely identify a API Request/Response Module from WSE artifacts
/// </summary>
/// <param name="parserResult">Transport information used to create ScanTag</param>
/// <param name="prefix">Dilimiter</param>
/// <returns></returns>
private static string Generate(IWseArtifactsParser parserResult, string prefix)
{
var scanTag = new StringBuilder();
scanTag.Append(prefix);
scanTag.Append("#");
scanTag.Append(parserResult.Method);
scanTag.Append("#");
scanTag.Append(parserResult.Endpoint);
scanTag.Append("#");
scanTag.Append(parserResult.Resource);
scanTag.Append("#");
scanTag.Append(CommonUtilities.GetSoapAction(parserResult.Headers));
scanTag.Append("#");
scanTag.Append(CommonUtilities.GetQueryParamsKeys(parserResult.QueryParams));
scanTag.Append("#");
scanTag.Append(parserResult.HashCode);
return(scanTag.ToString());
}
/// <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);
}
/// <summary>
/// Identify location of existing WSE Specialized Modules and create generic folder for storing API modules
/// </summary>
/// <param name="rootComponentFolder"> Component Folder at which migration is executing </param>
/// <param name="xTestStep">TestStep for WseArtifacts</param>
/// <param name="parserResult">Transport information used to fill in Request and Response Module</param>
/// <returns></returns>
public (TCFolder, string) CreateFolderForApiModules(TCObject rootComponentFolder,
XTestStep xTestStep,
IWseArtifactsParser parserResult)
{
if (SpecializationHelper.IsRequestIsUsingEmbeddedModule(xTestStep, out XModule requestSpecializationModule)
)
{
return(CreateFolderForApiModules(requestSpecializationModule), requestSpecializationModule.Name);
}
if (SpecializationHelper.IsResponseIsUsingEmbeddedModule(xTestStep,
out XModule responseSpecializationModule))
{
return(CreateFolderForApiModules(responseSpecializationModule), responseSpecializationModule.Name);
}
var apiModulesFolder = GetOrCreateApiModulesFolder(rootComponentFolder);
var moduleName = CommonUtilities.CreateModuleFolderName(xTestStep, parserResult);
var folder = apiModulesFolder.CreateFolder();
folder.Name = $"API_{moduleName}";
folder.EnsureUniqueName();
return(folder, moduleName);
}
protected override bool IsModuleSearchCriteriaEmpty(IWseArtifactsParser parserResult)
{
return(string.IsNullOrEmpty(parserResult.Endpoint));
}
SearchResponseModule(TCObject rootComponentFolder, IWseArtifactsParser testStepParser)
{
return(ScanTag.SearchModuleByScanTag(rootComponentFolder,
ScanTag.GetResponseScanTag(testStepParser)));
}
private static ApiModule SearchRequestModule(TCObject rootComponentFolder, IWseArtifactsParser testStepParser)
{
return(ScanTag.SearchModuleByScanTag(rootComponentFolder,
ScanTag.GetRequestScanTag(testStepParser)));
}
protected override bool IsModuleSearchCriteriaEmpty(IWseArtifactsParser parserResult)
{
return(string.IsNullOrEmpty(CommonUtilities.GetSoapAction(parserResult.Headers)));
}
protected abstract bool IsModuleSearchCriteriaEmpty(IWseArtifactsParser parserResult);
public static string GetResponseScanTag(IWseArtifactsParser parser)
{
return(Generate(parser, "Response"));
}
public static string GetRequestScanTag(IWseArtifactsParser parser)
{
return(Generate(parser, "Request"));
}
