Exemple #1
0
        /// <summary>
        /// construct json payload for Api modules
        /// </summary>
        /// <param name="rawRequestPayload">WSE XTestStepValues</param>
        /// <param name="jObject">json payload</param>
        /// <returns>json payload</returns>
        public static JObject ConstructJsonStructure(XTestStepValue rawRequestPayload, JObject jObject)
        {
            try {
                foreach (var testStepValue in rawRequestPayload.SubValues)
                {
                    if (testStepValue.ModuleAttribute.BusinessType == "JsonValue")
                    {
                        jObject.Add(testStepValue.Name, testStepValue.Value);
                    }
                    else if (testStepValue.ModuleAttribute.BusinessType == "JsonObject")
                    {
                        JObject nestedObject = new JObject();
                        nestedObject = ConstructJsonStructure(testStepValue, nestedObject);
                        jObject.Add(testStepValue.Name, nestedObject);
                    }
                    else if (testStepValue.ModuleAttribute.BusinessType == "JsonArray")
                    {
                        JArray  arrayAttributes = new JArray();
                        JObject arrayObject     = new JObject();
                        arrayObject = ConstructJsonStructure(testStepValue, arrayObject);
                        arrayAttributes.Add(arrayObject.Values());
                        jObject.Add(testStepValue.Name, arrayAttributes);
                    }
                }
            }
            catch (Exception ex) {
                FileLogger.Instance.Error(ex.Message);
            }

            return(jObject);
        }
        private XTestStepValue GetOrCreateApiXTestStepValue(XTestStep apiTestStep,
                                                            KeyValuePair <string, string> wseTestStepValue)
        {
            XTestStepValue apiTeststepValue =
                (XTestStepValue)apiTestStep
                .Search(string.Format(TqlToGetApiTestStepValue, wseTestStepValue.Key))
                .FirstOrDefault();

            //if xTestStepValue not present,create it.
            if (apiTeststepValue == null)
            {
                //check if module attribute is present.
                var xModuleAttribute =
                    (XModuleAttribute)apiTestStep
                    .Module.Search(
                        string.Format(TqlToGetModuleAttributeInApiModule,
                                      wseTestStepValue.Key)).FirstOrDefault();
                //if not present, Create it.
                if (xModuleAttribute == null)
                {
                    XModuleAttribute m =
                        CreateModuleAttribute(apiTestStep.Module as ApiModule, wseTestStepValue);
                    apiTeststepValue = apiTestStep.CreateXTestStepValue(m);
                }
                //if already present, use it.
                else
                {
                    apiTeststepValue = apiTestStep.CreateXTestStepValue(xModuleAttribute);
                }
            }

            return(apiTeststepValue);
        }
        static void Main(string[] args)
        {
            using (TCAPI tcapi = TCAPI.CreateInstance())
            {
                TCWorkspace     workspace      = tcapi.OpenWorkspace(@"C:\Users\estan\Desktop\trainings\TOSCA Customizations\Tosca Workspace\Training Customizations\Training Customizations.tws", "Admin", "");
                TCProject       project        = workspace.GetProject();
                List <TCObject> result         = project.Search($"=>SUBPARTS:TCFolder[UniqueId==\"{unique_id_test_case_folder}\"]");
                TCFolder        testCaseFolder = (TCFolder)result.First();
                testCaseFolder.Checkout();

                TestCase testCase = testCaseFolder.CreateTestCase();
                testCase.Name = "Test Creating Test Case";

                XModule tboxSetBuffer = (XModule)project.Search($"=>SUBPARTS:XModule[UniqueId==\"{unique_id_tbox_set_buffer}\"]").First();
                XModule tboxWait      = (XModule)project.Search($"=>SUBPARTS:XModule[UniqueId==\"{unique_id_tbox_wait}\"]").First();


                XTestStep      setBufferTestStep  = testCase.CreateXTestStepFromXModule(tboxSetBuffer);
                XTestStepValue setBUfferStepvalue = setBufferTestStep.CreateXTestStepValue(tboxSetBuffer.Attributes.First());
                setBUfferStepvalue.Name       = "Test Buffer Creation";
                setBUfferStepvalue.Value      = "42";
                setBUfferStepvalue.ActionMode = XTestStepActionMode.Input;

                XTestStep      tboxSetWaitTimeStep      = testCase.CreateXTestStepFromXModule(tboxWait);
                XTestStepValue tboxWaitSettimeStepValue = tboxSetWaitTimeStep.TestStepValues.First();
                tboxWaitSettimeStepValue.Value = "500";
            }
        }
        /// <summary>
        /// Parses WSE XTestStep to get payload
        /// </summary>
        /// <param name="xTestStep">WSE XTestStep</param>
        /// <param name="tql">tql to get root json object from request/reponse object</param>
        /// <returns>payload</returns>
        public string Parse(XTestStep xTestStep, string tql = "")
        {
            try {
                if (xTestStep == null)
                {
                    return(string.Empty);
                }
                XTestStepValue jsonObject = xTestStep.Search(tql).Cast <XTestStepValue>().FirstOrDefault(
                    x => x.ModuleAttribute.BusinessType
                    == "JsonObject" ||
                    x.ModuleAttribute.BusinessType == "JsonArray");

                if (jsonObject != null)
                {
                    JArray  arrayObject = new JArray();
                    JObject plainObject = CommonUtilities.ConstructJsonStructure(jsonObject, new JObject());
                    if (jsonObject.ModuleAttribute.BusinessType == "JsonObject")
                    {
                        return(Convert.ToString(plainObject));
                    }

                    arrayObject.Add(plainObject.Values());
                    return(Convert.ToString(arrayObject));
                }
            }
            catch (Exception e) {
                FileLogger.Instance.Error(
                    $"Failed to create Json payload for request :{xTestStep?.Name}",
                    e);
            }

            return(string.Empty);
        }
        /// <summary>
        /// Fills XML payload using recursive call to method
        /// </summary>
        /// <param name="tcObjects">XML payload testStepValues</param>
        /// <param name="apiTestStep">apiTestStep</param>
        /// <param name="wseTestStep">wseTestStep</param>
        /// <param name="xPath">xpTah</param>
        /// <param name="parent">xModule and xModuleAttribute of API</param>
        /// <param name="parentTest">XTestStep and xTestStepValue of ApiTesstep</param>
        public virtual void FillPayloadInternal(IEnumerable <XTestStepValue> tcObjects,
                                                XTestStep apiTestStep,
                                                XTestStep wseTestStep,
                                                string xPath,
                                                dynamic parent,
                                                dynamic parentTest)
        {
            XTestStepValue wseTestStepValue = null;
            string         tXpathFormat     = "/*[local-name()='{0}']";

            if (!tcObjects.Any())
            {
                return;
            }
            var firstObject = tcObjects.First();
            var lastObject  = tcObjects.Last();

            foreach (var tcObject in tcObjects.Where(x => x.ModuleAttribute.BusinessType == "XmlElement"))
            {
                bool isArray = false;
                try {
                    wseTestStepValue = tcObject;
                    string currXpath;
                    if (firstObject.Name == lastObject.Name && !ReferenceEquals(firstObject, lastObject))
                    {
                        currXpath = xPath + string.Format(tXpathFormat,
                                                          wseTestStepValue.Name);
                        isArray = true;
                    }
                    else
                    {
                        currXpath = xPath + string.Format(tXpathFormat, wseTestStepValue.Name);
                    }

                    XTestStepValue apiTestStepValue = CreateModuleAttributeForPayload(wseTestStepValue,
                                                                                      currXpath,
                                                                                      parent,
                                                                                      (ApiModule)apiTestStep.Module,
                                                                                      parentTest,
                                                                                      wseTestStepValue
                                                                                      .ModuleAttribute
                                                                                      ?.Cardinality,
                                                                                      isArray
                                                                                      );
                    FillPayloadInternal(tcObject.SubValues,
                                        apiTestStep,
                                        wseTestStep,
                                        currXpath,
                                        apiTestStepValue.ModuleAttribute,
                                        apiTestStepValue);
                }
                catch (Exception ex) {
                    FileLogger.Instance.Error(
                        $"Error occurred while creating Business Parameter for WSE TestStep : 'Name: {wseTestStep?.Name}' NodePath:'{wseTestStep?.NodePath}' TestStepValue:'{wseTestStepValue?.Name}' Exception:'{ex.ToString()}'");
                }
            }
        }
        /// <summary>
        /// Evaluates Json path of wseteststep values.
        /// </summary>
        /// <param name="wseTestStep">parent node of wseteststep</param>
        /// <param name="wseTestStepValue">node for which json path is to be evaluated</param>
        /// <param name="jsonPath">reform json path for static or dynamic payload</param>
        /// <returns></returns>
        public virtual string GetJsonPath(XTestStep wseTestStep, XTestStepValue wseTestStepValue, string jsonPath)
        {
            TCObject rootObject = wseTestStep
                                  .Search("=>SUBPARTS:XTestStepValue[Name==\"Response\"]->SUBPARTS")
                                  .FirstOrDefault();

            var rootObjectNodePath = rootObject?.NodePath;

            return(ExtractToscaJsonPath(rootObjectNodePath, wseTestStepValue, jsonPath));
        }
 CreateModuleAttribute(ApiModule apiModule, XTestStepValue wseTestStepValue)
 {
     return(apiModule.CreateModuleAttribute(
                "StatusCode",
                HttpStatusCodeExtension.ValueRange(),
                wseTestStepValue.ModuleAttribute.DefaultValue,
                "StatusCode",
                "StatusCode",
                wseTestStepValue.ModuleAttribute.DefaultActionMode,
                wseTestStepValue.ModuleAttribute.DefaultDataType));
 }
