/// <summary>
        /// Creates new folder path. e.g. if path is passed as Subject\Dummy1\Dummy2\Dummy3 and Only subject folder exists in ALM then this function will create Dummy1, Dummy2 and Dummy3 folders.
        /// <para/> true if successfull
        /// </summary>
        /// <param name="folderPath">folder path</param>
        /// <returns>true if successfull</returns>
        public TDAPIOLELib.TestFolder CreateNewFolderPath(String folderPath)
        {
            TDAPIOLELib.TreeManager OTManager = tDConnection.TreeManager;
            String PathChecked = "Subject";

            TDAPIOLELib.SysTreeNode oTestFolder = GetNodeObject("subject");

            foreach (String Folder in folderPath.Split('\\'))
            {
                if (!(Folder.ToUpper() == "SUBJECT"))
                {
                    try
                    {
                        oTestFolder = GetNodeObject(PathChecked + "\\" + Folder);
                        PathChecked = PathChecked + "\\" + Folder;
                    }
                    catch
                    {
                        oTestFolder = GetNodeObject(PathChecked);
                        oTestFolder.AddNode(Folder);
                        PathChecked = PathChecked + "\\" + Folder;
                    }
                }
            }

            TDAPIOLELib.TestFolder testFolder = GetFolderObject(PathChecked);
            return(testFolder);
        }
        /// <summary>
        /// Create a new folder path in test lab
        /// <para/>returns true if successfull
        /// </summary>
        /// <param name="FolderPath">Folder path to be created. All missing folder will be created</param>
        /// <returns>true if successfull</returns>
        public Boolean CreateNewFolderPath(String FolderPath)
        {
            String PathChecked = "Root";

            TDAPIOLELib.SysTreeNode oTestFolder = GetNodeObject("root");
            foreach (String Folder in FolderPath.Split('\\'))
            {
                if (!(Folder.ToUpper() == "ROOT"))
                {
                    try
                    {
                        oTestFolder = GetNodeObject(PathChecked + "\\" + Folder);
                        PathChecked = PathChecked + "\\" + Folder;
                    }
                    catch
                    {
                        oTestFolder = GetNodeObject(PathChecked);
                        oTestFolder.AddNode(Folder);
                        PathChecked = PathChecked + "\\" + Folder;
                    }
                }
            }

            return(true);
        }
 /// <summary>
 /// Renames a Folder
 /// <para/>Returns true if successfull
 /// </summary>
 /// <param name="ParentFolderPath">Parent folder path</param>
 /// <param name="CurrentFolderName">Current folder name</param>
 /// <param name="NewFolderName">New folder name</param>
 /// <returns>true if successfull</returns>
 public Boolean Rename(String ParentFolderPath, String CurrentFolderName, String NewFolderName)
 {
     TDAPIOLELib.SysTreeNode OParentFolder  = GetNodeObject(ParentFolderPath);
     TDAPIOLELib.SysTreeNode OCurrentFolder = OParentFolder.FindChildNode(CurrentFolderName) as TDAPIOLELib.SysTreeNode;
     OCurrentFolder.Name = NewFolderName;
     OCurrentFolder.Post();
     return(true);
 }
        /// <summary>
        /// Finds All Folder names under a test plan folder.
        /// <para/>returns List of string with folder names
        /// </summary>
        /// <param name="folderPath"></param>
        /// <returns>List of string with folder names</returns>
        public List <String> GetChildFolderNames(String folderPath)
        {
            List <String> OFNames = new List <string>();

            TDAPIOLELib.SysTreeNode OSysTreeNode = GetNodeObject(folderPath);
            for (int Counter = 1; Counter <= OSysTreeNode.Count; Counter++)
            {
                OFNames.Add(OSysTreeNode.Child[Counter].Name);
            }
            return(OFNames);
        }
        /// <summary>
        /// Deletes a folder in test lab
        /// </summary>
        /// <param name="ParentFolderPath">Parent folder path</param>
        /// <param name="DeleteFolderName">folder to be deleted</param>
        /// <returns></returns>
        public Boolean Delete(String ParentFolderPath, String DeleteFolderName)
        {
            TDAPIOLELib.SysTreeNode OSysTreeNode    = GetNodeObject(ParentFolderPath);
            TDAPIOLELib.SysTreeNode NodeToBeDeleted = OSysTreeNode.FindChildNode(DeleteFolderName) as TDAPIOLELib.SysTreeNode;

            if (NodeToBeDeleted.NodeID > 0)
            {
                OSysTreeNode.RemoveNode(NodeToBeDeleted);
            }
            return(true);
        }
