Forum Discussion

krogold's avatar
krogold
Regular Contributor
3 years ago
Solved

Setup script execution from another groovy step

Hello, I have several testCases in my project for which the setup script cleans the properties (generated dynamically during testCase execution). In order to clean my project before GIT commit, I wi...
  • krogold's avatar
    krogold
    3 years ago

    Finally I found out how to do it : it requires to modify context.ExecutionID

     

    /* check setup scripts
 if those contain 
testRunner.testCase.getPropertyList().each{
	testRunner.testCase.removeProperty(it.name)
}
it means that, prior to execution the setup script will clear data that will be (re)created during test execution
it means that this data is likely to be detected as a relevant modification in git though it is not
to avoid this this script will detect which test has such a setup script and will execute the setup script
in order to delete these dynamic properties
*/

testRunner.testCase.testSuite.project.testSuiteList.each
{
	suite ->
	name = suite.getName()

	if ((name.contains("USE CASES -"))||(name.contains("TOOLS - Configuration")))
	{
		suite.testCaseList.each{
			TC -> 
			if ((TC.setupScript != null)&&(TC.setupScript.contains("removeProperty")))
			{
				s_script = TC.setupScript 	// store the script
				TC.setSetupScript(null) 		// clear setup script

				// neutralize init_test_case
				sscript = s_script.replace("setup.init_test_case","//setup.init_test_case")
				sleep(1000)	
				TC.setSetupScript(sscript) 	// replace initial setup script

				// execute the modified setup script to clean properties without launching init
				context.ExecutionID = TC.config.id
				TC.runSetupScript(context, testRunner)

				// restore initial setupScript
				// re-enable setup init
				TC.setSetupScript(s_script)
			}
		}
	}
}

     

krogold's avatar
krogold
Regular Contributor

actually, it looks like it takes, as a context, the script that executes the research. Even if this one does not have a setup script, it executes the setup script of a target testCase but with its own characteristics (I've put a log that shows the name of the testCase that is run and it gives the one of my cleaning script !)

krogold's avatar
krogold
Regular Contributor
3 years ago

Finally I found out how to do it : it requires to modify context.ExecutionID

 

/* check setup scripts
 if those contain 
testRunner.testCase.getPropertyList().each{
	testRunner.testCase.removeProperty(it.name)
}
it means that, prior to execution the setup script will clear data that will be (re)created during test execution
it means that this data is likely to be detected as a relevant modification in git though it is not
to avoid this this script will detect which test has such a setup script and will execute the setup script
in order to delete these dynamic properties
*/

testRunner.testCase.testSuite.project.testSuiteList.each
{
	suite ->
	name = suite.getName()

	if ((name.contains("USE CASES -"))||(name.contains("TOOLS - Configuration")))
	{
		suite.testCaseList.each{
			TC -> 
			if ((TC.setupScript != null)&&(TC.setupScript.contains("removeProperty")))
			{
				s_script = TC.setupScript 	// store the script
				TC.setSetupScript(null) 		// clear setup script

				// neutralize init_test_case
				sscript = s_script.replace("setup.init_test_case","//setup.init_test_case")
				sleep(1000)	
				TC.setSetupScript(sscript) 	// replace initial setup script

				// execute the modified setup script to clean properties without launching init
				context.ExecutionID = TC.config.id
				TC.runSetupScript(context, testRunner)

				// restore initial setupScript
				// re-enable setup init
				TC.setSetupScript(s_script)
			}
		}
	}
}

 

  • krogold's avatar
    krogold
    Regular Contributor
    3 years ago

    Hello,

    unfortunately it seems that this solution does not work any longer on latest ReadyAPI versions (problems in 3.8.0 and 3.9.0) so I had to find another way to perform what I wanted, ie. to play a part of each testCase's setup script.

    The workaround I found is to modify temporarily the concerned tests :

    - I get the list of their testSteps id (I use config.id as a unique identifier) and status (disabled or not)

    - I disable all the testSteps

    - I store the setup script and modify it accordingly to my needs (in my case I neutralize an initialization call)

    - I store the teardown script and erase it

    - I run the test so it can clean all the unwanted properties that were created during the test runs (and that were needed for further testing)

    then I reset my tests back to their original configuration

    - I enable the testSteps according to their original status

    - I replace the setup script with its original value

    - I replace the teardown script with its original value

     

    here is the code associated:

    testRunner.testCase.testSuite.project.testSuiteList.each
{
    suite ->
    name = suite.getName()

    suite.testCaseList.each{
        TC -> 
        if ((TC.setupScript != null)&&(TC.setupScript.contains("removeProperty")))
        {
            log.info "clear lists from test '${TC.name}'"
            // store testSteps state
            ts_state_map = [:]
            //testRunner.testCase.gettes
            TC.getTestStepList().each{
                //log.info "${it.config.id} / " + it.isDisabled()
                ts_state_map[it.config.id] = it.isDisabled()
                // neutralize each testSTep
                if (it.isDisabled() != true)
                    it.setDisabled(true)
            }
            log.info ts_state_map

            // neutralize Setup script init phase
            s_script = TC.setupScript     // store the script
            TC.setSetupScript(null)         // clear setup script

            // neutralize init_test_case part
            sscript = s_script.replace("setup.init_test_case","//setup.init_test_case")
            sleep(1000)    
            TC.setSetupScript(sscript)     // replace initial setup script
            
            // neutralize TD script as well
            td_script = TC.tearDownScript
            TC.setTearDownScript(null)

            // execute testCase in order to execute only setup script
            def async = false
            TC.run (context.getProperties(), async)

            // restore TD script
            TC.setTearDownScript(td_script)

            // restore initial setupScript
            // re-enable setup init
            TC.setSetupScript(s_script)
            
            // restore testSteps state
            TC.getTestStepList().each{
                //log.info "${it.config.id} / " + it.isDisabled()
                // restore state
                if (ts_state_map[it.config.id] != true)
                    it.setDisabled(false)
            }
        }
    }
}