Exemple #8
0
 CreateModuleAttribute(ApiModule apiModule, XTestStepValue wseTestStepValue)
 {
     return(apiModule.CreateModuleAttribute(
                "Endpoint",
                GetRefinedWseTestStepValue(wseTestStepValue.Value),
                GetRefinedWseTestStepValue(wseTestStepValue.Value),
                "Endpoint",
                "Endpoint",
                wseTestStepValue.ModuleAttribute.DefaultActionMode,
                wseTestStepValue.ModuleAttribute.DefaultDataType));
 }
Exemple #9
0
        private static void SetConstraintIndexProperty(XTestStepValue wseTestStepValue, XTestStepValue testStepValue)
        {
            string constraintIndex =
                wseTestStepValue.RelevantXParams.FirstOrDefault(x => x.Name == "ConstraintIndex")?.Value;

            if (!StringExtensions.IsNullOrBlankInTosca(constraintIndex))
            {
                testStepValue.ActionProperty = $"Index";
                testStepValue.Operator       = Operator.Equals;
                testStepValue.Value          = constraintIndex;
            }
        }
Exemple #10
0
        private string Parse(XTestStepValue root)
        {
            string payload = string.Empty;

            if (root == null)
            {
                return(payload);
            }
            XElement xmlStructure = XmlHelper.ConstructXmlStructure(root);

            xmlStructure = XmlHelper.RemoveNodeFromXml(xmlStructure, "Fault", "Body");
            payload      = Convert.ToString(xmlStructure);
            return(payload);
        }
 //Implement this for header
 private static void UpdateValueRange(XTestStepValue apiTeststepValue, string wseValue)
 {
     if (!String.IsNullOrEmpty(wseValue) && !apiTeststepValue.ModuleAttribute.ValueRange.Contains(wseValue))
     {
         if (!string.IsNullOrEmpty(apiTeststepValue.ModuleAttribute.ValueRange))
         {
             apiTeststepValue.ModuleAttribute.ValueRange =
                 $"{apiTeststepValue.ModuleAttribute.ValueRange};{Regex.Replace(wseValue, ";", @"\;")}";
         }
         else
         {
             apiTeststepValue.ModuleAttribute.ValueRange = Regex.Replace(wseValue, ";", @"\;");
         }
     }
 }
 CreateModuleAttribute(ApiModule apiModule, XTestStepValue wseTestStepValue)
 {
     return(apiModule.CreateModuleAttribute(
                "Method",
                HttpMethodExtension.ValueRangeString(),
                wseTestStepValue
                .ModuleAttribute.DefaultValue,
                "Method",
                "Method",
                wseTestStepValue
                .ModuleAttribute
                .DefaultActionMode,
                wseTestStepValue
                .ModuleAttribute
                .DefaultDataType));
 }
 /// <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));
 }
