TestON/JenkinsFile/dependencies/JenkinsTestONTests.groovy - OnosSystemTest - Gitiles

 #!groovy

 // Copyright 2019 Open Networking Foundation (ONF)
 //
 // Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
 // the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
 // or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
 //
 //     TestON is free software: you can redistribute it and/or modify
 //     it under the terms of the GNU General Public License as published by
 //     the Free Software Foundation, either version 2 of the License, or
 //     (at your option) any later version.
 //
 //     TestON is distributed in the hope that it will be useful,
 //     but WITHOUT ANY WARRANTY; without even the implied warranty of
 //     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 //     GNU General Public License for more details.
 //
 //     You should have received a copy of the GNU General Public License
 //     along with TestON.  If not, see <http://www.gnu.org/licenses/>.

 allTests = [:]
 schedules = [:]
 branches = [:]

 // read all json files and save as maps
 def init(){
     def tests_buffer = readTrusted( "TestON/JenkinsFile/dependencies/tests.json" )
     def schedules_buffer = readTrusted( "TestON/JenkinsFile/dependencies/schedule.json" )
     def branches_buffer = readTrusted( "TestON/JenkinsFile/dependencies/branches.json" )
     allTests = readJSON text: tests_buffer
     schedules = readJSON text: schedules_buffer
     branches = readJSON text: branches_buffer
 }

 // ***************
 // General Methods
 // ***************

 // returns the entire set of TestON tests from the json file
 def getAllTests(){
     return allTests
 }

 // returns the entire set of schedules from the json file
 def getSchedules(){
     return schedules
 }

 // returns a list of days corresponding to the given schedule code
 def convertScheduleKeyToDays( sch ){
     return schedules[ sch ]
 }

 // given a test dictionary, returns a list of tests as a string
 def getTestListAsString( tests ){
     str_result = ""
     for ( String test in tests.keySet() ){
         str_result += test + ","
     }
     return str_result[ 0..-2 ]
 }

 // given a list of tests as a string, returns the list of tests as a map, similar formatted to tests.json
 def getTestsFromStringList( list ){
     testsResult = [:]
     for ( item in list ){
         if ( allTests.keySet().contains( item ) ){
             testsResult.put( item, allTests[ item ] )
         }
     }
     return testsResult
 }

 // Get a given test property from the schedules list for a given test
 // Example: getTestScheduleProperty( "FUNCflow", "nodeLabel" ) gets all node labels for each branch
 def getTestScheduleProperty( test_name, property, tests=[:] ){
     schedulePropertyResult = [:]

     if ( tests == [:] ){
         tests = allTests
     }
     for ( subDict in tests[ test_name ][ "schedules" ] ){
         schedulePropertyResult.put( subDict[ "branch" ], subDict[ property ] )
     }

     return schedulePropertyResult
 }

 // ********
 // Branches
 // ********

 // returns all branches from branches.json
 def getAllBranches(){
     return branches
 }

 // given a day, returns all branches that are run on that day
 def getBranchesFromDay( day, tests=[:] ){
     branchesFromDayResult = []
     if ( tests == [:] ){
         tests = allTests
     }
     validSchedules = getValidSchedules( day )

     for ( String key in tests.keySet() ){
         for ( subDict in tests[ key ][ "schedules" ] ){
             sch = subDict[ "day" ]
             new_branch = convertBranchCodeToBranch( subDict[ "branch" ], false )
             if ( validSchedules.contains( sch ) && !branchesFromDayResult.contains( new_branch ) ){
                 branchesFromDayResult += new_branch
             }
         }
     }
     return branchesFromDayResult
 }

 // Converts a branch code to an actual ONOS branch.
 // Example: converts onos-1.x to onos-1.15
 def convertBranchCodeToBranch( branch_code, withPrefix=true ){
     for ( String branch_type in branches.keySet() ){
         for ( String b in branches[ branch_type ].keySet() ){
             if ( branch_code == b ){
                 return withPrefix ? ( "onos-" + branches[ branch_type ][ b ] ) : branches[ branch_type ][ b ]
             }
         }
     }
     return branch_code
 }

 // given a branch, returns the corresponding branch code (hack)
 // Example: given "onos-1.15", returns "onos-1.x"
 def convertBranchToBranchCode( branch ){
     if ( branch == "master" ){
         return branch
     } else if ( branch.substring( 0, 1 ) == "o" ) {
         return branch.substring( 0, 6 ) + ".x"
     } else {
         return "onos-" + branch.substring( 0, 1 ) + ".x"
     }
 }

 // given a branch without a prefix, returns the branch with the "onos-" prefix
 def addPrefixToBranch( branchNoPrefix ){
     if ( branchNoPrefix == "master" ){
         return "master"
     } else {
         return "onos-" + branchNoPrefix
     }
 }

 // given a branch with the prefix "onos-", returns the branch without the prefix
 def removePrefixFromBranch( branchWithPrefix ){
     return branchWithPrefix.minus( "onos-" )
 }

 // *************
 // Test Category
 // *************

 // given a test category ("FUNC", "HA", etc.), returns all tests associated with that category
 def getTestsFromCategory( category, tests=[:] ){
     testsFromCategoryResult = [:]
     if ( tests == [:] ){
         tests = allTests
     }
     for ( String test_name in tests.keySet() ){
         if ( getCategoryOfTest( test_name ) == category ){
             testsFromCategoryResult.put( test_name, tests[ test_name ] )
         }
     }
     return testsFromCategoryResult
 }

 // given the test name, returns the category (FUNC, HA, etc.) of that test
 def getCategoryOfTest( test_name, tests=[:] ){
     if ( tests == [:] ){
         tests = allTests
     }
     return tests[ test_name ][ "category" ]
 }

 // returns all categories of all tests, or the given test list
 def getAllTestCategories( tests=[:] ){
     testCategoriesResult = []
     if ( tests == [:] ){
         tests = allTests
     }
     for ( String test_name in tests.keySet() ){
         category = getCategoryOfTest( test_name, tests )
         if ( !testCategoriesResult.contains( category ) ){
             testCategoriesResult += category
         }
     }
     return testCategoriesResult
 }

 // ********************
 // Test Schedule / Days
 // ********************

 // given a day, returns schedules that contain that day
 def getValidSchedules( day ){
     validSchedules = []
     for ( String key in schedules.keySet() ){
         if ( schedules[ key ].contains( day ) ){
             validSchedules += key
         }
     }
     return validSchedules
 }

 // given a day, returns all tests that run on the given day on the given branch
 def getTestsFromDay( day, tests=[:] ){
     resultDict = [:]
     if ( tests == [:] ){
         tests = allTests
     }
     validSchedules = getValidSchedules( day )
     for ( String key in tests.keySet() ){
         scheduleProperty = getTestScheduleProperty( key, "day", tests )
         for ( b in scheduleProperty.keySet() ){
             if ( validSchedules.contains( scheduleProperty[ b ] ) ){
                 resultDict.put( key, tests[ key ] )
                 break
             }
         }
     }
     return resultDict
 }

 // **********
 // Node Label
 // **********

 // Given a node label and branch, return all tests that run on that node.
 def getTestsFromNodeLabel( nodeLabel, branch, tests=[:] ){
     nodeLabelTestsResult = [:]
     if ( tests == [:] ){
         tests = allTests
     }
     for ( String key in tests.keySet() ){
         branchNodeLabelMap = getTestScheduleProperty( key, "nodeLabel", tests )
         if ( branchNodeLabelMap[ convertBranchToBranchCode( branch ) ] == nodeLabel ){
             nodeLabelTestsResult.put( key, tests[ key ] )
         }
     }
     return nodeLabelTestsResult
 }

 // Given a test name and branch, return the node label associated.
 def getNodeLabel( test_name, branch, tests=[:] ){
     if ( tests == [:] ){
         tests = allTests
     }
     result = getTestScheduleProperty( test_name, "nodeLabel", tests )
     if ( result == [:] ){
         return "UNKNOWN"
     } else {
         return result[ convertBranchToBranchCode( branch ) ]
     }
 }

 // given a branch, returns all nodeLabels from all tests, or a given test list
 def getAllNodeLabels( branch, tests=[:] ){
     nodeLabelResult = []
     if ( tests == [:] ){
         tests = allTests
     }
     for ( test_name in tests.keySet() ){
         nodeLabel = getNodeLabel( test_name, branch, tests )
         if ( !nodeLabelResult.contains( nodeLabel ) && nodeLabel != null ){
             nodeLabelResult += nodeLabel
         }
     }
     return nodeLabelResult
 }

 return this
	#!groovy

	// Copyright 2019 Open Networking Foundation (ONF)
	//
	// Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
	// the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
	// or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
	//
	// TestON is free software: you can redistribute it and/or modify
	// it under the terms of the GNU General Public License as published by
	// the Free Software Foundation, either version 2 of the License, or
	// (at your option) any later version.
	//
	// TestON is distributed in the hope that it will be useful,
	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	// GNU General Public License for more details.
	//
	// You should have received a copy of the GNU General Public License
	// along with TestON. If not, see <http://www.gnu.org/licenses/>.

	allTests = [:]
	schedules = [:]
	branches = [:]

	// read all json files and save as maps
	def init(){
	def tests_buffer = readTrusted( "TestON/JenkinsFile/dependencies/tests.json" )
	def schedules_buffer = readTrusted( "TestON/JenkinsFile/dependencies/schedule.json" )
	def branches_buffer = readTrusted( "TestON/JenkinsFile/dependencies/branches.json" )
	allTests = readJSON text: tests_buffer
	schedules = readJSON text: schedules_buffer
	branches = readJSON text: branches_buffer
	}

	// ***************
	// General Methods
	// ***************

	// returns the entire set of TestON tests from the json file
	def getAllTests(){
	return allTests
	}

	// returns the entire set of schedules from the json file
	def getSchedules(){
	return schedules
	}

	// returns a list of days corresponding to the given schedule code
	def convertScheduleKeyToDays( sch ){
	return schedules[ sch ]
	}

	// given a test dictionary, returns a list of tests as a string
	def getTestListAsString( tests ){
	str_result = ""
	for ( String test in tests.keySet() ){
	str_result += test + ","
	}
	return str_result[ 0..-2 ]
	}

	// given a list of tests as a string, returns the list of tests as a map, similar formatted to tests.json
	def getTestsFromStringList( list ){
	testsResult = [:]
	for ( item in list ){
	if ( allTests.keySet().contains( item ) ){
	testsResult.put( item, allTests[ item ] )
	}
	}
	return testsResult
	}

	// Get a given test property from the schedules list for a given test
	// Example: getTestScheduleProperty( "FUNCflow", "nodeLabel" ) gets all node labels for each branch
	def getTestScheduleProperty( test_name, property, tests=[:] ){
	schedulePropertyResult = [:]

	if ( tests == [:] ){
	tests = allTests
	}
	for ( subDict in tests[ test_name ][ "schedules" ] ){
	schedulePropertyResult.put( subDict[ "branch" ], subDict[ property ] )
	}

	return schedulePropertyResult
	}

	// ********
	// Branches
	// ********

	// returns all branches from branches.json
	def getAllBranches(){
	return branches
	}

	// given a day, returns all branches that are run on that day
	def getBranchesFromDay( day, tests=[:] ){
	branchesFromDayResult = []
	if ( tests == [:] ){
	tests = allTests
	}
	validSchedules = getValidSchedules( day )

	for ( String key in tests.keySet() ){
	for ( subDict in tests[ key ][ "schedules" ] ){
	sch = subDict[ "day" ]
	new_branch = convertBranchCodeToBranch( subDict[ "branch" ], false )
	if ( validSchedules.contains( sch ) && !branchesFromDayResult.contains( new_branch ) ){
	branchesFromDayResult += new_branch
	}
	}
	}
	return branchesFromDayResult
	}

	// Converts a branch code to an actual ONOS branch.
	// Example: converts onos-1.x to onos-1.15
	def convertBranchCodeToBranch( branch_code, withPrefix=true ){
	for ( String branch_type in branches.keySet() ){
	for ( String b in branches[ branch_type ].keySet() ){
	if ( branch_code == b ){
	return withPrefix ? ( "onos-" + branches[ branch_type ][ b ] ) : branches[ branch_type ][ b ]
	}
	}
	}
	return branch_code
	}

	// given a branch, returns the corresponding branch code (hack)
	// Example: given "onos-1.15", returns "onos-1.x"
	def convertBranchToBranchCode( branch ){
	if ( branch == "master" ){
	return branch
	} else if ( branch.substring( 0, 1 ) == "o" ) {
	return branch.substring( 0, 6 ) + ".x"
	} else {
	return "onos-" + branch.substring( 0, 1 ) + ".x"
	}
	}

	// given a branch without a prefix, returns the branch with the "onos-" prefix
	def addPrefixToBranch( branchNoPrefix ){
	if ( branchNoPrefix == "master" ){
	return "master"
	} else {
	return "onos-" + branchNoPrefix
	}
	}

	// given a branch with the prefix "onos-", returns the branch without the prefix
	def removePrefixFromBranch( branchWithPrefix ){
	return branchWithPrefix.minus( "onos-" )
	}

	// *************
	// Test Category
	// *************

	// given a test category ("FUNC", "HA", etc.), returns all tests associated with that category
	def getTestsFromCategory( category, tests=[:] ){
	testsFromCategoryResult = [:]
	if ( tests == [:] ){
	tests = allTests
	}
	for ( String test_name in tests.keySet() ){
	if ( getCategoryOfTest( test_name ) == category ){
	testsFromCategoryResult.put( test_name, tests[ test_name ] )
	}
	}
	return testsFromCategoryResult
	}

	// given the test name, returns the category (FUNC, HA, etc.) of that test
	def getCategoryOfTest( test_name, tests=[:] ){
	if ( tests == [:] ){
	tests = allTests
	}
	return tests[ test_name ][ "category" ]
	}

	// returns all categories of all tests, or the given test list
	def getAllTestCategories( tests=[:] ){
	testCategoriesResult = []
	if ( tests == [:] ){
	tests = allTests
	}
	for ( String test_name in tests.keySet() ){
	category = getCategoryOfTest( test_name, tests )
	if ( !testCategoriesResult.contains( category ) ){
	testCategoriesResult += category
	}
	}
	return testCategoriesResult
	}

	// ********************
	// Test Schedule / Days
	// ********************

	// given a day, returns schedules that contain that day
	def getValidSchedules( day ){
	validSchedules = []
	for ( String key in schedules.keySet() ){
	if ( schedules[ key ].contains( day ) ){
	validSchedules += key
	}
	}
	return validSchedules
	}

	// given a day, returns all tests that run on the given day on the given branch
	def getTestsFromDay( day, tests=[:] ){
	resultDict = [:]
	if ( tests == [:] ){
	tests = allTests
	}
	validSchedules = getValidSchedules( day )
	for ( String key in tests.keySet() ){
	scheduleProperty = getTestScheduleProperty( key, "day", tests )
	for ( b in scheduleProperty.keySet() ){
	if ( validSchedules.contains( scheduleProperty[ b ] ) ){
	resultDict.put( key, tests[ key ] )
	break
	}
	}
	}
	return resultDict
	}

	// **********
	// Node Label
	// **********

	// Given a node label and branch, return all tests that run on that node.
	def getTestsFromNodeLabel( nodeLabel, branch, tests=[:] ){
	nodeLabelTestsResult = [:]
	if ( tests == [:] ){
	tests = allTests
	}
	for ( String key in tests.keySet() ){
	branchNodeLabelMap = getTestScheduleProperty( key, "nodeLabel", tests )
	if ( branchNodeLabelMap[ convertBranchToBranchCode( branch ) ] == nodeLabel ){
	nodeLabelTestsResult.put( key, tests[ key ] )
	}
	}
	return nodeLabelTestsResult
	}

	// Given a test name and branch, return the node label associated.
	def getNodeLabel( test_name, branch, tests=[:] ){
	if ( tests == [:] ){
	tests = allTests
	}
	result = getTestScheduleProperty( test_name, "nodeLabel", tests )
	if ( result == [:] ){
	return "UNKNOWN"
	} else {
	return result[ convertBranchToBranchCode( branch ) ]
	}
	}

	// given a branch, returns all nodeLabels from all tests, or a given test list
	def getAllNodeLabels( branch, tests=[:] ){
	nodeLabelResult = []
	if ( tests == [:] ){
	tests = allTests
	}
	for ( test_name in tests.keySet() ){
	nodeLabel = getNodeLabel( test_name, branch, tests )
	if ( !nodeLabelResult.contains( nodeLabel ) && nodeLabel != null ){
	nodeLabelResult += nodeLabel
	}
	}
	return nodeLabelResult
	}

	return this