private void CalculateARC(ActReturnValue ARC)
{
// We do only simple calculation not including BF or proj env params so it will work
ARC.ExpectedCalculated = ARC.Expected;
GingerRunner.ReplaceActualPlaceHolder(ARC);
GingerRunner.CalculateARCStatus(ARC);
}
public void CleanUpActivityShouldExecuteWhenNonMandatoryActivityFails()
{
BusinessFlow businessFlow = CreateBusinessFlow();
ActReturnValue returnValue = new ActReturnValue();
returnValue.Active = true;
returnValue.mExpected = "2";
returnValue.Operator = Amdocs.Ginger.Common.Expressions.eOperator.Equals;
businessFlow.Activities[1].Acts[0].ActReturnValues.Add(returnValue);
mGR.Executor.BusinessFlows.Add(businessFlow);
Context context1 = new Context();
context1.BusinessFlow = businessFlow;
context1.Activity = businessFlow.Activities[0];
mGR.Executor.CurrentBusinessFlow = businessFlow;
mGR.Executor.CurrentBusinessFlow.CurrentActivity = businessFlow.Activities[0];
mGR.Executor.Context = context1;
//Act
mGR.Executor.RunBusinessFlow(businessFlow);
Assert.AreEqual(eRunStatus.Failed, businessFlow.RunStatus, "Business Flow Status");
Assert.AreEqual(eRunStatus.Passed, businessFlow.Activities[0].Status, "Activity 1 Status");
Assert.AreEqual(eRunStatus.Failed, businessFlow.Activities[1].Status, "Not mandatory Activity 2 Status should be failed");
Assert.AreEqual(eRunStatus.Passed, businessFlow.Activities[2].Status, "Activity 3 Status");
Assert.AreEqual(eRunStatus.Passed, businessFlow.Activities[3].Status, "Clean Up Activity should execute");
}
public void DifferenVarsUsedInSeveralPlaces()
{
//Arrange
Activity a1 = new Activity()
{
ActivityName = "a1"
};
ActDummy act1 = new ActDummy();
ActReturnValue actReturnValue = new ActReturnValue()
{
Param = "out1", StoreToValue = "v1"
};
act1.ReturnValues.Add(actReturnValue);
FlowControl flowControl = new FlowControl()
{
Condition = "{Var Name=v2}=123"
};
act1.FlowControls.Add(flowControl);
a1.Acts.Add(act1);
//Act
List <string> usedVars = new List <string>();
VariableBase.GetListOfUsedVariables(a1, ref usedVars);
//Assert
Assert.AreEqual(2, usedVars.Count, "usedVars.Count");
Assert.IsTrue(usedVars.Contains("v1"), "usedVars.Contains 'v1'");
Assert.IsTrue(usedVars.Contains("v2"), "usedVars.Contains 'v2'");
}
private void AddActReturnValue(ActReturnValue ARV)
{
WriteLine("if (!actual.Equels(" + VE(ARV.Expected) + "))");
OpenBrackets();
WriteLine(Missing + " Mark step as failed - throw");
CloseBrackets();
}
public void UsedVarInActionOutoutStoreToVar()
{
//Arrange
Activity a1 = new Activity()
{
ActivityName = "a1"
};
ActDummy act1 = new ActDummy();
ActReturnValue actReturnValue = new ActReturnValue()
{
Param = "out1", StoreToValue = "v1"
};
act1.ReturnValues.Add(actReturnValue);
a1.Acts.Add(act1);
//Act
List <string> usedVars = new List <string>();
VariableBase.GetListOfUsedVariables(a1, ref usedVars);
//Assert
Assert.AreEqual(1, usedVars.Count, "usedVars.Count");
Assert.AreEqual("v1", usedVars[0], "usedVars[0]=v1");
}
public void TestActionLog_InputAndReturnValues()
{
//Arrange
string fileName = TestResources.GetTempFile("ActionLog\\ActionLogTest_4.log");
GingerRunnerLogger gingerRunnerLogger = new GingerRunnerLogger(fileName);
ActDummy actDummy = new ActDummy();
// set all the values in the action
ActInputValue actInputValue = new ActInputValue();
actInputValue.ItemName = "TestInput";
actInputValue.Value = INP_VAL_EXPECTED;
actDummy.InputValues.Add(actInputValue);
ActReturnValue actReturnValue = new ActReturnValue();
actReturnValue.ItemName = "TestReturn";
actReturnValue.Expected = RET_VAL_EXPECTED;
actReturnValue.Actual = RET_VAL_EXPECTED;
actDummy.ReturnValues.Add(actReturnValue);
actDummy.ActionLogConfig = new ActionLogConfig();
actDummy.ActionLogConfig.LogInputVariables = true;
actDummy.ActionLogConfig.LogOutputVariables = true;
actDummy.EnableActionLogConfig = true;
//Act
gingerRunnerLogger.LogAction(actDummy);
//Assert
Assert.IsTrue(IsFileContains(fileName, INP_VAL_EXPECTED));
Assert.IsTrue(IsFileContains(fileName, RET_VAL_EXPECTED));
}
public void ValidateOutPutValidationPostFixeValues()
{
ABF.FixItHandler.Invoke(ABF, null);
var ReturnValues = ABF.ReturnValues;
ActReturnValue ARV1 = ReturnValues.Where(x => x.Param.Equals("Value1")).FirstOrDefault();
Assert.AreEqual(Amdocs.Ginger.Common.Expressions.eOperator.Equals, ARV1.Operator);
ActReturnValue ARV2 = ReturnValues.Where(x => x.Param.Equals("Value2")).FirstOrDefault();
Assert.AreEqual(Amdocs.Ginger.Common.Expressions.eOperator.Legacy, ARV2.Operator);
ActReturnValue ARV3 = ReturnValues.Where(x => x.Param.Equals("Value3")).FirstOrDefault();
Assert.AreEqual(Amdocs.Ginger.Common.Expressions.eOperator.Legacy, ARV3.Operator);
ActReturnValue ARV4 = ReturnValues.Where(x => x.Param.Equals("Value4")).FirstOrDefault();
Assert.AreEqual(Amdocs.Ginger.Common.Expressions.eOperator.Legacy, ARV4.Operator);
ActReturnValue ARV5 = ReturnValues.Where(x => x.Param.Equals("Value5")).FirstOrDefault();
Assert.AreEqual(Amdocs.Ginger.Common.Expressions.eOperator.Equals, ARV5.Operator);
}
public void TestActionLog_ReturnValues()
{
//Arrange
string fileName = TestResources.GetTempFile("ActionLog\\ActionLogTest_3.log");
GingerRunnerLogger gingerRunnerLogger = new GingerRunnerLogger(fileName);
ActDummy actDummy = new ActDummy();
// set all the return values in the action
ActReturnValue actReturnValue = new ActReturnValue();
actReturnValue.ItemName = "TestReturn";
actReturnValue.Expected = RET_VAL_EXPECTED;
actReturnValue.Actual = RET_VAL_EXPECTED;
actDummy.ReturnValues.Add(actReturnValue);
actDummy.ActionLogConfig = new ActionLogConfig();
actDummy.ActionLogConfig.LogOutputVariables = true;
actDummy.EnableActionLogConfig = true;
//Act
gingerRunnerLogger.LogAction(actDummy);
//Assert
Assert.AreEqual(FindTextOccurrencesInFile(fileName, RET_VAL_EXPECTED), 2);
}
public override void Execute()
{
mJavaApplicationProcessID = -1;
//calculate the arguments
if (!CalculateArguments())
{
return;
}
//validate the arguments
if (!ValidateArguments())
{
return;
}
if (mLaunchJavaApplication)
{
if (!PerformLaunchJavaApplication())
{
return;
}
}
if (mLaunchWithAgent)
{
//For Parallel execution, we want attach to be synchronized.
//So for windows with same title, correct process id will be calculated
lock (syncLock)
{
mProcessIDForAttach = -1;
if (!PerformAttachGingerAgent())
{
return;
}
if (mPort_Calc.Equals(Fields.DynamicPortPlaceHolder) &&
portValueAutoResetEvent != null)
{
portValueAutoResetEvent.WaitOne(TimeSpan.FromSeconds(10));
}
AddOrUpdateReturnParamActual("Port", mPort_Calc);
}
}
//Changing the existing param namefrom "Actual" to "Process ID", it Param "Actual" exist, to support Return params configured on old version
ActReturnValue ARC = (from arc in ReturnValues where arc.Param == "Actual" select arc).FirstOrDefault();
if (ARC != null)
{
ARC.Param = "Process ID";
ARC.ParamCalculated = "Process ID";
}
AddOrUpdateReturnParamActual("Process ID", "" + mProcessIDForAttach);
}
private void GenerateResponse(SwaggerOperation operation, ApplicationAPIModel basicModal)
{
if (operation.Responses.Count > 0 && operation.Responses.Keys.Where(x => x.StartsWith("2")).Count() > 0)
{
//handling only the first sucess response code need to be improved
//as discussed, for now handling response for only success
string sucesskey = operation.Responses.Keys.Where(x => x.StartsWith("2")).ElementAt(0);
SwaggerResponse response = null;
operation.Responses.TryGetValue(sucesskey, out response);
if (response != null && response.Schema == null)
{
if (response.Reference != null && response.Reference is SwaggerResponse)
{
response = response.Reference;
}
}
if (response.Schema != null)
{
var schemaObj = response.Schema;
if (response.Schema.HasReference && response.Schema.Reference != null)
{
schemaObj = response.Schema.Reference;
}
if (basicModal.ContentType == ApplicationAPIUtils.eContentType.XML)
{
ApplicationAPIModel JsonResponseModel = new ApplicationAPIModel();
var i = GenerateXMLBody(JsonResponseModel, schemaObj);
foreach (AppModelParameter currModel in GenerateJsonBody(JsonResponseModel, schemaObj))
{
ActReturnValue arv = new ActReturnValue();
arv.ItemName = currModel.ItemName;
arv.Path = currModel.XPath;
arv.DoNotConsiderAsTemp = true;
basicModal.ReturnValues.Add(arv);
}
}
else if (basicModal.ContentType == ApplicationAPIUtils.eContentType.JSon)
{
ApplicationAPIModel JsonResponseModel = new ApplicationAPIModel();
var i = GenerateJsonBody(JsonResponseModel, schemaObj);
foreach (AppModelParameter currModel in GenerateJsonBody(JsonResponseModel, schemaObj))
{
ActReturnValue arv = new ActReturnValue();
arv.ItemName = currModel.ItemName;
arv.Path = currModel.XPath;
arv.DoNotConsiderAsTemp = true;
basicModal.ReturnValues.Add(arv);
}
}
}
}
}
public void SimulatedOutputWithVETest()
{
Activity Activity2 = new Activity();
Activity2.Active = true;
Activity2.ActivityName = "Web API REST with VE";
Activity2.CurrentAgent = wsAgent;
mBF.Activities.Add(Activity2);
ActWebAPIRest restAct = new ActWebAPIRest();
restAct.AddOrUpdateInputParamValue(ActWebAPIBase.Fields.EndPointURL, "https://jsonplaceholder.typicode.com/posts/1");
restAct.AddOrUpdateInputParamValue(ActWebAPIBase.Fields.CertificateTypeRadioButton, ApplicationAPIUtils.eCretificateType.AllSSL.ToString());
restAct.AddOrUpdateInputParamValue(ActWebAPIRest.Fields.RequestType, ApplicationAPIUtils.eRequestType.GET.ToString());
restAct.AddOrUpdateInputParamValue(ActWebAPIRest.Fields.ContentType, ApplicationAPIUtils.eContentType.JSon.ToString());
restAct.AddOrUpdateInputParamValue(ActWebAPIRest.Fields.ResponseContentType, ApplicationAPIUtils.eContentType.JSon.ToString());
restAct.Active = true;
restAct.EnableRetryMechanism = false;
restAct.ItemName = "Web API REST Simulated Output VE";
restAct.SupportSimulation = true;
ActReturnValue simulateOutput = new ActReturnValue();
simulateOutput.Active = true;
simulateOutput.Param = "TestSimulation";
ValueExpression testVE = new ValueExpression(null, mBF);
testVE.Value = "simulated VE";
simulateOutput.SimulatedActual = testVE.Value;
mBF.Activities[0].Acts.Add(restAct);
mDriver.StartDriver();
mGR.RunRunner();
if (restAct.ReturnValues.Count > 0)
{
foreach (ActReturnValue val in restAct.ReturnValues)
{
if ((val.SimulatedActual != null) && (val.Actual != val.SimulatedActual))
{
if (val.Actual.ToString() == "simulated VE")
{
Assert.AreEqual(val.Actual, "simulated VE");
}
}
if ((val.SimulatedActual != null) && (val.Actual == val.SimulatedActual))
{
Assert.Fail();
}
}
}
}
public override void CalculateModelParameterExpectedValue(ActReturnValue actReturnValue)
{
if (actReturnValue.ExpectedCalculated.Contains("AppModelParam"))
{
List <AppModelParameter> usedParams = ActAppModelParameters.Where(x => actReturnValue.ExpectedCalculated.Contains(x.PlaceHolder)).ToList();
foreach (AppModelParameter param in usedParams)
{
actReturnValue.ExpectedCalculated = actReturnValue.ExpectedCalculated.Replace(("{AppModelParam Name = " + param.PlaceHolder + "}"), param.ExecutionValue);
}
}
}
public UCStoreTo()
{
ActReturnValue actR = new ActReturnValue();
InitializeComponent();
mLabel = ActReturnValue.eStoreTo.Variable.ToString();
GingerCore.General.FillComboItemsFromEnumType(cmbStoreTo, actR.StoreTo.GetType());
if (WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <DataSourceBase>().Count == 0)
{
GingerCore.General.DisableComboItem(cmbStoreTo, ActReturnValue.eStoreTo.DataSource);
DSConfig.IsEnabled = false;
}
}
Act IObsoleteAction.GetNewAction()
{
AutoMapper.MapperConfiguration mapConfigUIElement = new AutoMapper.MapperConfiguration(cfg => { cfg.CreateMap <Act, ActWebAPIRest>(); });
ActWebAPIRest convertedActWebAPIRest = mapConfigUIElement.CreateMapper().Map <Act, ActWebAPIRest>(this);
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.DoNotFailActionOnBadRespose, Convert.ToString(this.DoNotFailActionOnBadRespose));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.UseLegacyJSONParsing, Convert.ToString(this.UseLegacyJSONParsing));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLDomain, this.URLDomain.Value);
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLUser, this.URLUser.Value);
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLPass, this.URLPass.Value);
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.SecurityType, Convert.ToString(this.SecurityType));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.RequestType, Convert.ToString(this.RequestType));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.ResponseContentType, Convert.ToString(this.ResponseContentType));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.CookieMode, Convert.ToString(this.CookieMode));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.ContentType, Convert.ToString(this.ContentType));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.ReqHttpVersion, Convert.ToString(this.ReqHttpVersion));
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.AuthorizationType, ApplicationAPIUtils.eAuthType.NoAuthentication.ToString());
if (this.UseTemplateFile)
{
//Note:Don't confuse with field names. Use Template file is binded to Free text radio button in old Rest Action.
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.RequestBodyTypeRadioButton, ApplicationAPIUtils.eRequestBodyType.FreeText.ToString());
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.RequestBody, this.RequestBody.Value);
}
else if (this.UseRequestBody)
{
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.RequestBodyTypeRadioButton, ApplicationAPIUtils.eRequestBodyType.TemplateFile.ToString());
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.TemplateFileNameFileBrowser, this.TemplateFile.Value);
}
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.CertificateTypeRadioButton, ApplicationAPIUtils.eCretificateType.AllSSL.ToString());
convertedActWebAPIRest.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.NetworkCredentialsRadioButton, ApplicationAPIUtils.eNetworkCredentials.Default.ToString());
convertedActWebAPIRest.DynamicElements = this.DynamicElements;
convertedActWebAPIRest.HttpHeaders = this.HttpHeaders;
if (convertedActWebAPIRest.ReturnValues != null && convertedActWebAPIRest.ReturnValues.Count != 0)
{
//Old rest action add response as --> Respose
//And new adds it as Response:
// so we update it when converting from old action to new
ActReturnValue ARC = convertedActWebAPIRest.ReturnValues.Where(x => x.Param == "Respose").FirstOrDefault();
if (ARC != null)
{
ARC.Param = "Response:";
}
}
return(convertedActWebAPIRest);
}
Act IObsoleteAction.GetNewAction()
{
AutoMapper.MapperConfiguration mapperConfiguration = new AutoMapper.MapperConfiguration(cfg => { cfg.CreateMap <Act, ActWebAPISoap>(); });
ActWebAPISoap convertedActWebAPISoap = mapperConfiguration.CreateMapper().Map <Act, ActWebAPISoap>(this);
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.EndPointURL, this.URL.Value);
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.AuthorizationType, ApplicationAPIUtils.eAuthType.NoAuthentication.ToString());
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.SecurityType, ApplicationAPIUtils.eSercurityType.None.ToString());
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.CertificateTypeRadioButton, ApplicationAPIUtils.eCretificateType.AllSSL.ToString());
if (!string.IsNullOrEmpty(this.URLDomain.Value) || (!string.IsNullOrEmpty(this.URLUser.Value) && !string.IsNullOrEmpty(this.URLPass.Value)))
{
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.NetworkCredentialsRadioButton, ApplicationAPIUtils.eNetworkCredentials.Custom.ToString());
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLDomain, this.URLDomain.Value);
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLUser, this.URLUser.Value);
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLPass, this.URLPass.Value);
}
else
{
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.NetworkCredentialsRadioButton, ApplicationAPIUtils.eNetworkCredentials.Default.ToString());
}
if (!string.IsNullOrEmpty(this.XMLfileName.ToString()))
{
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.RequestBodyTypeRadioButton, ApplicationAPIUtils.eRequestBodyType.TemplateFile.ToString());
convertedActWebAPISoap.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.TemplateFileNameFileBrowser, this.XMLfileName.Value);
}
if (convertedActWebAPISoap.ReturnValues != null && convertedActWebAPISoap.ReturnValues.Count != 0)
{
//Old web service action add response as --> FullReponseXML
//And new adds it as Response:
// so we update it when converting from old action to new
ActReturnValue ARC = convertedActWebAPISoap.ReturnValues.Where(x => x.Param == "FullReponseXML").FirstOrDefault();
if (ARC != null)
{
ARC.Param = "Response:";
if (!string.IsNullOrEmpty(ARC.Expected))
{
ARC.Expected = XMLDocExtended.PrettyXml(ARC.Expected);
}
}
}
convertedActWebAPISoap.DynamicElements = this.DynamicXMLElements;
return(convertedActWebAPISoap);
}
public void ExpectedActulWithOrNumbers()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "7";
ARC.Expected = "{Actual}=3 or {Actual}=7";
//Act
CalculateARC(ARC);
//Assert
Assert.AreEqual(ARC.ExpectedCalculated, "'7=3 or 7=7' is True");
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Passed);
}
private static void DeleteOldReturnValuesInAction(Act act, ApplicationModelBase apiModel)
{
for (int index = 0; index < act.ReturnValues.Count; index++)
{
if (act.ReturnValues[index].AddedAutomatically == true)
{
ActReturnValue apiARV = apiModel.ReturnValues.Where(x => x.Guid == act.ReturnValues[index].Guid).FirstOrDefault();
if (apiARV == null) //Output value deleted from API - delete it also from action
{
act.ReturnValues.RemoveAt(index);
index--;
}
}
}
}
private static void AddNewActReturnValue(Act act, ActReturnValue apiARV)
{
ActReturnValue newARV = new ActReturnValue();
newARV.AddedAutomatically = true;
newARV.Status = ActReturnValue.eStatus.Pending;
newARV.Guid = apiARV.Guid;
newARV.Active = apiARV.Active;
newARV.ItemName = apiARV.ItemName;
newARV.Path = apiARV.Path;
newARV.Expected = apiARV.Expected;
newARV.StoreTo = apiARV.StoreTo;
newARV.SimulatedActual = apiARV.SimulatedActual;
act.ActReturnValues.Add(newARV);
}
public static void ClassInitialize(TestContext testContext)
{
BF = new BusinessFlow("BF1");
act = new ActDummy();
ARC = new ActReturnValue();
ARC.Param = "Test";
ARC.Active = true;
act.Active = true;
act.AddNewReturnParams = true;
act.SupportSimulation = true;
mGingerRunner = new GingerRunner();
mGingerRunner.RunInSimulationMode = true;
BF.Activities[0].Acts.Add(act);
mGingerRunner.BusinessFlows.Add(BF);
}
public void CheckforStartingwithNot()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "Not Tough";
ARC.Expected = "Not Tough";
//Act
CalculateARC(ARC);
//Assert
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Passed);
}
public void ExpectedActualGreaterThanNumber()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "5";
ARC.Expected = "{Actual} > 0";
//Act
CalculateARC(ARC);
//Assert
Assert.AreEqual(ARC.ExpectedCalculated, "'5 > 0' is True");
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Passed);
}
public void ExpectedActualLowerThanNumberIsFalse()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "11";
ARC.Expected = "{Actual} < 10";
//Act
CalculateARC(ARC);
//Assert
Assert.AreEqual(ARC.ExpectedCalculated, "'11 < 10' is False");
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Failed);
}
public void ExpectedActulContainsString()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "Hello World!";
ARC.Expected = "InStr({Actual},\"Hello\")>0";
//Act
CalculateARC(ARC);
//Assert
Assert.AreEqual(ARC.ExpectedCalculated, "'InStr(\"Hello World!\",\"Hello\")>0' is True");
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Passed);
}
public void ExpectedActulContainsStringIsFalse()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "ABCDE";
ARC.Expected = "InStr({Actual},\"ZZZ\") > 0";
//Act
CalculateARC(ARC);
//Assert
Assert.AreEqual(ARC.ExpectedCalculated, "'InStr(\"ABCDE\",\"ZZZ\") > 0' is False");
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Failed);
}
public void ExpectedIsSimpleString()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "ABC";
ARC.Expected = "ABC";
//Act
CalculateARC(ARC);
//Assert
Assert.AreEqual(ARC.ExpectedCalculated, "ABC");
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Passed);
}
private static void UpdateAllReturnValuesInAction(Act act, ApplicationModelBase apiModel, ModelItemUsage usage)
{
ActReturnValue.eItemParts ePartToUpdate = (ActReturnValue.eItemParts)Enum.Parse(typeof(ActReturnValue.eItemParts), usage.SelectedItemPart);
foreach (ActReturnValue apiARV in apiModel.ReturnValues)
{
ActReturnValue actARV = act.ActReturnValues.Where(x => x.Guid == apiARV.Guid).FirstOrDefault();
if (actARV != null) //Exist already in the action - Update it
{
actARV.Active = apiARV.Active;
actARV.Status = ActReturnValue.eStatus.Pending;
if (ePartToUpdate == ActReturnValue.eItemParts.ExpectedValue || ePartToUpdate == ActReturnValue.eItemParts.All)
{
actARV.Expected = apiARV.Expected;
}
if (ePartToUpdate == ActReturnValue.eItemParts.Parameter || ePartToUpdate == ActReturnValue.eItemParts.All)
{
actARV.ItemName = apiARV.ItemName;
}
if (ePartToUpdate == ActReturnValue.eItemParts.Path || ePartToUpdate == ActReturnValue.eItemParts.All)
{
actARV.Path = apiARV.Path;
}
if (ePartToUpdate == ActReturnValue.eItemParts.SimulatedActual || ePartToUpdate == ActReturnValue.eItemParts.All)
{
actARV.SimulatedActual = apiARV.SimulatedActual;
}
if (ePartToUpdate == ActReturnValue.eItemParts.StoreTo || ePartToUpdate == ActReturnValue.eItemParts.All)
{
if (!string.IsNullOrEmpty(apiARV.StoreToValue))
{
actARV.StoreTo = ActReturnValue.eStoreTo.ApplicationModelParameter;
actARV.StoreToValue = apiARV.StoreToValue;
}
}
usage.Status = ModelItemUsage.eStatus.Updated;
}
else //Not exist in the action - add it
{
if (!string.IsNullOrEmpty(apiARV.StoreToValue))
{
apiARV.StoreTo = ActReturnValue.eStoreTo.ApplicationModelParameter;
}
AddNewActReturnValue(act, apiARV);
}
}
}
public void TextFileReadTest()
{
//Arrange
actReadTextFile.TextToWrite = txt;
actReadTextFile.TextFilePath = TestResources.GetTestResourcesFile(@"TextFiles" + Path.DirectorySeparatorChar + "textFileOperations.txt");
actReadTextFile.ValueExpression = new ValueExpression(actReadTextFile, "");
//Act
actReadTextFile.TextFileEncoding = ActReadTextFile.eTextFileEncodings.UTF8;
File.WriteAllText(actReadTextFile.TextFilePath, txt);
ExecuteActionOperation(actReadTextFile, ActReadTextFile.eTextFileActionMode.Read, true, true);
ActReturnValue returnValue = (ActReturnValue)actReadTextFile.ActReturnValues.ListItems.Find(x => (x as ActReturnValue).ItemName.Equals("File Content"));
//Assert
Assert.AreEqual(returnValue.Actual, txt);
}
public void ExpectedActulWithOrNumbersANDCond()
{
//Arrange
ActReturnValue ARC = new ActReturnValue();
ARC.Actual = "5";
ARC.Expected = "{Actual}=1 or {Actual}=5";
//Act
CalculateARC(ARC);
string Exp = ARC.Expected.Replace("{Actual}", ARC.Actual);
//Assert
Assert.AreEqual(ARC.ExpectedCalculated, "'" + Exp + "' is True");
Assert.AreEqual(ARC.Status, ActReturnValue.eStatus.Passed);
}
public void SimulatedOutputTest()
{
Activity Activity3 = new Activity();
Activity3.Active = true;
Activity3.ActivityName = "Web API REST Simulated Output";
Activity3.CurrentAgent = wsAgent;
mBF.Activities.Add(Activity3);
ActWebAPIRest restAct = new ActWebAPIRest();
restAct.AddOrUpdateInputParamValue(ActWebAPIBase.Fields.EndPointURL, "https://jsonplaceholder.typicode.com/posts/1");
restAct.AddOrUpdateInputParamValue(ActWebAPIBase.Fields.CertificateTypeRadioButton, ApplicationAPIUtils.eCretificateType.AllSSL.ToString());
restAct.AddOrUpdateInputParamValue(ActWebAPIRest.Fields.RequestType, ApplicationAPIUtils.eRequestType.GET.ToString());
restAct.AddOrUpdateInputParamValue(ActWebAPIRest.Fields.ContentType, ApplicationAPIUtils.eContentType.JSon.ToString());
restAct.AddOrUpdateInputParamValue(ActWebAPIRest.Fields.ResponseContentType, ApplicationAPIUtils.eContentType.JSon.ToString());
restAct.Active = true;
restAct.EnableRetryMechanism = false;
restAct.ItemName = "Web API REST Simulated Output";
restAct.SupportSimulation = true;
//Define dummy return value
ActReturnValue simulateOutput = new ActReturnValue();
simulateOutput.Active = true;
simulateOutput.Param = "TestSimulation";
simulateOutput.SimulatedActual = "simulated ok";
simulateOutput.Expected = "simulated ok";
restAct.ReturnValues.Add(simulateOutput);
mBF.Activities[0].Acts.Add(restAct);
mGR.RunInSimulationMode = true;
mGR.RunRunner();
if (restAct.ReturnValues[0].SimulatedActual == restAct.ReturnValues[0].Actual)
{
Assert.AreEqual(restAct.ReturnValues[0].Actual, restAct.ReturnValues[0].ExpectedCalculated);
}
}
private void GenerateResponse(SwaggerOperation operation, ApplicationAPIModel basicModal)
{
if (operation.Responses.Count > 1 && operation.Responses.Keys.Where(x => x.StartsWith("2")).Count() > 0)
{
string sucesskey = operation.Responses.Keys.Where(x => x.StartsWith("2")).ElementAt(0);
SwaggerResponse response = null;
operation.Responses.TryGetValue(sucesskey, out response);
if (response.Schema != null)
{
if (basicModal.ContentType == ApplicationAPIUtils.eContentType.XML)
{
ApplicationAPIModel JsonResponseModel = new ApplicationAPIModel();
var i = GenerateXMLBody(JsonResponseModel, response.Schema);
foreach (AppModelParameter currModel in GenerateJsonBody(JsonResponseModel, response.Schema))
{
ActReturnValue arv = new ActReturnValue();
arv.ItemName = currModel.ItemName;
arv.Path = currModel.XPath;
arv.DoNotConsiderAsTemp = true;
basicModal.ReturnValues.Add(arv);
}
}
else if (basicModal.ContentType == ApplicationAPIUtils.eContentType.JSon)
{
ApplicationAPIModel JsonResponseModel = new ApplicationAPIModel();
var i = GenerateJsonBody(JsonResponseModel, response.Schema);
foreach (AppModelParameter currModel in GenerateJsonBody(JsonResponseModel, response.Schema))
{
ActReturnValue arv = new ActReturnValue();
arv.ItemName = currModel.ItemName;
arv.Path = currModel.XPath;
arv.DoNotConsiderAsTemp = true;
basicModal.ReturnValues.Add(arv);
}
}
}
else
{
}
}
}