Exemple #14
0
        /// <summary>
        /// Extracts method from WSE TestStep
        /// </summary>
        /// <param name="xTestStep">WSE TestStep</param>
        /// <returns>HTTP Method</returns>
        public string Parse(XTestStep xTestStep)
        {
            try {
                XTestStepValue method =
                    (XTestStepValue)xTestStep.Search(AddOnConstants.TestStepMethodTql).FirstOrDefault();
                if (method == null)
                {
                    return(string.Empty);
                }
                return(method.Value);
            }
            catch (Exception ex) {
                FileLogger.Instance.Error(ex);
            }

            return(string.Empty);
        }
        /// <summary>
        /// Updates Value range of api module
        /// </summary>
        /// <param name="apiTeststepValue">value range to update in module attribute of apiTeststepValue</param>
        /// <param name="apiValue">value to set in Value range</param>
        /// <param name="wseValue">value to set in Value range in case of header</param>
        protected override void UpdateValueRange(XTestStepValue apiTeststepValue, string apiValue, string wseValue)
        {
            if (String.IsNullOrEmpty(apiTeststepValue.ModuleAttribute.ValueRange))
            {
                if (!String.IsNullOrEmpty(apiValue))
                {
                    apiTeststepValue.ModuleAttribute.ValueRange   = Regex.Replace(apiValue, ";", @"\;");
                    apiTeststepValue.ModuleAttribute.DefaultValue = Regex.Replace(apiValue, ";", @"\;");
                }

                UpdateValueRange(apiTeststepValue, wseValue);
            }
            else
            {
                UpdateValueRange(apiTeststepValue, wseValue);
            }
        }
        /// <summary>
        /// Creates Xml structure from Wse XTestStepValue for API Modules Payload section
        /// </summary>
        /// <param name="xTestStepValue">Wse XTestStepValues</param>
        /// <param name="xmlStructure">XElement used to create Payload Structure</param>
        /// <param name="parent">XElement used to identify and create parent nodes in xml structure </param>
        /// <returns>xml structure for API Modules Payload Section</returns>
        public static XElement ConstructXmlStructure(XTestStepValue xTestStepValue,
                                                     XElement xmlStructure = null,
                                                     XElement parent       = null)
        {
            XNamespace        xNamespace = GetNamespace(xTestStepValue.ModuleAttribute);
            List <XAttribute> xAttribute = GetXAttribute(xTestStepValue.ModuleAttribute);

            if (xmlStructure == null)
            {
                xmlStructure =
                    new XElement(xNamespace != null ? xNamespace + xTestStepValue.Name : xTestStepValue.Name,
                                 xAttribute,
                                 xTestStepValue.Value == "{NULL}" ? "" : xTestStepValue.Value);
                parent = xmlStructure;
            }
            else if (xmlStructure == parent)
            {
                parent = new XElement(
                    xNamespace != null ? xNamespace + xTestStepValue.Name : xTestStepValue.Name,
                    xAttribute,
                    xTestStepValue.Value == "{NULL}" ? "" : xTestStepValue.Value);
                xmlStructure.Add(parent);
            }
            else
            {
                var e = new XElement(
                    xNamespace != null ? xNamespace + xTestStepValue.Name : xTestStepValue.Name,
                    xAttribute,
                    xTestStepValue.Value == "{NULL}" ? "" : xTestStepValue.Value);
                parent?.Add(e);
                parent = e;
            }

            var childSubAttributes =
                xTestStepValue.SubValues;

            foreach (var childSubAttribute in childSubAttributes.Where(
                         x => x.ModuleAttribute.BusinessType == "XmlElement"))
            {
                xmlStructure = ConstructXmlStructure(childSubAttribute, xmlStructure, parent);
            }

            return(xmlStructure);
        }
        public void Execute(XTestStep apiTestStep, XTestStep wseTestStep)
        {
            try {
                Dictionary <string, string> testStepKeyValueList = GetWseTestStepValueAsKeyValPair(wseTestStep);
                if (!testStepKeyValueList.Any())
                {
                    return;
                }

                foreach (var wseTestStepValue in testStepKeyValueList)
                {
                    //Extract value need to be filled in api test step
                    string wseValue = wseTestStepValue.Value;
                    string apiValue = String.Empty;
                    //Note: we ignore this step in case of response.
                    if (!IsResponseTestStepValue)
                    {
                        //get api value
                        apiValue =
                            GetValueInApiModule(apiTestStep.Module as ApiModule, wseTestStepValue.Key);
                        //if values match,do nothing.

                        if (!Regex.IsMatch(wseValue, @"\{.*\}") &&
                            apiValue == CommonUtilities.RemoveExtraDoubleQuotes(wseValue))
                        {
                            return;
                        }
                    }

                    //if values does not match , Search if there is already a API xTestStepValue present.
                    XTestStepValue apiTeststepValue = GetOrCreateApiXTestStepValue(apiTestStep, wseTestStepValue);

                    //API xTestStepValue is present now. Assign Values to it now.
                    UpdateValueRange(apiTeststepValue, apiValue, wseValue);
                    apiTeststepValue.Value      = wseTestStepValue.Value;
                    apiTeststepValue.ActionMode =
                        IsResponseTestStepValue ? XTestStepActionMode.Verify : XTestStepActionMode.Insert;
                }
            }
            catch (Exception e) {
                FileLogger.Instance.Error("Multiple value setter failed", e);
            }
        }
        /// <summary>
        /// Gets Response Status Code from WSE TestStep
        /// </summary>
        /// <param name="xTestStep">WSE TestStep</param>
        /// <returns>Status code</returns>
        public string ParseResponseStatus(XTestStep xTestStep)
        {
            try {
                TCObject statusCodeModuleAttribute =
                    xTestStep.Search(AddOnConstants.TestStepResponseStatusTql)
                    .FirstOrDefault();
                if (statusCodeModuleAttribute == null)
                {
                    return(string.Empty);
                }

                XTestStepValue statusCodeXModuleAttribute = statusCodeModuleAttribute as XTestStepValue;
                return(statusCodeXModuleAttribute?.Value);
            }
            catch (Exception ex) {
                FileLogger.Instance.Error("Failed to retrieve response Status Code :", ex);
            }

            return(string.Empty);
        }
 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));
 }
        /// <summary>
        /// Returns Json path supported by Tosca for every field of payload from nodepath.
        /// </summary>
        /// <param name="rootObjectNodePath"> node path of root/main object</param>
        /// <param name="wseTestStepValue">test step value for which json path is to be evaluated</param>
        /// <param name="jsonPath">raw json path</param>
        /// <returns></returns>
        public string ExtractToscaJsonPath(string rootObjectNodePath,
                                           XTestStepValue wseTestStepValue,
                                           string jsonPath)
        {
            string nodePath = wseTestStepValue.NodePath;

            nodePath = nodePath.Replace(wseTestStepValue.ParentValue.NodePath, string.Empty);

            var name = wseTestStepValue.RelevantXParams.FirstOrDefault(x => x.Name == "Name");

            if (name?.Value != null && name.Value.EndsWith("*"))
            {
                nodePath = Regex.Replace(nodePath, @"/item#(\d*)$", Evaluator);
            }
            else
            {
                nodePath = Regex.Replace(nodePath, @"/item#(\d*)$", Evaluator2);
            }

            jsonPath = Regex.Replace(jsonPath, @"\[[\d | ""*""]*\]$", nodePath);

            return(jsonPath);
        }