Exemple #6
0
        public void Verify_TestSetFolders()
        {
            aLM_CORE.TestLab.TestLabFolders.Create("Root", "Dummy1");
            aLM_CORE.TestLab.TestLabFolders.CreateNewFolderPath("Root\\Dummy1\\Dummy2\\Dummy3\\Dummy4");

            Console.WriteLine("Created TestLab Folders");

            //Find Folders under a testlab folder
            List <String> list = aLM_CORE.TestLab.TestLabFolders.FindChildFolders("Root\\Dummy1");

            foreach (String folderName in list)
            {
                Console.WriteLine("Folder Under Root\\Dummy\\ : " + folderName);
            }

            //Create two testsets
            Dictionary <String, String> testSet_New = new Dictionary <String, String>();

            testSet_New.Add("CY_CYCLE", "Dummy test set name");

            aLM_CORE.TestLab.TestSet.Create(testSet_New, "Root\\Dummy1\\Dummy2\\Dummy3\\Dummy4");

            testSet_New.Clear();
            testSet_New.Add("CY_CYCLE", "Dummy test set name 2");
            aLM_CORE.TestLab.TestSet.Create(testSet_New, "Root\\Dummy1\\Dummy2\\Dummy3\\Dummy4");

            TDAPIOLELib.List tdList = aLM_CORE.TestLab.TestLabFolders.FindTestSets("Root\\Dummy1\\Dummy2\\Dummy3\\Dummy4");
            foreach (TDAPIOLELib.TestSet testSet in tdList)
            {
                Console.WriteLine("TestSets under Root\\Dummy1\\Dummy2\\Dummy3\\Dummy4 : " + testSet.Name);
            }

            TDAPIOLELib.SysTreeNode sysTreeNode = aLM_CORE.TestLab.TestLabFolders.GetNodeObject("Root\\Dummy1\\Dummy2\\Dummy3\\Dummy4");
            Console.WriteLine("sysTreeNode Object : " + sysTreeNode.Path);

            TDAPIOLELib.TestSetFolder testSetFolder = aLM_CORE.TestLab.TestLabFolders.GetTestSetFolder("Root\\Dummy1\\Dummy2\\Dummy3\\Dummy4");
            Console.WriteLine("Parent Folder name : " + testSetFolder.Father.Name.ToString());

            aLM_CORE.TestLab.TestLabFolders.Rename("Root\\Dummy1\\Dummy2\\Dummy3", "Dummy4", "Renamed Dummy4");

            Console.WriteLine("Renamed a Folder");

            aLM_CORE.TestLab.TestLabFolders.Delete("Root\\Dummy1\\Dummy2\\Dummy3", "Renamed Dummy4");
            aLM_CORE.TestLab.TestLabFolders.Delete("Root\\Dummy1\\Dummy2", "Dummy3");
            aLM_CORE.TestLab.TestLabFolders.Delete("Root\\Dummy1", "Dummy2");
            aLM_CORE.TestLab.TestLabFolders.Delete("Root", "Dummy1");

            Console.WriteLine("Deleted all folders");

            Console.WriteLine("Done");
        }
