cancel
Showing results for 
Search instead for 
Did you mean: 

select/run test by test item using command line

select/run test by test item using command line

In the same fashion that you can select and then run a test item or test item group while viewing the project in TestComplete, it would similarly be useful to be able to select a project test item or test item group and run it with the TestComplete or TestExecute using the command line.  So if the project items look like this:

 

project.PNG

 

So we might run some tests like this:

 

TestExecute.exe TestProject14.pjs /run /project:TestProject14 /projectitem: Group1

TestExecute.exe TestProject14.pjs /run /project:TestProject14 /projectitem: ProjectTestItem2

TestExecute.exe TestProject14.pjs /run /project:TestProject14 /projectitem: Group2

 

 

 

Perhaps overloading the /projectitem flag is not a good idea?  Then use a new flag, say, ... "/item".

 

TestExecute.exe TestProject14.pjs /run /project:TestProject14 /item: Group1

TestExecute.exe TestProject14.pjs /run /project:TestProject14 /item: ProjectTestItem2

TestExecute.exe TestProject14.pjs /run /project:TestProject14 /item: Group2

 

Should we honor or disregard the Enabled selection for the items and groups in the project?  Or perhaps honor it by default, and force execution if a "/force" flag is used?  For example, where TestItem2 is not enabled:

 

TestExecute.exe TestProject14.pjs /run /project:TestProject14 /item: ProjectTestItem2 /force

 

 

10 Comments
Frequent Contributor

Yes, I like this idea very much.

Contributor

There is a way you can do this currently. See this article here:

 

http://support.smartbear.com/viewarticle/54654/

 

Which can then be put into a console application as well to run as a scheduled task:

 

    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                Console.WriteLine("Expecting arguments");
                Console.Write("Press any key to continue...");
                Console.ReadLine();
            }
            else
            {
                string testItemGroup = "";
                string project = "";

                for (int i = 0; i < args.Length; i++)
                {
                  if (Regex.IsMatch(args[i], @"\/testitemgroup:", RegexOptions.IgnoreCase))
                  {
                      testItemGroup = Regex.Replace(args[i], @"\/testitemgroup:", "", RegexOptions.IgnoreCase);
                  }
                  if (Regex.IsMatch(args[i], @"\/p:", RegexOptions.IgnoreCase))
                  {
                      project = Regex.Replace(args[i], @"\/p:", "", RegexOptions.IgnoreCase);
                  }
                  if (Regex.IsMatch(args[i], @"\/project:", RegexOptions.IgnoreCase))
                  {
                      project = Regex.Replace(args[i], @"\/project:", "", RegexOptions.IgnoreCase);
                  }                
                }

                TestFunc(args[0], project, testItemGroup);
            }
            
        }

        private static void TestFunc(string projectSuite, string project, string testItemGroup)
        {
            const string TCProgID = "TestComplete.TestCompleteApplication.10";
            object TestCompleteObject = null;

            // Obtains access to TestComplete
            try
            {
                TestCompleteObject = Marshal.GetActiveObject(TCProgID);
            }
            catch
            {
                try
                {
                    TestCompleteObject = Activator.CreateInstance(Type.GetTypeFromProgID(TCProgID));
                }
                catch
                {
                }
            }

            if (TestCompleteObject == null) return;

            // Obtains ITestCompleteCOMManager 
            TestComplete.ITestCompleteCOMManager TestCompleteManager = (TestComplete.ITestCompleteCOMManager)TestCompleteObject;
            // Obtains Integration object
            TestComplete.ItcIntegration IntegrationObject = TestCompleteManager.Integration;

            // We have a reference to the integration object.
            // Now we can use its methods and properties to automate TestComplete.

            // Loads the project suite
            IntegrationObject.OpenProjectSuite(projectSuite);

            // Checks whether the project suite was opened
            // If the project suite cannot be opened, closes TestComplete
            if (!IntegrationObject.IsProjectSuiteOpened())
            {
                Console.WriteLine("Could not open the project suite.");
                // Closes TestComplete
                TestCompleteManager.Quit();
                // Releases COM objects
                Marshal.ReleaseComObject(IntegrationObject);
                Marshal.ReleaseComObject(TestCompleteManager);
                Marshal.ReleaseComObject(TestCompleteObject);
                return;
            }

            try
            {
                // Runs the test
                IntegrationObject.RunProjectTestItem(project, testItemGroup);

                // Waits until testing is over
                while (IntegrationObject.IsRunning())
                    Thread.Sleep(5000);

                // Check the results
                switch (IntegrationObject.GetLastResultDescription().Status)
                {
                    case TestComplete.TC_LOG_STATUS.lsOk:
                        Console.WriteLine("The test run finished successfully.");
                        break;
                    case TestComplete.TC_LOG_STATUS.lsWarning:
                        Console.WriteLine("Warning messages were posted to the test log.");
                        break;
                    case TestComplete.TC_LOG_STATUS.lsError:
                        Console.WriteLine("Error messages were posted to the test log.");
                        break;
                }
            }
            catch (System.Runtime.InteropServices.COMException ex)
            {
                Console.WriteLine("An exception occurred: " + ex.Message);
            }
            finally
            {
              
                // Closes TestComplete
                TestCompleteManager.Quit();
                // Releases COM objects
                Marshal.ReleaseComObject(IntegrationObject);
                Marshal.ReleaseComObject(TestCompleteManager);
                Marshal.ReleaseComObject(TestCompleteObject);
            }
        }
    }

 

 