Exemple #21
0
        /// <summary>
        /// Get Endpoint, Resource and Query Params from WSE XTestStep
        /// </summary>
        /// <param name="xTestStep"></param>
        /// <returns>AddressParserResult object which contains Endpoint, Resource and Query Params</returns>
        public AddressParserResult Parse(XTestStep xTestStep)
        {
            var addressParserResult = new AddressParserResult();

            try {
                XTestStepValue address = (XTestStepValue)
                                         xTestStep.Search(AddOnConstants.TestStepAddressValueTql).FirstOrDefault();
                if (address == null)
                {
                    return(addressParserResult);
                }
                if (string.IsNullOrEmpty(address.Value))
                {
                    return(addressParserResult);
                }
                ParseAddressInternal(addressParserResult, address.Value);
            }
            catch (Exception ex) {
                FileLogger.Instance.Error(ex);
            }

            return(addressParserResult);
        }
Exemple #22
0
        /// <summary>
        /// Gets headers from WSE XTestStep
        /// </summary>
        /// <param name="xTestStep">WSE XTestStep</param>
        /// <param name="tql">tql to get Header XTestStepValue from WSE XTestStep</param>
        /// <returns>All headers as a dictionary</returns>
        public Dictionary <string, string> Parse(XTestStep xTestStep, string tql)
        {
            var headersDict = new Dictionary <string, string>();

            try {
                List <TCObject> headers =
                    xTestStep.Search(tql);
                foreach (TCObject header in headers)
                {
                    XTestStepValue headerAttribute = (XTestStepValue)header;
                    if (string.IsNullOrEmpty(headerAttribute.Value))
                    {
                        continue;
                    }
                    headersDict.Add(headerAttribute.Name,
                                    CommonUtilities.RemoveExtraDoubleQuotes(headerAttribute.Value));
                }
            }
            catch (Exception) {
                // do nothing as this could happen possibly, just move on with the other attributes
            }

            return(headersDict);
        }
        public void CreateTestStepFromSET(string setName, Dictionary <string, TestStepValueData> testStepValues)
        {
            TestStepFolder testStepFolder = parentObject as TestStepFolder;

            if (testStepFolder == null)
            {
                throw new NullReferenceException("CurrentFolder is not set");
            }

            string   query    = "->PROJECT->AllOwnedSubItems=>SUBPARTS:XModule[SetWizard ==\"" + setName + "\"]";
            TCObject tcObject = testStepFolder.Search(query)[0];
            XModule  xModule  = tcObject as XModule;

            if (xModule == null)
            {
                return;
            }
            XTestStep testStep = testStepFolder.CreateXTestStepFromXModule(xModule);

            foreach (KeyValuePair <string, TestStepValueData> testStepValuePair in testStepValues)
            {
                foreach (XModuleAttribute xModuleAttribute in xModule.Attributes)
                {
                    if (xModuleAttribute.Name != testStepValuePair.Key)
                    {
                        continue;
                    }
                    XTestStepValue    testStepValue     = testStep.CreateXTestStepValue(xModuleAttribute);
                    TestStepValueData testStepValueData = testStepValuePair.Value;

                    testStepValue.Value = testStepValueData.Value;

                    testStepValue.ActionMode = ConvertActionMode(testStepValueData.ActionMode);
                }
            }
        }
        public void Execute(XTestStep apiTestStep, XTestStep wseTestStep)
        {
            try {
                //Get Raw Value
                XTestStepValue wseTestStepValue =
                    (XTestStepValue)wseTestStep.Search(TqlToGetWseTestStepValue).FirstOrDefault();
                if (wseTestStepValue == null)
                {
                    return;
                }

                //Extract value need to be filled in api test step
                string wseValue = GetRefinedWseTestStepValue(wseTestStepValue.Value);

                //Note: we ignore this step in case of response.
                if (!IsResponseTestStepValue)
                {
                    //get api value
                    string apiValue = GetValueInApiModule(apiTestStep.Module as ApiModule);
                    //if values match,do nothing.
                    if (!Regex.IsMatch(wseValue, @"\{.*\}") && apiValue == wseValue)
                    {
                        return;
                    }
                }

                //if values does not match , Search if there is already a API xTestStepValue present.
                XTestStepValue apiTeststepValue =
                    (XTestStepValue)apiTestStep.Search(TqlToGetApiTestStepValue).FirstOrDefault();

                //if xTestStepValue not present,create it.
                if (apiTeststepValue == null)
                {
                    //check if module attribute is present.
                    var xModuleAttribute =
                        (XModuleAttribute)apiTestStep
                        .Module.Search(TqlToGetModuleAttributeInApiModule).FirstOrDefault();
                    //if not present, Create it.
                    if (xModuleAttribute == null)
                    {
                        XModuleAttribute m =
                            CreateModuleAttribute(apiTestStep.Module as ApiModule, wseTestStepValue);
                        apiTeststepValue = apiTestStep.CreateXTestStepValue(m);
                    }
                    //if already present, use it.
                    else
                    {
                        apiTeststepValue = apiTestStep.CreateXTestStepValue(xModuleAttribute);
                    }
                }

                //API xTestStepValue is present now. Assign Values to it now.
                apiTeststepValue.Disabled   = wseTestStepValue.Disabled;
                apiTeststepValue.Value      = wseValue;
                apiTeststepValue.ActionMode = wseTestStepValue.ActionMode;
                apiTeststepValue.Condition  = wseTestStepValue.Condition;
                apiTeststepValue.Path       = wseTestStepValue.Path;
            }
            catch (Exception e) {
                FileLogger.Instance.Error("Setting value failed : ", e);
            }
        }
