/// <summary>
/// Delete all requirements from TraceTo
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="traceToReq">TDAPIOLELib.Trace Object</param>
/// <returns>True if Successfull</returns>
public Boolean DeleteRequirementTraceability_TraceTo(TDAPIOLELib.Req req, TDAPIOLELib.Trace traceToReq)
{
TDAPIOLELib.ReqTraceFactory reqTraceFactory = req.ReqTraceFactory[(int)TDAPIOLELib.tagTDAPI_TRACE_DIRECTION.TDOLE_TRACED_TO];
reqTraceFactory.RemoveItem(traceToReq.ID);
return(true);
}
/// <summary>
/// Finds filtered child requirements
/// </summary>
/// <param name="req">Parent requirement</param>
/// <param name="reqType">Filter type of requirement</param>
/// <returns>List of requirements</returns>
public TDAPIOLELib.List GetChildRequirements(TDAPIOLELib.Req req, TDAPIOLELib.TDAPI_PREDEFINED_REQ_TYPES reqType)
{
TDAPIOLELib.ReqFactory reqFactory = tDConnection.ReqFactory;
TDAPIOLELib.TDFilter tDFilter = reqFactory.Filter;
tDFilter["RQ_TYPE_ID"] = reqType.ToString();
return(reqFactory.GetFilteredChildrenList(req.ID, tDFilter));
}
/// <summary>
/// Updates a requirement field value
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="fieldName"></param>
/// <param name="newValue"></param>
/// <param name="Post"></param>
/// <returns></returns>
public Boolean UpdateFieldValue(TDAPIOLELib.Req req, String fieldName, String newValue, Boolean Post = true)
{
req[fieldName.ToUpper()] = newValue;
if (Post)
{
req.Post();
}
return(true);
}
/// <summary>
/// Creates a requirement Folder
/// </summary>
/// <param name="folderName">Requirement folder name</param>
/// <param name="folderPath">Requirement folder path</param>
/// <returns>TDAPIOLELib.Req Object</returns>
public TDAPIOLELib.Req CreateFolder(String folderName, String folderPath)
{
TDAPIOLELib.Req req = GetReqByPath(folderPath);
TDAPIOLELib.ReqFactory reqFactory = tDConnection.ReqFactory;
TDAPIOLELib.Req newReq = reqFactory.AddItem(System.DBNull.Value);
newReq.ParentId = req.ID;
newReq["RQ_TYPE_ID"] = TDAPIOLELib.TDAPI_PREDEFINED_REQ_TYPES.REQ_TYPE_FOLDER;
newReq.Name = folderName;
newReq.Post();
return(newReq);
}
/// <summary>
/// Creates a new requirement
/// </summary>
/// <param name="requirementDetails">dictionary object with requirement database field names and values</param>
/// <param name="folderPath"></param>
/// <param name="reqType"></param>
/// <returns></returns>
public TDAPIOLELib.Req Create(Dictionary <String, String> requirementDetails, String folderPath, TDAPIOLELib.TDAPI_PREDEFINED_REQ_TYPES reqType = TDAPIOLELib.TDAPI_PREDEFINED_REQ_TYPES.REQ_TYPE_UNDEFINED)
{
TDAPIOLELib.Req req = GetReqByPath(folderPath);
TDAPIOLELib.ReqFactory reqFactory = tDConnection.ReqFactory;
TDAPIOLELib.Req newReq = reqFactory.AddItem(System.DBNull.Value);
newReq.ParentId = req.ID;
newReq["RQ_TYPE_ID"] = reqType;
foreach (KeyValuePair <String, String> kvp in requirementDetails)
{
newReq[kvp.Key] = kvp.Value;
}
newReq.Post();
return(newReq);
}
/// <summary>
/// Get TDAPIOLELib.Req object from path
/// </summary>
/// <param name="folderPath">Requirement folder path</param>
/// <returns>TDAPIOLELib.Req Object</returns>
public TDAPIOLELib.Req GetReqByPath(String folderPath)
{
TDAPIOLELib.ReqFactory reqFactory = tDConnection.ReqFactory;
TDAPIOLELib.Req parentReq = reqFactory[0];
TDAPIOLELib.List reqList;
foreach (String Req in folderPath.Split('\\'))
{
if (Req.ToUpper() != "REQUIREMENTS")
{
reqList = reqFactory.Find(parentReq.ID, "RQ_REQ_NAME", Req, Convert.ToInt16(TDAPIOLELib.TDAPI_REQMODE.TDREQMODE_FIND_EXACT));
parentReq = null;
String FirstItemOfList = reqList[1] as String;
parentReq = reqFactory[FirstItemOfList.Split(',')[0]];
}
}
return(parentReq);
}
/// <summary>
/// Add a test plan folder to requiremnt coverage
/// </summary>
/// <param name="testFolderID"></param>
/// <param name="req"></param>
/// <returns></returns>
public Boolean AddTestPlanFolderToRequirementsCoverage(int testFolderID, TDAPIOLELib.Req req)
{
TDAPIOLELib.ICoverableReq coverable = req as TDAPIOLELib.ICoverableReq;
coverable.AddSubjectToCoverage(testFolderID, "");
return(true);
}
/// <summary>
/// Finds child requirements
/// </summary>
/// <param name="req">parent requirement</param>
/// <returns>List of child requirements</returns>
public TDAPIOLELib.List GetChildRequirements(TDAPIOLELib.Req req)
{
TDAPIOLELib.ReqFactory reqFactory = tDConnection.ReqFactory;
return(reqFactory.GetChildrenList(req.ID));
}
/// <summary>
/// Adds Requirement tracebility TraceTo
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="traceToReq">TDAPIOLELib.Req Object</param>
/// <returns>TDAPIOLELib.Trace Object</returns>
public TDAPIOLELib.Trace AddRequirementTraceability_TraceTo(TDAPIOLELib.Req req, TDAPIOLELib.Req traceToReq)
{
TDAPIOLELib.ReqTraceFactory reqTraceFactory = req.ReqTraceFactory[(int)TDAPIOLELib.tagTDAPI_TRACE_DIRECTION.TDOLE_TRACED_TO];
return(reqTraceFactory.AddItem(traceToReq.ID));
}
/// <summary>
/// Gets parent requirement
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>Parent requirement TDAPIOLELib.Req Object</returns>
public TDAPIOLELib.Req GetParentRequirement(TDAPIOLELib.Req req)
{
TDAPIOLELib.ReqFactory reqFactory = tDConnection.ReqFactory;
return(reqFactory[req.ID]);
}
/// <summary>
/// Get target cycles
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>True if successfull</returns>
public TDAPIOLELib.List GetTargetCycles(TDAPIOLELib.Req req)
{
TDAPIOLELib.List listofCycleIDs = req["RQ_TARGET_RCYC"];
return(listofCycleIDs);
}
/// <summary>
/// Delete target cycles
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>True if successfull</returns>
public Boolean DeleteTargetCycles(TDAPIOLELib.Req req)
{
req["RQ_TARGET_RCYC"] = "";
req.Post();
return(true);
}
/// <summary>
/// Set target cycles for requirement
/// </summary>
/// <param name="req">TDAPIOLELib.Req Obejct</param>
/// <param name="listofCycleIDs">List of Cycle ID's</param>
/// <returns>True if successfull</returns>
public Boolean SetTargetCycles(TDAPIOLELib.Req req, TDAPIOLELib.List listofCycleIDs)
{
req["RQ_TARGET_RCYC"] = listofCycleIDs;
req.Post();
return(true);
}
/// <summary>
/// Delete a requirement
/// </summary>
/// <param name="req">Requirement to be deleted</param>
/// <returns>True if successfull</returns>
public Boolean Delete(TDAPIOLELib.Req req)
{
TDAPIOLELib.ReqFactory reqFactory = tDConnection.ReqFactory;
reqFactory.RemoveItem(req.ID);
return(true);
}
/// <summary>
/// Gets the list of defects linked to requirement
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>TDAPIOLELib.List Object</returns>
public TDAPIOLELib.List GetLinkedDefectsToRequirement(TDAPIOLELib.Req req)
{
return(GetLinkedDefectsToEntities(req));
}
/// <summary>
/// Add Attachment to Requirement
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="attachmentsPath">List of Attachments path</param>
/// <returns>True if Successfull</returns>
public Boolean AddAttachements(TDAPIOLELib.Req req, List <String> attachmentsPath)
{
return(Utilities.AddAttachment(req.Attachments, attachmentsPath));
}
/// <summary>
/// Get all requirements from Traceto
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>List of TDAPIOLELib.Trace Object</returns>
public TDAPIOLELib.List GetRequirementTraceability_TraceTo(TDAPIOLELib.Req req)
{
TDAPIOLELib.ReqTraceFactory reqTraceFactory = req.ReqTraceFactory[(int)TDAPIOLELib.tagTDAPI_TRACE_DIRECTION.TDOLE_TRACED_TO];
return(reqTraceFactory.NewList(""));
}
/// <summary>
/// Add test to requirement coverage
/// </summary>
/// <param name="test">TDAPIOLELib.Test Object</param>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>True if successfull</returns>
public Boolean AddTestToRequirementsCoverage(TDAPIOLELib.Test test, TDAPIOLELib.Req req)
{
TDAPIOLELib.ICoverableReq coverable = req as TDAPIOLELib.ICoverableReq;
coverable.AddTestToCoverage(test.ID);
return(true);
}
/// <summary>
/// downloads requirement attachments
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="attachmentDownloadPath">attachment download path</param>
/// <returns></returns>
public Boolean DownloadAttachements(TDAPIOLELib.Req req, String attachmentDownloadPath)
{
return(Utilities.DownloadAttachments(req.Attachments, attachmentDownloadPath));
}
/// <summary>
/// Deletes a requirement attachment by name
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="attachmentName">Attachment name to be deleted</param>
/// <returns>True if successfull</returns>
public Boolean DeleteAttachementByName(TDAPIOLELib.Req req, String attachmentName)
{
return(Utilities.DeleteAttachmentByName(req.Attachments, attachmentName));
}
/// <summary>
/// Delete all attachments for a requirement
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>True if Successfull</returns>
public Boolean DeleteAllAttachments(TDAPIOLELib.Req req)
{
return(Utilities.DeleteAllAttachments(req.Attachments));
}
/// <summary>
/// Rename a requirement
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="newName">New requirement name</param>
/// <returns>True if Successfull</returns>
public Boolean Rename(TDAPIOLELib.Req req, String newName)
{
req["RQ_REQ_NAME"] = newName;
req.Post();
return(true);
}
/// <summary>
/// Set target releases for a requirements.
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <param name="listofReleaseIDs">TDAPIOLELib.List of Release ID's</param>
/// <returns>True if successfull</returns>
public Boolean SetTargetReleases(TDAPIOLELib.Req req, TDAPIOLELib.List listofReleaseIDs)
{
req["RQ_TARGET_REL"] = listofReleaseIDs;
req.Post();
return(true);
}
/// <summary>
/// Links Defect to Requirement
/// </summary>
/// <param name="requirement">TDAPIOLELib.Req Object</param>
/// <param name="bug">TDAPIOLELib.Bug Object</param>
/// <param name="comment">Comment</param>
/// <returns>True if Successfull</returns>
public Boolean LinkDefectToRequirement(TDAPIOLELib.Req requirement, TDAPIOLELib.Bug bug, String comment = "")
{
return(LinkDefectToEntities(requirement, bug, comment));
}
/// <summary>
/// Find target releases for requirement
/// </summary>
/// <param name="req">TDAPIOLELib.Req Object</param>
/// <returns>List of Target releases</returns>
public TDAPIOLELib.List GetTargetReleases(TDAPIOLELib.Req req)
{
TDAPIOLELib.List listofReleaseIDs = req["RQ_TARGET_REL"];
return(listofReleaseIDs);
}
public void Verify_Requirements()
{
Dictionary <String, String> requirementDetails = new Dictionary <String, String>();
requirementDetails.Add("RQ_REQ_NAME", "Dummy1");
aLM_CORE.Requirements.Create(requirementDetails, "Requirements", TDAPIOLELib.TDAPI_PREDEFINED_REQ_TYPES.REQ_TYPE_FOLDER);
TDAPIOLELib.Req req = aLM_CORE.Requirements.CreateFolder("Dummy2", "Requirements\\Dummy1");
aLM_CORE.Requirements.Delete(req);
req = aLM_CORE.Requirements.GetReqByPath("Requirements\\Dummy1");
Console.WriteLine(req.Path);
aLM_CORE.Requirements.UpdateFieldValue(req, "RQ_REQ_NAME", "Dummy6", true);
Console.WriteLine("Requirement Name after change : " + req.Name);
List <String> Attach = new List <String>();
Attach.Add("C:\\Temp\\ALMUPLOAD\\DOC1.txt");
Attach.Add("C:\\Temp\\ALMUPLOAD\\DOC2.docx");
Attach.Add("C:\\Temp\\ALMUPLOAD\\DOC3.xlsx");
aLM_CORE.Requirements.AddAttachements(req, Attach);
aLM_CORE.Requirements.DeleteAttachementByName(req, "DOC2.docx");
aLM_CORE.Requirements.DeleteAllAttachments(req);
aLM_CORE.TestPlan.TestFolders.Create("Subject", "Dummy1");
Dictionary <String, String> TestN = new Dictionary <String, String>();
TestN.Add("TS_NAME", "THIS IS DUMMUY TEST");
TestN.Add("TS_STATUS", "Ready");
aLM_CORE.TestPlan.TestFolders.Create("Subject\\Dummy1", "Dummy2");
TDAPIOLELib.Test test = aLM_CORE.TestPlan.Test.Create(TestN, "Subject\\Dummy1");
TDAPIOLELib.Test test1 = aLM_CORE.TestPlan.Test.Create(TestN, "Subject\\Dummy1\\Dummy2");
TestN.Clear();
TestN.Add("TS_NAME", "THIS IS DUMMUY TEST2");
TestN.Add("TS_STATUS", "Ready");
TDAPIOLELib.Test test2 = aLM_CORE.TestPlan.Test.Create(TestN, "Subject\\Dummy1\\Dummy2");
//Create a requirement of type undefined
TDAPIOLELib.Req req1 = aLM_CORE.Requirements.Create(requirementDetails, "Requirements\\Dummy6", TDAPIOLELib.TDAPI_PREDEFINED_REQ_TYPES.REQ_TYPE_UNDEFINED);
aLM_CORE.Requirements.AddTestToRequirementsCoverage(test, req1);
aLM_CORE.Requirements.AddTestPlanFolderToRequirementsCoverage(aLM_CORE.TestPlan.TestFolders.GetNodeObject("Subject\\Dummy1\\Dummy2").NodeID, req1);
requirementDetails.Clear();
requirementDetails.Add("RQ_REQ_NAME", "Dummy2");
TDAPIOLELib.Req req2 = aLM_CORE.Requirements.Create(requirementDetails, "Requirements\\Dummy6", TDAPIOLELib.TDAPI_PREDEFINED_REQ_TYPES.REQ_TYPE_UNDEFINED);
TDAPIOLELib.Trace trace1 = aLM_CORE.Requirements.AddRequirementTraceability_TraceFrom(req1, req2);
TDAPIOLELib.Trace trace2 = aLM_CORE.Requirements.AddRequirementTraceability_TraceTo(req1, req2);
foreach (TDAPIOLELib.Trace oTrace in aLM_CORE.Requirements.GetRequirementTraceability_TraceFrom(req1))
{
Console.Write("Requirement Tracebility Trace from requirements : " + oTrace.FromReq.Name);
}
foreach (TDAPIOLELib.Trace oTrace in aLM_CORE.Requirements.GetRequirementTraceability_TraceTo(req1))
{
Console.Write("Requirement Tracebility Trace from requirements : " + oTrace.ToReq.Name);
}
TDAPIOLELib.Recordset recordset = aLM_CORE.ExecuteQuery("Select REL_ID From Releases where rownum < 10");
recordset.First();
TDAPIOLELib.List releaseIDList = new TDAPIOLELib.List();
for (int Counter = 0; Counter < recordset.RecordCount; Counter++)
{
Console.WriteLine("Release ID : " + recordset[0]);
releaseIDList.Add(recordset[0]);
recordset.Next();
}
aLM_CORE.Requirements.SetTargetReleases(req1, releaseIDList);
foreach (TDAPIOLELib.Release release in aLM_CORE.Requirements.GetTargetReleases(req1))
{
Console.WriteLine("Target Release ID : " + release.ID);
}
aLM_CORE.Requirements.DeleteTargetReleases(req1);
recordset = aLM_CORE.ExecuteQuery("Select RCYC_ID From RELEASE_CYCLES where rownum < 10");
recordset.First();
TDAPIOLELib.List cycleIDList = new TDAPIOLELib.List();
for (int Counter = 0; Counter < recordset.RecordCount; Counter++)
{
Console.WriteLine("Cycle ID : " + recordset[0]);
cycleIDList.Add(recordset[0]);
recordset.Next();
}
aLM_CORE.Requirements.SetTargetCycles(req1, cycleIDList);
foreach (TDAPIOLELib.Cycle cycle in aLM_CORE.Requirements.GetTargetCycles(req1))
{
Console.WriteLine("Target Cycle ID : " + cycle.ID);
}
aLM_CORE.Requirements.DeleteTargetCycles(req1);
aLM_CORE.Requirements.DeleteRequirementTraceability_TraceFrom(req1, trace1);
aLM_CORE.Requirements.DeleteRequirementTraceability_TraceTo(req1, trace2);
foreach (TDAPIOLELib.Req oReq in aLM_CORE.Requirements.GetChildRequirements(aLM_CORE.Requirements.GetReqByPath("Requirements\\Dummy6")))
{
Console.WriteLine("Child requirement Found : " + oReq.Name);
}
Console.WriteLine("Parent Requirement Name : " + aLM_CORE.Requirements.GetParentRequirement(aLM_CORE.Requirements.GetReqByPath("Requirements\\Dummy6\\Dummy1")).Name);
aLM_CORE.Requirements.Delete(req1);
aLM_CORE.Requirements.Delete(req2);
aLM_CORE.Requirements.Delete(req);
aLM_CORE.TestPlan.Test.Delete(test);
aLM_CORE.TestPlan.Test.Delete(test1);
aLM_CORE.TestPlan.Test.Delete(test2);
aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1");
}
/// <summary>
/// Assign requirement to the test case
/// <para/> returns true if successfull
/// </summary>
/// <param name="test"></param>
/// <param name="requirement"></param>
/// <returns>true if successfull</returns>
public Boolean AssignRequirement(TDAPIOLELib.Test test, TDAPIOLELib.Req requirement)
{
TDAPIOLELib.ICoverableReq OICoverable = requirement as TDAPIOLELib.ICoverableReq;
OICoverable.AddTestToCoverage(test.ID);
return(true);
}
