public void AddActivityToExistingGroupTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity1, group1);
busFlow.AddActivity(activity2, group1);
busFlow.AddActivity(activity3, group1);
busFlow.AddActivity(activity4, group2);
busFlow.AddActivity(activity5, group2);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity6, group1);
//Assert
Assert.IsTrue(busFlow.Activities[3] == activity6, "Validate new Activity added in last of existing group Activities");
Assert.IsTrue(activity6.ActivitiesGroupID == group1.Name, "Validate new Activity is mapped to existing group");
Assert.IsTrue(group1.ActivitiesIdentifiers[group1.ActivitiesIdentifiers.Count - 1].IdentifiedActivity == activity6, "Validate new Activity is mapped to existing group");
}
private void AddFromRepository(object sender, RoutedEventArgs e)
{
if (mInTreeModeView == false)
{
if (grdActivitiesGroupsRepository.Grid.SelectedItems != null && grdActivitiesGroupsRepository.Grid.SelectedItems.Count > 0)
{
if (mBusinessFlow == null)
{
return;
}
foreach (ActivitiesGroup selectedItem in grdActivitiesGroupsRepository.Grid.SelectedItems)
{
ActivitiesGroup droppedGroupIns = (ActivitiesGroup)selectedItem.CreateInstance(true);
mBusinessFlow.AddActivitiesGroup(droppedGroupIns);
mBusinessFlow.ImportActivitiesGroupActivitiesFromRepository(droppedGroupIns, App.LocalRepository.GetSolutionRepoActivities(), false);
int selectedActIndex = -1;
ObservableList <ActivitiesGroup> actsList = App.BusinessFlow.ActivitiesGroups;
if (actsList.CurrentItem != null)
{
selectedActIndex = actsList.IndexOf((ActivitiesGroup)actsList.CurrentItem);
}
if (selectedActIndex >= 0)
{
actsList.Move(actsList.Count - 1, selectedActIndex + 1);
}
}
mBusinessFlow.AttachActivitiesGroupsAndActivities();
}
else
{
Reporter.ToUser(eUserMsgKeys.NoItemWasSelected);
}
}
}
private void grdActivitiesGroups_ItemDropped(object sender, EventArgs e)
{
object droppedItem = ((DragInfo)sender).Data;
Activity previousActivity = null;
if ((ActivitiesGroup)grdActivitiesGroups.CurrentItem != null && ((ActivitiesGroup)grdActivitiesGroups.CurrentItem).ActivitiesIdentifiers.Count > 0)
{
previousActivity = (Activity)(((ActivitiesGroup)grdActivitiesGroups.CurrentItem).ActivitiesIdentifiers[((ActivitiesGroup)grdActivitiesGroups.CurrentItem).ActivitiesIdentifiers.Count - 1].IdentifiedActivity);
}
if (droppedItem.GetType() == typeof(ActivitiesGroup))
{
ActivitiesGroup droppedGroupIns = (ActivitiesGroup)((ActivitiesGroup)droppedItem).CreateInstance(true);
mBusinessFlow.AddActivitiesGroup(droppedGroupIns);
ObservableList <Activity> activities = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <Activity>();
mBusinessFlow.ImportActivitiesGroupActivitiesFromRepository(droppedGroupIns, activities, false, false, previousActivity);
mBusinessFlow.AttachActivitiesGroupsAndActivities();
int selectedActIndex = -1;
ObservableList <ActivitiesGroup> actsList = mBusinessFlow.ActivitiesGroups;
if (actsList.CurrentItem != null)
{
selectedActIndex = actsList.IndexOf((ActivitiesGroup)actsList.CurrentItem);
}
if (selectedActIndex >= 0)
{
actsList.Move(actsList.Count - 1, selectedActIndex + 1);
}
}
}
public string RecoverFolderPath = null; //??? move to above ? !!!!!!!!!!!
public BusinessFlow GetNewBusinessFlow(string Name, bool setTargetApp = false)
{
BusinessFlow newBF = new BusinessFlow();
newBF.Name = Name;
Activity defActivity = new Activity()
{
Active = true
};
defActivity.ActivityName = GingerDicser.GetTermResValue(eTermResKey.Activity) + " 1";
newBF.AddActivity(defActivity, newBF.AddActivitiesGroup());
newBF.Activities.CurrentItem = defActivity;
newBF.CurrentActivity = defActivity;
if (setTargetApp == true && WorkSpace.Instance.Solution.ApplicationPlatforms.Count > 0)
{
newBF.TargetApplications.Add(new TargetApplication()
{
AppName = WorkSpace.Instance.Solution.MainApplication
});
newBF.CurrentActivity.TargetApplication = newBF.TargetApplications[0].Name;
}
return(newBF);
}
/// <summary>
/// Adding Activities Groups from Shared Repository to the Business Flow in Context
/// </summary>
/// <param name="sharedActivitiesGroupsToAdd">Shared Repository Activities Groups to Add Instances from</param>
/// <param name="businessFlow">Business Flow to add to</param>
public static void AddActivitiesGroupsFromSRHandler(List <ActivitiesGroup> sharedActivitiesGroupsToAdd, BusinessFlow businessFlow)
{
foreach (ActivitiesGroup sharedGroup in sharedActivitiesGroupsToAdd)
{
ActivitiesGroup droppedGroupIns = (ActivitiesGroup)sharedGroup.CreateInstance(true);
businessFlow.AddActivitiesGroup(droppedGroupIns);
ObservableList <Activity> activities = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <Activity>();
businessFlow.ImportActivitiesGroupActivitiesFromRepository(droppedGroupIns, activities, false);
}
businessFlow.AttachActivitiesGroupsAndActivities();
}
private BusinessFlow ConvertRunSetToBF(IReportInfo reportInfo)
{
RunsetExecutor runSetExec = WorkSpace.Instance.RunsetExecutor;
try
{
if (reportInfo == null)
{
return(null);
}
//Create Business Flow
BusinessFlow virtualBF = new BusinessFlow();
virtualBF.Name = runSetExec.RunSetConfig.Name;
virtualBF.Description = runSetExec.RunSetConfig.Description;
virtualBF.Status = BusinessFlow.eBusinessFlowStatus.Unknown;
virtualBF.RunStatus = runSetExec.RunSetConfig.RunSetExecutionStatus;
virtualBF.Activities = new ObservableList <Activity>();
foreach (GingerRunner runSetrunner in runSetExec.Runners)
{
// if executor is null when run if from file
if (runSetrunner.Executor is null)
{
runSetrunner.Executor = new GingerExecutionEngine(runSetrunner);
}
foreach (BusinessFlow runSetBF in runSetrunner.Executor.BusinessFlows)
{
ActivitiesGroup virtualAG = new ActivitiesGroup();
virtualAG.Name = runSetBF.Name;
virtualAG.Description = runSetBF.Description;
if (Enum.IsDefined(typeof(eActivitiesGroupRunStatus), runSetBF.RunStatus.ToString()))
{
virtualAG.RunStatus = (eActivitiesGroupRunStatus)Enum.Parse(typeof(eActivitiesGroupRunStatus), runSetBF.RunStatus.ToString());
}
else
{
virtualAG.RunStatus = eActivitiesGroupRunStatus.NA;
}
virtualBF.AddActivitiesGroup(virtualAG);
foreach (Activity runSetAct in runSetBF.Activities)
{
virtualBF.AddActivity(runSetAct, virtualAG);
}
}
}
return(virtualBF);
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, $"Failed to convert Run Set to BF for ALM Export", ex);
return(null);
}
}
private void grdActivities_ItemDropped(object sender, EventArgs e)
{
object droppedItem = ((DragInfo)sender).Data;
if (droppedItem.GetType() == typeof(Activity))
{
Activity instance = (Activity)((Activity)droppedItem).CreateInstance(true);
instance.Active = true;
mBusinessFlow.SetActivityTargetApplication(instance);
mBusinessFlow.AddActivity(instance);
//Placing the item after current item
int selectedActIndex = -1;
ObservableList <Activity> actsList = mBusinessFlow.Activities;
if (actsList.CurrentItem != null)
{
selectedActIndex = actsList.IndexOf((Activity)actsList.CurrentItem);
}
if (selectedActIndex >= 0)
{
actsList.Move(actsList.Count - 1, selectedActIndex + 1);
}
}
else if (droppedItem.GetType() == typeof(ActivitiesGroup))
{
ActivitiesGroup droppedGroupIns = (ActivitiesGroup)((ActivitiesGroup)droppedItem).CreateInstance(true);
mBusinessFlow.AddActivitiesGroup(droppedGroupIns);
ObservableList <Activity> activities = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <Activity>();
mBusinessFlow.ImportActivitiesGroupActivitiesFromRepository(droppedGroupIns, activities, false);
mBusinessFlow.AttachActivitiesGroupsAndActivities();
int selectedActIndex = -1;
ObservableList <ActivitiesGroup> actsList = App.BusinessFlow.ActivitiesGroups;
if (actsList.CurrentItem != null)
{
selectedActIndex = actsList.IndexOf((ActivitiesGroup)actsList.CurrentItem);
}
if (selectedActIndex >= 0)
{
actsList.Move(actsList.Count - 1, selectedActIndex + 1);
}
}
}
private void grdActivities_ItemDropped(object sender, EventArgs e)
{
object droppedItem = ((DragInfo)sender).Data;
if (droppedItem.GetType() == typeof(Activity))
{
Activity instance = (Activity)((Activity)droppedItem).CreateInstance(true);
instance.Active = true;
mBusinessFlow.SetActivityTargetApplication(instance);
mBusinessFlow.AddActivity(instance);
}
else if (droppedItem.GetType() == typeof(ActivitiesGroup))
{
ActivitiesGroup droppedGroupIns = (ActivitiesGroup)((ActivitiesGroup)droppedItem).CreateInstance(true);
mBusinessFlow.AddActivitiesGroup(droppedGroupIns);
ObservableList <Activity> activities = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <Activity>();
mBusinessFlow.ImportActivitiesGroupActivitiesFromRepository(droppedGroupIns, activities, false);
mBusinessFlow.AttachActivitiesGroupsAndActivities();
}
}
private void grdActivitiesGroups_ItemDropped(object sender, EventArgs e)
{
object droppedItem = ((DragInfo)sender).Data;
if (droppedItem.GetType() == typeof(ActivitiesGroup))
{
ActivitiesGroup droppedGroupIns = (ActivitiesGroup)((ActivitiesGroup)droppedItem).CreateInstance(true);
mBusinessFlow.AddActivitiesGroup(droppedGroupIns);
mBusinessFlow.ImportActivitiesGroupActivitiesFromRepository(droppedGroupIns, App.LocalRepository.GetSolutionRepoActivities(), false);
mBusinessFlow.AttachActivitiesGroupsAndActivities();
int selectedActIndex = -1;
ObservableList <ActivitiesGroup> actsList = mBusinessFlow.ActivitiesGroups;
if (actsList.CurrentItem != null)
{
selectedActIndex = actsList.IndexOf((ActivitiesGroup)actsList.CurrentItem);
}
if (selectedActIndex >= 0)
{
actsList.Move(actsList.Count - 1, selectedActIndex + 1);
}
}
}
private void XAddGroupBtn_Click(object sender, RoutedEventArgs e)
{
string groupName = string.Empty;
if (InputBoxWindow.GetInputWithValidation("New Group", "New Group Name:", ref groupName))
{
if (!string.IsNullOrEmpty(groupName))
{
if (mBusinessFlow.ActivitiesGroups.Where(x => x.Name.Trim() == groupName.Trim()).FirstOrDefault() == null)
{
ActivitiesGroup activitiesGroup = new ActivitiesGroup()
{
Name = groupName.Trim()
};
mBusinessFlow.AddActivitiesGroup(activitiesGroup);
xGroupComboBox.SelectedItem = activitiesGroup;
}
else
{
Reporter.ToUser(eUserMsgKey.StaticWarnMessage, "Group with same name already exist, please set unique name.");
}
}
}
}
public void CreateNewGroupToUnSyncedGroupedActivitiesTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
group1.AddActivityToGroup(activity1);
group1.AddActivityToGroup(activity2);
group2.AddActivityToGroup(activity3);
group1.AddActivityToGroup(activity4);
group1.AddActivityToGroup(activity5);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups.Count == 3, "Validate 1 extra groups were added");
Assert.IsTrue(group1.ActivitiesIdentifiers.Count == 2, "Validate only 2 Activities are attached to first group");
Assert.IsTrue(group2.ActivitiesIdentifiers.Count == 1, "Validate 1 Activities were attached to second group");
Assert.IsTrue(busFlow.ActivitiesGroups.Where(x => x.Name == group1.Name + "_2").FirstOrDefault() != null, "Validate new added group name");
Assert.IsTrue(activity4.ActivitiesGroupID == group1.Name + "_2", "Validate Activity was re-grouped to new added group");
Assert.IsTrue(activity5.ActivitiesGroupID == group1.Name + "_2", "Validate Activity was re-grouped to new added group");
}
public void MoveActivityInGroupsTest2()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity1, group1);
busFlow.AddActivity(activity2, group2);
busFlow.AddActivity(activity3, group2);
busFlow.AddActivity(activity4, group2);
busFlow.AddActivity(activity5, group2);
busFlow.AddActivity(activity6, group3);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
busFlow.MoveActivityInGroup(activity5, 1);
//Assert
Assert.IsTrue(busFlow.Activities.IndexOf(activity5) == 1, "Validate Activity moved to correct index in Activities list");
Assert.IsTrue(group2.ActivitiesIdentifiers.IndexOf(group2.ActivitiesIdentifiers.Where(x => x.IdentifiedActivity == activity5).First()) == 0, "Validate Activity moved to correct indx in target group");
}
public void GroupUnGroupedActivitiesTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
group1.AddActivityToGroup(activity1);
group2.AddActivityToGroup(activity4);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups.Count == 2, "Validate no extra groups were added");
Assert.IsTrue(group1.ActivitiesIdentifiers.Count == 3, "Validate first three Activities were attached to first group");
Assert.IsTrue(group2.ActivitiesIdentifiers.Count == 2, "Validate last two Activities were attached to second group");
Assert.IsTrue(group1.ActivitiesIdentifiers[2].ActivityName == activity3.ActivityName, "Validate group 1 has correct activities mapped to it");
Assert.IsTrue(group2.ActivitiesIdentifiers[1].ActivityName == activity5.ActivityName, "Validate group 2 has correct activities mapped to it");
Assert.IsTrue(activity2.ActivitiesGroupID == group1.Name, "Validate Activities mapped to group 1");
Assert.IsTrue(activity5.ActivitiesGroupID == group2.Name, "Validate Activities mapped to group 2");
}
public void MoveActivityBetweenGroupsTest3()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity1, group1);
busFlow.AddActivity(activity2, group1);
busFlow.AddActivity(activity3, group2);
busFlow.AddActivity(activity4, group2);
busFlow.AddActivity(activity5, group3);
busFlow.AddActivity(activity6, group3);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
busFlow.MoveActivityBetweenGroups(activity6, group2, 2);
//Assert
Assert.IsTrue(group3.ActivitiesIdentifiers.Where(x => x.IdentifiedActivity == activity6).FirstOrDefault() == null, "Validate Activity removed from original group");
Assert.IsTrue(activity6.ActivitiesGroupID == group2.Name, "Validate Activity moved to target group");
Assert.IsTrue(busFlow.Activities.IndexOf(activity6) == 2, "Validate Activity moved to correct index in Activities list");
Assert.IsTrue(group2.ActivitiesIdentifiers.IndexOf(group2.ActivitiesIdentifiers.Where(x => x.IdentifiedActivity == activity6).First()) == 0, "Validate Activity moved to correct indx in target group");
}
public void AddActivityWithNewGroupTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity1, group1);
busFlow.AddActivity(activity2, group1);
busFlow.AddActivity(activity3, group1);
busFlow.AddActivity(activity4, group2);
busFlow.AddActivity(activity5, group2);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity6, group3);
//Assert
Assert.IsTrue(busFlow.Activities[5] == activity6, "Validate new Activity added in last");
Assert.IsTrue(busFlow.ActivitiesGroups[2] == group3, "Validate new group was added to BF");
Assert.IsTrue(activity6.ActivitiesGroupID == group3.Name, "Validate new Activity is mapped to new group");
Assert.IsTrue(group3.ActivitiesIdentifiers[0].IdentifiedActivity == activity6, "Validate new Activity is mapped to new group");
}
public void MoveActivitiesGroupDownTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
Activity activity6 = new Activity()
{
ActivityName = "Activity6"
};
busFlow.AddActivity(activity6);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
group1.AddActivityToGroup(activity1);
group1.AddActivityToGroup(activity2);
group2.AddActivityToGroup(activity3);
group2.AddActivityToGroup(activity4);
group2.AddActivityToGroup(activity5);
group3.AddActivityToGroup(activity6);
//Act
busFlow.MoveActivitiesGroupDown(group1);
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups[0] == group2, "Validate group 2 moved to place 1");
Assert.IsTrue(busFlow.ActivitiesGroups[1] == group1, "Validate group 1 moved to place 2");
Assert.IsTrue(busFlow.Activities[0] == activity3, "Validate group 2 Activities moved up");
Assert.IsTrue(busFlow.Activities[1] == activity4, "Validate group 2 Activities moved up");
Assert.IsTrue(busFlow.Activities[2] == activity5, "Validate group 2 Activities moved up");
Assert.IsTrue(busFlow.Activities[3] == activity1, "Validate group 1 Activities moved down");
Assert.IsTrue(busFlow.Activities[4] == activity2, "Validate group 1 Activities moved down");
}
public BusinessFlow ConvertQCTestSetToBF(QC.ALMTestSet testSet)
{
GingerActivitiesGroupsRepo = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <ActivitiesGroup>();
GingerActivitiesRepo = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <Activity>();
try
{
if (testSet == null)
{
return(null);
}
//Create Business Flow
BusinessFlow busFlow = new BusinessFlow();
busFlow.Name = testSet.TestSetName;
busFlow.ExternalID = testSet.TestSetID;
busFlow.Status = BusinessFlow.eBusinessFlowStatus.Development;
busFlow.Activities = new ObservableList <Activity>();
busFlow.Variables = new ObservableList <VariableBase>();
Dictionary <string, string> busVariables = new Dictionary <string, string>();//will store linked variables
//Create Activities Group + Activities for each TC
foreach (QC.ALMTSTest tc in testSet.Tests)
{
//check if the TC is already exist in repository
ActivitiesGroup tcActivsGroup;
ActivitiesGroup repoActivsGroup = null;
if (repoActivsGroup == null)
{
repoActivsGroup = GingerActivitiesGroupsRepo.Where(x => x.ExternalID == tc.TestID).FirstOrDefault();
}
if (repoActivsGroup != null)
{
List <Activity> repoNotExistsStepActivity = GingerActivitiesRepo.Where(z => repoActivsGroup.ActivitiesIdentifiers.Select(y => y.ActivityExternalID).ToList().Contains(z.ExternalID))
.Where(x => !tc.Steps.Select(y => y.StepID).ToList().Contains(x.ExternalID)).ToList();
tcActivsGroup = (ActivitiesGroup)repoActivsGroup.CreateInstance();
var ActivitySIdentifiersToRemove = tcActivsGroup.ActivitiesIdentifiers.Where(x => repoNotExistsStepActivity.Select(z => z.ExternalID).ToList().Contains(x.ActivityExternalID));
for (int indx = 0; indx < tcActivsGroup.ActivitiesIdentifiers.Count; indx++)
{
if ((indx < tcActivsGroup.ActivitiesIdentifiers.Count) && (ActivitySIdentifiersToRemove.Contains(tcActivsGroup.ActivitiesIdentifiers[indx])))
{
tcActivsGroup.ActivitiesIdentifiers.Remove(tcActivsGroup.ActivitiesIdentifiers[indx]);
indx--;
}
}
tcActivsGroup.ExternalID2 = tc.TestID;
busFlow.AddActivitiesGroup(tcActivsGroup);
busFlow.ImportActivitiesGroupActivitiesFromRepository(tcActivsGroup, GingerActivitiesRepo, ApplicationPlatforms, true);
busFlow.AttachActivitiesGroupsAndActivities();
}
else //TC not exist in Ginger repository so create new one
{
tcActivsGroup = new ActivitiesGroup();
tcActivsGroup.Name = tc.TestName;
tcActivsGroup.ExternalID = tc.TestID;
tcActivsGroup.ExternalID2 = tc.LinkedTestID;
tcActivsGroup.Description = tc.Description;
busFlow.AddActivitiesGroup(tcActivsGroup);
}
//Add the TC steps as Activities if not already on the Activities group
foreach (QC.ALMTSTestStep step in tc.Steps)
{
Activity stepActivity;
bool toAddStepActivity = false;
//check if mapped activity exist in repository
Activity repoStepActivity = (Activity)GingerActivitiesRepo.Where(x => x.ExternalID == step.StepID).FirstOrDefault();
if (repoStepActivity != null)
{
//check if it is part of the Activities Group
ActivityIdentifiers groupStepActivityIdent = (ActivityIdentifiers)tcActivsGroup.ActivitiesIdentifiers.Where(x => x.ActivityExternalID == step.StepID).FirstOrDefault();
if (groupStepActivityIdent != null)
{
//already in Activities Group so get link to it
stepActivity = (Activity)busFlow.Activities.Where(x => x.Guid == groupStepActivityIdent.ActivityGuid).FirstOrDefault();
// in any case update description/expected/name - even if "step" was taken from repository
stepActivity.Description = StripHTML(step.Description);
stepActivity.Expected = StripHTML(step.Expected);
stepActivity.ActivityName = tc.TestName + ">" + step.StepName;
}
else//not in ActivitiesGroup so get instance from repo
{
stepActivity = (Activity)repoStepActivity.CreateInstance();
toAddStepActivity = true;
}
}
else//Step not exist in Ginger repository so create new one
{
stepActivity = new Activity();
stepActivity.ActivityName = tc.TestName + ">" + step.StepName;
stepActivity.ExternalID = step.StepID;
stepActivity.Description = StripHTML(step.Description);
toAddStepActivity = true;
}
if (toAddStepActivity)
{
//not in group- need to add it
busFlow.AddActivity(stepActivity, tcActivsGroup);
}
//pull TC-Step parameters and add them to the Activity level
List <string> stepParamsList = new List <string>();
foreach (string param in stepParamsList)
{
//get the param value
string paramSelectedValue = string.Empty;
bool? isflowControlParam = null;
QC.ALMTSTestParameter tcParameter = tc.Parameters.Where(x => x.Name.ToUpper() == param.ToUpper()).FirstOrDefault();
//get the param value
if (tcParameter != null && tcParameter.Value != null && tcParameter.Value != string.Empty)
{
paramSelectedValue = tcParameter.Value;
}
else
{
isflowControlParam = null;//empty value
paramSelectedValue = "<Empty>";
}
//check if parameter is part of a link
string linkedVariable = null;
if (paramSelectedValue.StartsWith("#$#"))
{
string[] valueParts = paramSelectedValue.Split(new [] { "#$#" }, StringSplitOptions.None);
if (valueParts.Count() == 3)
{
linkedVariable = valueParts[1];
paramSelectedValue = "$$_" + valueParts[2];//so it still will be considered as non-flow control
if (!busVariables.Keys.Contains(linkedVariable))
{
busVariables.Add(linkedVariable, valueParts[2]);
}
}
}
//determine if the param is Flow Control Param or not based on it value and agreed sign "$$_"
if (paramSelectedValue.StartsWith("$$_"))
{
isflowControlParam = false;
if (paramSelectedValue.StartsWith("$$_"))
{
paramSelectedValue = paramSelectedValue.Substring(3);//get value without "$$_"
}
}
else if (paramSelectedValue != "<Empty>")
{
isflowControlParam = true;
}
//check if already exist param with that name
VariableBase stepActivityVar = stepActivity.Variables.Where(x => x.Name.ToUpper() == param.ToUpper()).FirstOrDefault();
if (stepActivityVar == null)
{
//#Param not exist so add it
if (isflowControlParam == true)
{
//add it as selection list param
stepActivityVar = new VariableSelectionList();
stepActivityVar.Name = param;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = eActivityAutomationStatus.Development;//reset status because new flow control param was added
}
else
{
//add as String param
stepActivityVar = new VariableString();
stepActivityVar.Name = param;
((VariableString)stepActivityVar).InitialStringValue = paramSelectedValue;
stepActivity.AddVariable(stepActivityVar);
}
}
else
{
//#param exist
if (isflowControlParam == true)
{
if (!(stepActivityVar is VariableSelectionList))
{
//flow control param must be Selection List so transform it
stepActivity.Variables.Remove(stepActivityVar);
stepActivityVar = new VariableSelectionList();
stepActivityVar.Name = param;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = eActivityAutomationStatus.Development;//reset status because flow control param was added
}
}
else if (isflowControlParam == false)
{
if (stepActivityVar is VariableSelectionList)
{
//change it to be string variable
stepActivity.Variables.Remove(stepActivityVar);
stepActivityVar = new VariableString();
stepActivityVar.Name = param;
((VariableString)stepActivityVar).InitialStringValue = paramSelectedValue;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = eActivityAutomationStatus.Development;//reset status because flow control param was removed
}
}
}
//add the variable selected value
if (stepActivityVar is VariableSelectionList)
{
OptionalValue stepActivityVarOptionalVar = ((VariableSelectionList)stepActivityVar).OptionalValuesList.Where(x => x.Value == paramSelectedValue).FirstOrDefault();
if (stepActivityVarOptionalVar == null)
{
//no such variable value option so add it
stepActivityVarOptionalVar = new OptionalValue(paramSelectedValue);
((VariableSelectionList)stepActivityVar).OptionalValuesList.Add(stepActivityVarOptionalVar);
if (isflowControlParam == true)
{
stepActivity.AutomationStatus = eActivityAutomationStatus.Development;//reset status because new param value was added
}
}
//set the selected value
((VariableSelectionList)stepActivityVar).SelectedValue = stepActivityVarOptionalVar.Value;
}
else
{
//try just to set the value
try
{
stepActivityVar.Value = paramSelectedValue;
if (stepActivityVar is VariableString)
{
((VariableString)stepActivityVar).InitialStringValue = paramSelectedValue;
}
}
catch (Exception ex) { Reporter.ToLog(eLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}", ex); }
}
//add linked variable if needed
if (!string.IsNullOrEmpty(linkedVariable))
{
stepActivityVar.LinkedVariableName = linkedVariable;
}
else
{
stepActivityVar.LinkedVariableName = string.Empty;//clear old links
}
}
}
//order the Activities Group activities according to the order of the matching steps in the TC
try
{
int startGroupActsIndxInBf = 0;
if (busFlow.Activities.Count > 0)
{
startGroupActsIndxInBf = busFlow.Activities.IndexOf(tcActivsGroup.ActivitiesIdentifiers[0].IdentifiedActivity);
}
foreach (QC.ALMTSTestStep step in tc.Steps)
{
int stepIndx = tc.Steps.IndexOf(step) + 1;
ActivityIdentifiers actIdent = (ActivityIdentifiers)tcActivsGroup.ActivitiesIdentifiers.Where(x => x.ActivityExternalID == step.StepID).FirstOrDefault();
if (actIdent == null || actIdent.IdentifiedActivity == null)
{
break;//something wrong- shouldn't be null
}
Activity act = (Activity)actIdent.IdentifiedActivity;
int groupActIndx = tcActivsGroup.ActivitiesIdentifiers.IndexOf(actIdent);
int bfActIndx = busFlow.Activities.IndexOf(act);
//set it in the correct place in the group
int numOfSeenSteps = 0;
int groupIndx = -1;
foreach (ActivityIdentifiers ident in tcActivsGroup.ActivitiesIdentifiers)
{
groupIndx++;
if (string.IsNullOrEmpty(ident.ActivityExternalID) ||
tc.Steps.Where(x => x.StepID == ident.ActivityExternalID).FirstOrDefault() == null)
{
continue;//activity which not originally came from the TC
}
numOfSeenSteps++;
if (numOfSeenSteps >= stepIndx)
{
break;
}
}
ActivityIdentifiers identOnPlace = (ActivityIdentifiers)tcActivsGroup.ActivitiesIdentifiers[groupIndx];
if (identOnPlace.ActivityGuid != act.Guid)
{
//replace places in group
tcActivsGroup.ActivitiesIdentifiers.Move(groupActIndx, groupIndx);
//replace places in business flow
busFlow.Activities.Move(bfActIndx, startGroupActsIndxInBf + groupIndx);
}
}
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}", ex);
//failed to re order the activities to match the tc steps order, not worth breaking the import because of this
}
}
//Add the BF variables (linked variables)
if (busVariables.Keys.Count > 0)
{
foreach (KeyValuePair <string, string> var in busVariables)
{
//add as String param
VariableString busVar = new VariableString();
busVar.Name = var.Key;
busVar.InitialStringValue = var.Value;
busFlow.AddVariable(busVar);
}
}
return(busFlow);
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Failed to import QC test set and convert it into " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow), ex);
return(null);
}
}
public static BusinessFlow ConvertRallyTestPlanToBF(RallyTestPlan testPlan)
{
try
{
if (testPlan == null)
{
return(null);
}
//Create Business Flow
BusinessFlow busFlow = new BusinessFlow();
busFlow.Name = testPlan.Name;
busFlow.ExternalID = "RallyID=" + testPlan.RallyID;
busFlow.Status = BusinessFlow.eBusinessFlowStatus.Development;
busFlow.Activities = new ObservableList <Activity>();
busFlow.Variables = new ObservableList <VariableBase>();
//Create Activities Group + Activities for each TC
foreach (RallyTestCase tc in testPlan.TestCases)
{
//check if the TC is already exist in repository
ActivitiesGroup tcActivsGroup;
ActivitiesGroup repoActivsGroup = null;
if (repoActivsGroup == null)
{
repoActivsGroup = GingerActivitiesGroupsRepo.Where(x => x.ExternalID != null ? x.ExternalID.Split('|').First().Split('=').Last() == tc.RallyID : false).FirstOrDefault();
}
if (repoActivsGroup != null)
{
tcActivsGroup = (ActivitiesGroup)repoActivsGroup.CreateInstance();
busFlow.AddActivitiesGroup(tcActivsGroup);
busFlow.ImportActivitiesGroupActivitiesFromRepository(tcActivsGroup, GingerActivitiesRepo, true, true);
busFlow.AttachActivitiesGroupsAndActivities();
}
else // TC not exist in Ginger repository so create new one
{
tcActivsGroup = new ActivitiesGroup();
tcActivsGroup.Name = tc.Name;
tcActivsGroup.Description = tc.Description;
tcActivsGroup.ExternalID = "RallyID=" + tc.RallyID + "|AtsID=" + tc.BTSID;
busFlow.AddActivitiesGroup(tcActivsGroup);
}
foreach (RallyTestStep step in tc.TestSteps)
{
Activity stepActivity;
bool toAddStepActivity = false;
// check if mapped activity exist in repository
Activity repoStepActivity = GingerActivitiesRepo.Where(x => x.ExternalID != null ? x.ExternalID.Split('|').First().Split('=').Last() == step.RallyIndex : false).FirstOrDefault();
if (repoStepActivity != null)
{
//check if it is part of the Activities Group
ActivityIdentifiers groupStepActivityIdent = tcActivsGroup.ActivitiesIdentifiers.Where(x => x.ActivityExternalID == step.RallyIndex).FirstOrDefault();
if (groupStepActivityIdent != null)
{
//already in Activities Group so get link to it
stepActivity = busFlow.Activities.Where(x => x.Guid == groupStepActivityIdent.ActivityGuid).FirstOrDefault();
}
else // not in ActivitiesGroup so get instance from repo
{
stepActivity = (Activity)repoStepActivity.CreateInstance();
toAddStepActivity = true;
}
}
else //Step not exist in Ginger repository so create new one
{
string strBtsID = string.Empty;
stepActivity = new Activity();
stepActivity.ActivityName = tc.Name + ">" + step.Name;
stepActivity.ExternalID = "RallyID=" + step.RallyIndex + "|AtsID=" + strBtsID;
stepActivity.Description = StripHTML(step.Description);
stepActivity.Expected = StripHTML(step.ExpectedResult);
toAddStepActivity = true;
}
if (toAddStepActivity)
{
// not in group- need to add it
busFlow.AddActivity(stepActivity);
tcActivsGroup.AddActivityToGroup(stepActivity);
}
//pull TC-Step parameters and add them to the Activity level
foreach (RallyTestParameter param in tc.Parameters) // Params taken from TestScriptLevel only!!!! Also exists parapameters at TestCase, to check if them should be taken!!!
{
bool?isflowControlParam = null;
//detrmine if the param is Flow Control Param or not based on it value and agreed sign "$$_"
if (param.Value.ToString().StartsWith("$$_"))
{
isflowControlParam = false;
if (param.Value.ToString().StartsWith("$$_"))
{
param.Value = param.Value.ToString().Substring(3); //get value without "$$_"
}
}
else if (param.Value.ToString() != "<Empty>")
{
isflowControlParam = true;
}
//check if already exist param with that name
VariableBase stepActivityVar = stepActivity.Variables.Where(x => x.Name.ToUpper() == param.Name.ToUpper()).FirstOrDefault();
if (stepActivityVar == null)
{
//#Param not exist so add it
if (isflowControlParam == true)
{
//add it as selection list param
stepActivityVar = new VariableSelectionList();
stepActivityVar.Name = param.Name;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because new flow control param was added
}
else
{
//add as String param
stepActivityVar = new VariableString();
stepActivityVar.Name = param.Name;
((VariableString)stepActivityVar).InitialStringValue = param.Value;
stepActivity.AddVariable(stepActivityVar);
}
}
else
{
//#param exist
if (isflowControlParam == true)
{
if (!(stepActivityVar is VariableSelectionList))
{
//flow control param must be Selection List so transform it
stepActivity.Variables.Remove(stepActivityVar);
stepActivityVar = new VariableSelectionList();
stepActivityVar.Name = param.Name;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because flow control param was added
}
}
else if (isflowControlParam == false)
{
if (stepActivityVar is VariableSelectionList)
{
//change it to be string variable
stepActivity.Variables.Remove(stepActivityVar);
stepActivityVar = new VariableString();
stepActivityVar.Name = param.Name;
((VariableString)stepActivityVar).InitialStringValue = param.Value;
stepActivity.AddVariable(stepActivityVar);
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because flow control param was removed
}
}
}
//add the variable selected value
if (stepActivityVar is VariableSelectionList)
{
OptionalValue stepActivityVarOptionalVar = ((VariableSelectionList)stepActivityVar).OptionalValuesList.Where(x => x.Value == param.Value).FirstOrDefault();
if (stepActivityVarOptionalVar == null)
{
//no such variable value option so add it
stepActivityVarOptionalVar = new OptionalValue(param.Value);
((VariableSelectionList)stepActivityVar).OptionalValuesList.Add(stepActivityVarOptionalVar);
if (isflowControlParam == true)
{
stepActivity.AutomationStatus = Activity.eActivityAutomationStatus.Development;//reset status because new param value was added
}
}
//set the selected value
((VariableSelectionList)stepActivityVar).SelectedValue = stepActivityVarOptionalVar.Value;
}
else
{
//try just to set the value
try
{
stepActivityVar.Value = param.Value;
if (stepActivityVar is VariableString)
{
((VariableString)stepActivityVar).InitialStringValue = param.Value;
}
}
catch (Exception ex) { Reporter.ToLog(eAppReporterLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {ex.Message}", ex); }
}
}
}
}
return(busFlow);
}
catch (Exception ex)
{
Reporter.ToLog(eAppReporterLogLevel.ERROR, "Failed to import Rally test set and convert it into " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow), ex);
return(null);
}
}
private ActivitiesGroup CreateScenario(ScenarioDefinition sc, int?index = null)
{
// Create new activity per each step
// Each scenario is in one ActivitiesGroup
ActivitiesGroup AG = new ActivitiesGroup();
AG.Name = sc.Name;
if (index != null)
{
AG.Name += " #" + index; // Adding Scenario index so it will be unique
}
mBizFlow.AddActivitiesGroup(AG);
//Add Tags - on ActivitiesGroup and solution if needed
IEnumerable <Tag> TagList = null;
if (sc is ScenarioOutline)
{
TagList = ((ScenarioOutline)sc).Tags;
}
else if (sc is Scenario)
{
TagList = ((Scenario)sc).Tags;
}
foreach (var t in TagList)
{
Guid tg = GetOrCreateTagInSolution(t.Name);
AG.Tags.Add(tg);
}
foreach (Guid guid in mBizFlow.Tags)
{
AG.Tags.Add(guid);
}
foreach (Gherkin.Ast.Step step in sc.Steps)
{
// Find the Activity from the template BF with All activity, create a copy and add to BF
string GN = GherkinGeneral.GetActivityGherkinName(step.Text);
Activity a = (Activity)SearchActivityByName(GN);
if (a != null)
{
Activity a1 = (Activity)a.CreateCopy(false);
a1.ActivityName = step.Text;
a1.Active = true;
a1.ParentGuid = a1.Guid;
Guid g = Guid.NewGuid();
a1.Guid = g;
foreach (var t in AG.Tags)
{
if (!a1.Tags.Contains(t))
{
a1.Tags.Add(t);
}
if (!a.Tags.Contains(t))
{
a.Tags.Add(t);
}
}
//Adding feature tags
foreach (Guid guid in mBizFlow.Tags)
{
if (!a1.Tags.Contains(guid))
{
a1.Tags.Add(guid);
}
if (!a.Tags.Contains(guid))
{
a.Tags.Add(guid);
}
}
UpdateActivityVars(a1, a.ActivityName);
mBizFlow.AddActivity(a1, AG);
}
else
{
//TODO: err activity not found...
Reporter.ToUser(eUserMsgKey.GherkinActivityNotFound, GN);
}
}
return(AG);
}
private void AddGroup(object sender, RoutedEventArgs e)
{
mBusinessFlow.AddActivitiesGroup();
}
public void GroupsOrderTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group3 = new ActivitiesGroup()
{
Name = "Group3"
};
busFlow.AddActivitiesGroup(group3);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
group1.AddActivityToGroup(activity1);
group1.AddActivityToGroup(activity2);
group2.AddActivityToGroup(activity3);
group3.AddActivityToGroup(activity4);
group3.AddActivityToGroup(activity5);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(busFlow.ActivitiesGroups[0] == group1, "Validate first group is group 1 same as in Activities flow");
Assert.IsTrue(busFlow.ActivitiesGroups[1] == group2, "Validate first group is group 2 same as in Activities flow");
Assert.IsTrue(busFlow.ActivitiesGroups[2] == group3, "Validate first group is group 3 same as in Activities flow");
}
public void GroupsActivitiesOrderTest()
{
//Arrange
BusinessFlow busFlow = new BusinessFlow();
Activity activity1 = new Activity()
{
ActivityName = "Activity1"
};
busFlow.AddActivity(activity1);
Activity activity2 = new Activity()
{
ActivityName = "Activity2"
};
busFlow.AddActivity(activity2);
Activity activity3 = new Activity()
{
ActivityName = "Activity3"
};
busFlow.AddActivity(activity3);
Activity activity4 = new Activity()
{
ActivityName = "Activity4"
};
busFlow.AddActivity(activity4);
Activity activity5 = new Activity()
{
ActivityName = "Activity5"
};
busFlow.AddActivity(activity5);
ActivitiesGroup group1 = new ActivitiesGroup()
{
Name = "Group1"
};
busFlow.AddActivitiesGroup(group1);
ActivitiesGroup group2 = new ActivitiesGroup()
{
Name = "Group2"
};
busFlow.AddActivitiesGroup(group2);
group1.AddActivityToGroup(activity3);
group1.AddActivityToGroup(activity2);
group1.AddActivityToGroup(activity1);
group2.AddActivityToGroup(activity4);
group2.AddActivityToGroup(activity5);
//Act
busFlow.AttachActivitiesGroupsAndActivities();
//Assert
Assert.IsTrue(group1.ActivitiesIdentifiers[0].IdentifiedActivity == activity1, "Validate group 1 Activity 1 order is same as in Activities flow");
Assert.IsTrue(group1.ActivitiesIdentifiers[1].IdentifiedActivity == activity2, "Validate group 1 Activity 2 order is same as in Activities flow");
Assert.IsTrue(group1.ActivitiesIdentifiers[2].IdentifiedActivity == activity3, "Validate group 1 Activity 3 order is same as in Activities flow");
Assert.IsTrue(group2.ActivitiesIdentifiers[0].IdentifiedActivity == activity4, "Validate group 2 Activity 4 order is same as in Activities flow");
Assert.IsTrue(group2.ActivitiesIdentifiers[1].IdentifiedActivity == activity5, "Validate group 2 Activity 5 order is same as in Activities flow");
}
private static ActivitiesGroup CheckIfTCAlreadyExistInRepo(BusinessFlow busFlow, QCTestInstance testInstance, QCTestCaseStepsColl tSTestCaseSteps)
{
ActivitiesGroup tcActivsGroup;
ActivitiesGroup repoActivsGroup = null;
QCTestCaseStepsColl relevantTestCaseSteps = QCRestAPIConnect.GetTestCaseSteps(testInstance.TestId);
QCTestCaseStep relevantStep = null;
foreach (QCTestCaseStep testcaseStep in relevantTestCaseSteps)
{
if (testcaseStep.ElementsField.ContainsKey("link-test"))
{
relevantStep = testcaseStep;
}
}
if (relevantStep != null)
{
repoActivsGroup = GingerActivitiesGroupsRepo.Where(x => x.ExternalID == relevantStep.ElementsField["link-test"].ToString()).FirstOrDefault();
}
if (repoActivsGroup == null)
{
repoActivsGroup = GingerActivitiesGroupsRepo.Where(x => x.ExternalID == testInstance.Id).FirstOrDefault();
}
if (repoActivsGroup != null)
{
List <Activity> repoNotExistsStepActivity = GingerActivitiesRepo.Where(z => repoActivsGroup.ActivitiesIdentifiers.Select(y => y.ActivityExternalID).ToList().Contains(z.ExternalID))
.Where(x => !tSTestCaseSteps.Where(item => item.TestId == testInstance.TestId).Select(y => y.Id).ToList().Contains(x.ExternalID)).ToList();
tcActivsGroup = (ActivitiesGroup)repoActivsGroup.CreateInstance();
var ActivitySIdentifiersToRemove = tcActivsGroup.ActivitiesIdentifiers.Where(x => repoNotExistsStepActivity.Select(z => z.ExternalID).ToList().Contains(x.ActivityExternalID));
for (int indx = 0; indx < tcActivsGroup.ActivitiesIdentifiers.Count; indx++)
{
if ((indx < tcActivsGroup.ActivitiesIdentifiers.Count) && (ActivitySIdentifiersToRemove.Contains(tcActivsGroup.ActivitiesIdentifiers[indx])))
{
tcActivsGroup.ActivitiesIdentifiers.Remove(tcActivsGroup.ActivitiesIdentifiers[indx]);
indx--;
}
}
tcActivsGroup.ExternalID2 = testInstance.Id;
busFlow.AddActivitiesGroup(tcActivsGroup);
busFlow.ImportActivitiesGroupActivitiesFromRepository(tcActivsGroup, GingerActivitiesRepo, true, true);
busFlow.AttachActivitiesGroupsAndActivities();
}
else //TC not exist in Ginger repository so create new one
{
tcActivsGroup = new ActivitiesGroup();
tcActivsGroup.Name = testInstance.Name;
if (relevantStep == null)
{
tcActivsGroup.ExternalID = testInstance.Id;
tcActivsGroup.ExternalID2 = testInstance.Id;
}
else
{
tcActivsGroup.ExternalID = relevantStep.ElementsField["link-test"].ToString();
tcActivsGroup.ExternalID2 = testInstance.Id;
}
busFlow.AddActivitiesGroup(tcActivsGroup);
}
return(tcActivsGroup);
}