Exemple #25
0
        public override TCObject Execute(TCObject objectToExecuteOn, TCAddOnTaskContext taskContext)
        {
            //ITestDataHandler testDataHandler = new TestDataHandler.ToscaTestDataHandler(objectToExecuteOn);
            //AssistantMain assistant = new AssistantMain(testDataHandler);
            //assistant.StartMainWindow();


            //string toscahome = Path.GetFullPath(Environment.GetEnvironmentVariable("TRICENTIS_HOME"));

            System.Diagnostics.Process.Start("c:\\Temp\\ToscaAssistant.exe");


            var currentTescase = objectToExecuteOn as TestCase;
            var folder         = objectToExecuteOn as TCFolder;

            Thread.Sleep(5000);

            if (folder != null && folder.Name == "Modules")
            {
                XModule xModuleHome    = folder.CreateXModule();
                XModule xModuleManuals = folder.CreateXModule();

                xModuleHome.Name    = "Home";
                xModuleManuals.Name = "Manuals";

                return(null);
            }


            var     query   = "->PROJECT->AllOwnedSubItems=>SUBPARTS: XModule[SetWizard == \"File\"]";
            XModule xModule = objectToExecuteOn.Search(query)[0] as XModule;

            var currentTestStep = currentTescase.CreateXTestStepFromXModule(xModule);

            foreach (var testValue in currentTestStep.TestStepValues)
            {
                if (testValue.Name == "Directory")
                {
                    testValue.Value = "C:\\GIG";
                }


                if (testValue.Name == "File")
                {
                    testValue.Value = "createdFile.txt";
                }


                if (testValue.Name == "Text")
                {
                    testValue.Value = "Usability";
                }
            }

            foreach (var attribute in xModule.Attributes)
            {
                if (attribute.Name == "Encoding")
                {
                    XTestStepValue testStepValue = currentTestStep.CreateXTestStepValue(attribute);
                    testStepValue.Value = "UTF-8";
                }

                if (attribute.Name == "Overwrite")
                {
                    XTestStepValue testStepValue = currentTestStep.CreateXTestStepValue(attribute);
                    testStepValue.Value = "True";
                }
            }



            return(null);
        }