Exemple #7
0
        public void Verify_TestFolder()
        {
            /////Test TestFolders.Cs
            TDAPIOLELib.TestFolder parent = aLM_CORE.TestPlan.TestFolders.Create("Subject", "Dummy1");
            aLM_CORE.TestPlan.TestFolders.CreateNewFolderPath("Subject\\Dummy1\\Dummy2\\Dummy3");
            aLM_CORE.TestPlan.TestFolders.CreateNewFolderPath("Subject\\Dummy1\\Dummy4\\Dummy5");
            aLM_CORE.TestPlan.TestFolders.CreateNewFolderPath("Subject\\Dummy1\\Dummy6\\Dummy7");

            Console.WriteLine("Folders Created Successfully in ALM");

            List <String> list = aLM_CORE.TestPlan.TestFolders.GetChildFolderNames("Subject\\Dummy1");

            foreach (String folderName in list)
            {
                Console.WriteLine("Folder Found under Subject\\Dummy1 : " + folderName);
            }

            list = aLM_CORE.TestPlan.TestFolders.GetChildFolderNames(parent);
            foreach (String folderName in list)
            {
                Console.WriteLine("Folder Found under Subject\\Dummy1 : " + folderName);
            }

            TDAPIOLELib.SysTreeNode sysTreeNode = aLM_CORE.TestPlan.TestFolders.GetNodeObject("Subject\\Dummy1\\Dummy6");
            Console.WriteLine("Count of folders under this folder is : " + sysTreeNode.Count);

            parent = aLM_CORE.TestPlan.TestFolders.GetFolderObject("Subject\\Dummy1\\Dummy6");
            Console.WriteLine("Count of folders under this folder is : " + parent.TestFolderFactory.NewList("").Count);

            //Create first test under folder
            Dictionary <String, String> TestN = new Dictionary <String, String>();

            TestN.Add("TS_NAME", "THIS IS DUMMUY TEST");
            TestN.Add("TS_STATUS", "Ready");
            aLM_CORE.TestPlan.Test.Create(TestN, "Subject\\Dummy1\\Dummy6");

            TestN.Clear();

            //Create second test inder folder
            TestN.Add("TS_NAME", "THIS IS DUMMUY TEST1");
            TestN.Add("TS_STATUS", "Design");
            aLM_CORE.TestPlan.Test.Create(TestN, "Subject\\Dummy1\\Dummy6");

            //Get the List of folders under test folder
            TDAPIOLELib.List Tdlist = aLM_CORE.TestPlan.TestFolders.GetTests("Subject\\Dummy1\\Dummy6");

            foreach (TDAPIOLELib.Test test in Tdlist)
            {
                Console.WriteLine("Test Found under Subject\\Dummy1\\Dummy6 : " + test.Name);
            }

            //Create test under Dummy 7, which is under dummy 6
            TestN.Clear();

            //Create second test inder folder
            TestN.Add("TS_NAME", "THIS IS DUMMUY TEST2");
            TestN.Add("TS_STATUS", "Design");
            TDAPIOLELib.Test test12 = aLM_CORE.TestPlan.Test.Create(TestN, "Subject\\Dummy1\\Dummy6\\Dummy7");

            Tdlist = aLM_CORE.TestPlan.TestFolders.GetTestsRecurcively("Subject\\Dummy1\\Dummy6");
            foreach (TDAPIOLELib.Test test in Tdlist)
            {
                Console.WriteLine("Test Found Name : " + test.Name + ", Path : " + aLM_CORE.TestPlan.Test.GetPath(test));
            }

            //Rename
            aLM_CORE.TestPlan.TestFolders.Rename("Subject\\Dummy1\\Dummy6\\Dummy7", "Renamed7");

            //Now read the tests again
            Tdlist = aLM_CORE.TestPlan.TestFolders.GetTestsRecurcively("Subject\\Dummy1\\Dummy6");
            foreach (TDAPIOLELib.Test test in Tdlist)
            {
                Console.WriteLine("After Renaming Folder Test Found Name : " + test.Name + ", Path : " + aLM_CORE.TestPlan.Test.GetPath(test));
            }

            aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1\\Dummy2\\Dummy3");
            aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1\\Dummy4\\Dummy5");
            aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1\\Dummy6\\Renamed7", true);

            aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1\\Dummy2");
            aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1\\Dummy4");
            aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1\\Dummy6");

            aLM_CORE.TestPlan.TestFolders.Delete("Subject\\Dummy1");

            aLM_CORE.TestPlan.Test.Delete(test12);

            Console.WriteLine("Deleted all folders");


            Console.WriteLine("Done");
        }
 /// <summary>
 /// Create a new folder under test lab
 /// <para/>returns true if successfull
 /// </summary>
 /// <param name="ParentFolderPath">Parent folder name</param>
 /// <param name="NewFolderName">New folder name</param>
 /// <returns>true if successfull</returns>
 public Boolean Create(String ParentFolderPath, String NewFolderName)
 {
     TDAPIOLELib.SysTreeNode OSysTreeNode = GetNodeObject(ParentFolderPath);
     OSysTreeNode.AddNode(NewFolderName);
     return(true);
 }