Valued Contributor

Currently only Project items could be run from command line.

If test items could be run, it would be really usefull.........

Staff
Status changed to: Selected for Development
 
Super Contributor

Try this, it may be help you and achieved your requirement partially.

 

echo**********************************************************************
echo                     TEST SUITE ITEMS
echo**********************************************************************

echo TP001_TestItem1
echo TP002_TestItem2
echo TP003_TestItem3
echo TP004_TestItem4
echo TP005_TestItem5

echo **********************************************************************


set /p "Input = Please select any one suite, from TEST SUITE ITEMS"
echo %Input %
"C:\Program Files (x86)\SmartBear\TestExecute 11\Bin\TestExecute.exe" "C:\XZY Automation\ProjectSuites\XZY_Automation\XZY_Automation.pjs" /r /p:XZY_Automation /u:TP_XZY /rt:%Input % /exit /SilentMode

  

 

Save above code as .bat and run it. it will ask you to select a specific TestItem. when you enter your specific item, TestExecute run it.

Regular Visitor

Hi,

 

We solved this issue by using the following Gradle/Groovy-based code, that updates the TC12 project to enable only the wanted test items to run:

 

 

    def patchMdsFile(Project project, File mdsFile) {
        def testItemToEnable = project.properties.testItem
        if (!testItemToEnable)
            throw new GradleException('Please set the `testItem` parameter (string containing the name of the test item to enable).')
        project.logger.lifecycle("Enabling test item ${testItemToEnable} in ${mdsFile}...")

        def mdsRoot = new XmlParser(false, false, true).parse(mdsFile)

        def projectVersion = VersionNumber.parse(mdsRoot.@version.toString())
        project.logger.info("Detected project version ${projectVersion}")

        if (projectVersion < VersionNumber.parse('12.0.0'))
            throw new GradleException("The project file uses an unsupported TestComplete version (${projectVersion}). Please upgrade your project to version 12 or above.")

        mdsRoot.testItems.children.testItem.each {
            def isEnabled = it.@name == testItemToEnable
            project.logger.info("Test item '${it.@name}' enabled flag: ${isEnabled}")

            it.@enabled = isEnabled
        }

        mdsFile.write(XmlUtil.serialize(mdsRoot))
    }

 

Contributor

So I stumbled across the ability to run TestComplete and TestExecute via command line.

 

The issue I'm seeing is that I don't see an easy way to run TC and TE by group. I've attached a screen shot of what my project file looks like. I'd like the ability to run just the SmokeTest group or the Day2Tests group, but I haven't seen a way to do it.

Moderator
Contributor

Yes! That would exactly what I'm looking for. I'm going to poke through some of the code examples they have to see if I can get one of them to work.  I was trying that before, but it kept having problems actually launching Test Execute.

Status changed to: Implemented

Hello,

 

This functionality has been implemented in TestComplete 12.40.

Announcements
Welcome to the TestComplete Feature Requests board!

Here you can review submitted feature requests and vote up the ones you like! If you can't find the feature you want - go ahead and suggest your own idea. Ideas with the highest rating can be implemented in the product.

Check out the Create a Feature Request guide for more information.
New Here?
Join us and watch the welcome video:
Announcements