Exemple #26
0
 protected override void UpdateValueRange(XTestStepValue apiTeststepValue, string apiValue, string wseValue)
 {
 }
Exemple #27
0
        /// <summary>
        /// Creates and set module attributes at module and teststep
        /// </summary>
        /// <param name="wseTestStepValue">TestStepValues of WSE Teststep</param>
        /// <param name="tcPath">XPath and JsonPath for xml and Json respectively</param>
        /// <param name="xModule">xModule and xModuleAttribute of ApiEngine</param>
        /// <param name="xModuleDemo">ApiModule</param>
        /// <param name="parameterPathType">Enum which define creation of xml and json moduleattributes</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>
        public static XTestStepValue CreateBusinessParameterInTosca(XTestStepValue wseTestStepValue,
                                                                    string tcPath,
                                                                    dynamic xModule,
                                                                    ApiModule xModuleDemo,
                                                                    BusinessParameterPathTypes parameterPathType,
                                                                    dynamic parentTest,
                                                                    string cardinality,
                                                                    bool isArray)
        {
            string businessParameterName  = wseTestStepValue.Name;
            string businessParameterValue = wseTestStepValue.Value == "{NULL}" ? string.Empty : wseTestStepValue.Value;
            XTestStepActionMode     xTestStepActionMode = wseTestStepValue.ActionModeToUse;
            ModuleAttributeDataType attributeDataType   = wseTestStepValue.DataType;

            var mAttributes = xModuleDemo.Search("=>SUBPARTS:XModuleAttribute").Cast <XModuleAttribute>();

            XModuleAttribute xModuleAttribute = GetExistingXModuleAttribute(mAttributes, tcPath, parameterPathType);

            if (xModuleAttribute != null)
            {
                if (!string.IsNullOrEmpty(xModuleAttribute.ValueRange))
                {
                    if (!xModuleAttribute.ValueRange.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
                        .Contains(businessParameterValue))
                    {
                        xModuleAttribute.ValueRange =
                            $"{xModuleAttribute.ValueRange};{businessParameterValue}";
                    }
                }
                else
                {
                    xModuleAttribute.ValueRange =
                        $"{businessParameterValue}";
                }
            }
            else
            {
                xModuleAttribute      = xModule.CreateModuleAttribute();
                xModuleAttribute.Name = businessParameterName;
                xModuleAttribute.AddXParamToModuleAttribute("PathType",
                                                            parameterPathType == BusinessParameterPathTypes.XPATH
                                                                    ? "XPath"
                                                                    : parameterPathType
                                                            == BusinessParameterPathTypes.JSONPATH
                                                                            ? "JsonPath"
                                                                            : "",
                                                            ParamTypeE.TechnicalID);
                xModuleAttribute.AddXParamToModuleAttribute("Path",
                                                            tcPath,
                                                            ParamTypeE.TechnicalID);
                xModuleAttribute.AddXParamToModuleAttribute("ExplicitName",
                                                            "True",
                                                            ParamTypeE.Configuration);
                xModuleAttribute.DefaultActionMode = xTestStepActionMode;
                xModuleAttribute.DefaultDataType   = wseTestStepValue.ModuleAttribute.DefaultDataType;
                xModuleAttribute.DefaultValue      = wseTestStepValue.ModuleAttribute?.DefaultValue == "{NULL}"
                                                        ? string.Empty
                                                        : wseTestStepValue.ModuleAttribute?.DefaultValue;
                xModuleAttribute.ValueRange  = $"{businessParameterValue}";
                xModuleAttribute.Cardinality = isArray ? "0-N" : cardinality;
                xModuleAttribute.EnsureUniqueName();
            }

            XTestStepValue testStepValue = parentTest.CreateXTestStepValue(xModuleAttribute);

            testStepValue.ActionProperty = wseTestStepValue.ActionProperty;
            testStepValue.Operator       = wseTestStepValue.Operator;
            testStepValue.Value          = wseTestStepValue.Value;
            testStepValue.ActionMode     = xTestStepActionMode;
            testStepValue.DataType       = attributeDataType;
            testStepValue.Disabled       = wseTestStepValue.Disabled;
            SetConstraintIndexProperty(wseTestStepValue, testStepValue);
            return(testStepValue);
        }
 protected abstract XModuleAttribute CreateModuleAttribute(ApiModule apiModule, XTestStepValue wseTestStepValue);
 public override string GetJsonPath(XTestStep wseTestStep, XTestStepValue wseTestStepValue, string jsonPath)
 {
     return(jsonPath);
 }
 protected abstract void UpdateValueRange(XTestStepValue apiTeststepValue, string apiValue, string wseValue);