def test_cluster_analysis(self):
'''test_cluster_analysis'''
if Configuration.DEBUG == True: print(".....ClusterAnalysisTestCase.test_cluster_analysis")
arcpy.ImportToolbox(self.toolboxUnderTest, self.toolboxUnderTestAlias)
outputClusterFeatures = os.path.join(Configuration.incidentResultGDB, "outputClusters")
# Delete the feature class used to load if already exists
if arcpy.Exists(outputClusterFeatures) :
arcpy.Delete_management(outputClusterFeatures)
runToolMessage = "Running tool (Cluster Analysis)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
distance = "500 Meters"
try:
# Tools have different parameter order in Pro vs. ArcMap
if Configuration.Platform == Configuration.PLATFORM_PRO :
arcpy.ClusterAnalysis_iaTools(self.inputPointsFeatures, distance, outputClusterFeatures)
else:
arcpy.ClusterAnalysis_iaTools(self.inputPointsFeatures, outputClusterFeatures, distance)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except Exception as e:
UnitTestUtilities.handleGeneralError(e)
clusterCount = int(arcpy.GetCount_management(outputClusterFeatures).getOutput(0))
self.assertGreaterEqual(clusterCount, int(10))
def setUp(self):
if Configuration.DEBUG == True: print(" SubSpecificationsTestCase.setUp")
UnitTestUtilities.checkArcPy()
self.maritimeDataGDB = os.path.join(Configuration.maritimeDataPath, "Maritime Decision Aid Tools.gdb")
self.subSpecsTable = os.path.join(self.maritimeDataGDB, "Sub_Specs")
UnitTestUtilities.checkFilePaths([Configuration.maritimeDataPath, Configuration.maritime_DesktopToolboxPath, Configuration.maritime_ProToolboxPath])
def test_incident_table_to_point(self, toolboxPath):
try:
if Configuration.DEBUG == True: print(" IncidentTableToPointTestCase.test_incident_table_to_point")
arcpy.ImportToolbox(toolboxPath, "iaTools")
runToolMessage = "Running tool (Incident Table To Point)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
coordFormat = "MGRS"
xField = "MGRS"
yField = "MGRS"
outputTable = os.path.join(Configuration.incidentScratchGDB, "outputTable")
arcpy.IncidentTableToPoint_iaTools(self.inputTable, coordFormat, xField, yField, outputTable)
result = arcpy.GetCount_management(outputTable)
featureCount = int(result.getOutput(0))
self.assertEqual(featureCount, int(5532))
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
def test_hot_spots_by_area(self, toolboxPath):
try:
if Configuration.DEBUG == True: print(" HotSpotsByAreaTestCase.test_hot_spots_by_area")
arcpy.ImportToolbox(toolboxPath, "iaTools")
runToolMessage = "Running tool (Hot Spots By Area)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
incidentFieldName = "district"
outputWorkspace = Configuration.incidentDataPath
# second parameter: inputIncidents must be a Feature Layer
arcpy.MakeFeatureLayer_management(self.inputIncidents, "incidentsLayer")
arcpy.HotSpotsByArea_iaTools(self.inputAOIFeatures, "incidentsLayer", incidentFieldName, outputWorkspace)
self.assertTrue(arcpy.Exists(outputWorkspace))
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
def main():
''' main test logic '''
if Configuration.DEBUG == True:
print("TestRunner.py - main")
else:
print("Debug messaging is OFF")
# setup logger
logName = None
if not logFileFromBAT == None:
logName = logFileFromBAT
Configuration.Logger = UnitTestUtilities.initializeLogger(logFileFromBAT)
else:
logName = UnitTestUtilities.getLoggerName()
Configuration.Logger = UnitTestUtilities.initializeLogger(logName)
print("Logging results to: " + str(logName))
UnitTestUtilities.setUpLogFileHeader()
result = runTestSuite()
logTestResults(result)
print("END OF TEST =========================================\n")
if result.wasSuccessful():
#tests successful
sys.exit(0)
else:
# test errors or failures
sys.exit(1)
return
def main():
''' main test logic '''
print("TestRunner.py - main")
if Configuration.DEBUG == True:
print("Debug messaging is ON")
logLevel = logging.DEBUG
else:
print("Debug messaging is OFF")
logLevel = logging.INFO
# setup logger
if not logFileFromBAT == None:
Configuration.Logger = UnitTestUtilities.initializeLogger(logFileFromBAT, logLevel)
else:
Configuration.GetLogger(logLevel)
print("Logging results to: " + str(Configuration.LoggerFile))
UnitTestUtilities.setUpLogFileHeader()
result = runTestSuite()
logTestResults(result)
return result.wasSuccessful()
def testClearingOperationsNumberFeatures_NoOutputParam(self):
if Configuration.DEBUG == True:print(".....ClearingOperationsNumberFeaturesTestCase.testClearingOperationsNumberFeatures_NoOutputParam")
print("Importing toolbox...")
arcpy.ImportToolbox(self.toolboxUnderTest)
arcpy.env.overwriteOutput = True
########################################################
# Test steps:
# 1. Copy a known feature class in the AOI to the scratch GDB
# 2. Add a new "Number" field (so will be blank)
# 3. Run the NumberFeatures tool
# 4. Verify the output
########################################################
#inputs
fieldToNumber = "NumberNewField"
inputPoints = os.path.join(self.scratchGDB, 'numFieldsInput_NoOutput')
# Copy the features of the original input FC into the scratch GDB
arcpy.CopyFeatures_management(self.pointFeatures, inputPoints)
arcpy.AddField_management(inputPoints, fieldToNumber, "LONG")
# Start Test
runToolMsg="Running tool (Number Features)"
arcpy.AddMessage(runToolMsg)
Configuration.Logger.info(runToolMsg)
toolOutput = None
try:
#Calling the NumberFeatures_ClearingOperations Script Tool
#No output parameter
toolOutput = arcpy.NumberFeatures_clrops(self.inputArea, inputPoints, \
fieldToNumber)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
# 1: Check the expected return value (output feature class)
# TODO: this return value may change in the future, and this check may need updated
expectedOutput = ""
if toolOutput is None:
returnedValue = "BAD"
else:
returnedValue = toolOutput.getOutput(0)
self.assertEqual(returnedValue, expectedOutput)
#2: Check the Output Feature class has no rows without a null Number
outputLayer = "Number_NoOutput"
arcpy.MakeFeatureLayer_management(inputPoints, outputLayer)
query = '(' + fieldToNumber + ' is NOT NULL)'
arcpy.SelectLayerByAttribute_management(outputLayer, "NEW_SELECTION", query)
recordCount = int(arcpy.GetCount_management(outputLayer).getOutput(0))
# Important only 90 of 120 records are in the area of interest
self.assertEqual(recordCount, int(90))
def setUp(self):
if Configuration.DEBUG == True: print(" SubsetRasterWorkspaceTestCase.setUp")
UnitTestUtilities.checkArcPy()
# DO NOT run data download again; dependent data is needed from ImportCRUToRasterTestCase
self.sourceWorkspace = os.path.join(Configuration.suitabilityDataPath, "CRURasters.gdb")
self.targetWorkspace = os.path.join(Configuration.suitabilityDataPath, "SubsetRasters.gdb")
UnitTestUtilities.checkFilePaths([Configuration.suitabilityDataPath, Configuration.maow_ToolboxPath, self.sourceWorkspace, self.targetWorkspace])
def setUp(self):
if Configuration.DEBUG == True: print(" ImportCRUToRasterTestCase.setUp")
UnitTestUtilities.checkArcPy()
Configuration.suitabilityDataPath = DataDownload.runDataDownload(Configuration.suitabilityPaths, "MilitaryAspectsOfWeatherTestData", Configuration.maowURL)
self.inputCRUFolder = os.path.join(Configuration.suitabilityDataPath, "CRUdata")
self.outputWorkspace = os.path.join(Configuration.suitabilityDataPath, "CRURasters.gdb")
UnitTestUtilities.checkFilePaths([Configuration.suitabilityDataPath, Configuration.maow_ToolboxPath, self.outputWorkspace])
def setUp(self):
if Configuration.DEBUG == True: print(".....IncidentHotSpotsTestCase.setUp")
UnitTestUtilities.checkArcPy()
Configuration.incidentDataPath = DataDownload.runDataDownload(Configuration.patternsPaths, Configuration.incidentGDBName, Configuration.incidentURL)
if (Configuration.incidentScratchGDB == None) or (not arcpy.Exists(Configuration.incidentScratchGDB)):
Configuration.incidentScratchGDB = UnitTestUtilities.createScratch(Configuration.incidentDataPath)
Configuration.incidentInputGDB = os.path.join(Configuration.incidentDataPath, Configuration.incidentGDBName)
UnitTestUtilities.checkFilePaths([Configuration.incidentDataPath, Configuration.incidentInputGDB, Configuration.patterns_ProToolboxPath, Configuration.patterns_DesktopToolboxPath])
self.inputPointFeatures = os.path.join(Configuration.incidentInputGDB, "Incidents")
self.inputBoundaryFeatures = os.path.join(Configuration.incidentInputGDB, "Districts")
def setUp(self):
if Configuration.DEBUG == True: print(" FindSubmarinesTestCase.setUp")
UnitTestUtilities.checkArcPy()
Configuration.maritimeDataPath = DataDownload.runDataDownload(Configuration.suitabilityPaths, Configuration.maritimeGDBName, Configuration.maritimeURL)
if(Configuration.maritimeScratchGDB == None) or (not arcpy.Exists(Configuration.maritimeScratchGDB)):
Configuration.maritimeScratchGDB = UnitTestUtilities.createScratch(Configuration.maritimeDataPath)
self.useableCanyons = os.path.join(Configuration.maritimeScratchGDB, "canyonsOutput")
UnitTestUtilities.checkFilePaths([Configuration.maritimeDataPath, Configuration.maritime_DesktopToolboxPath, Configuration.maritime_ProToolboxPath])
def GetLogger(logLevel = logging.DEBUG) :
global Logger
if Logger is None:
import UnitTestUtilities
logName = UnitTestUtilities.getLoggerName()
Logger = UnitTestUtilities.initializeLogger(logName, logLevel)
return Logger
def setUp(self):
if Configuration.DEBUG == True: print(" FarthestOnCircleTestCase.setUp")
UnitTestUtilities.checkArcPy()
Configuration.maritimeDataPath = DataDownload.runDataDownload(Configuration.suitabilityPaths, Configuration.maritimeGDBName, Configuration.maritimeURL)
if(Configuration.maritimeScratchGDB == None) or (not arcpy.Exists(Configuration.maritimeScratchGDB)):
Configuration.maritimeScratchGDB = UnitTestUtilities.createScratch(Configuration.maritimeDataPath)
self.maritimeDataGDB = os.path.join(Configuration.maritimeDataPath, "Maritime Decision Aid Tools.gdb")
self.position = os.path.join(self.maritimeDataGDB, "Vessel")
self.hoursOfTransit = os.path.join(Configuration.maritimeScratchGDB, "hoursOutput")
UnitTestUtilities.checkFilePaths([Configuration.maritimeDataPath, Configuration.maritime_DesktopToolboxPath, Configuration.maritime_ProToolboxPath])
def setUp(self):
if Configuration.DEBUG == True: print(" SubDepthRestrictionSuitabilityTestCase.setUp")
UnitTestUtilities.checkArcPy()
Configuration.maritimeDataPath = DataDownload.runDataDownload(Configuration.suitabilityPaths, Configuration.maritimeGDBName, Configuration.maritimeURL)
if(Configuration.maritimeScratchGDB == None) or (not arcpy.Exists(Configuration.maritimeScratchGDB)):
Configuration.maritimeScratchGDB = UnitTestUtilities.createScratch(Configuration.maritimeDataPath)
self.maritimeDataGDB = os.path.join(Configuration.maritimeDataPath, "Maritime Decision Aid Tools.gdb")
self.bathymetry = os.path.join(self.maritimeDataGDB, "SoCalDepthsGEBCO")
self.subDepthOutput = os.path.join(Configuration.maritimeScratchGDB, "SubDepth")
UnitTestUtilities.checkFilePaths([Configuration.maritimeDataPath, Configuration.maritime_DesktopToolboxPath, Configuration.maritime_ProToolboxPath])
def test_sub_depth_restriction_suitability(self, toolboxPath):
try:
if Configuration.DEBUG == True: print(" SubDepthRestrictionSuitabilityTestCase.test_sub_depth_restriction_suitability")
runToolMessage = "Running tool (Sub Depth Restriction Suitability)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
def test_sub_specifications(self, toolboxPath):
try:
if Configuration.DEBUG == True: print(" SubSpecificationsTestCase.test_sub_specifications")
runToolMessage = "Running tool (Sub Specifications)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
def setUp(self):
if Configuration.DEBUG == True: print(" VisibilityRangeAtSeaTestCase.setUp")
UnitTestUtilities.checkArcPy()
Configuration.maritimeDataPath = DataDownload.runDataDownload(Configuration.suitabilityPaths, Configuration.maritimeGDBName, Configuration.maritimeURL)
if(Configuration.maritimeScratchGDB == None) or (not arcpy.Exists(Configuration.maritimeScratchGDB)):
Configuration.maritimeScratchGDB = UnitTestUtilities.createScratch(Configuration.maritimeDataPath)
self.maritimeDataGDB = os.path.join(Configuration.maritimeDataPath, "Maritime Decision Aid Tools.gdb")
self.visibleRange = os.path.join(Configuration.maritimeScratchGDB, "visRangeOutput")
self.vessel = os.path.join(Configuration.maritimeScratchGDB, "vesselOutput")
self.shipLocation = os.path.join(self.maritimeDataGDB, "Vessel")
UnitTestUtilities.checkFilePaths([Configuration.maritimeDataPath, Configuration.maritime_DesktopToolboxPath, Configuration.maritime_ProToolboxPath])
def testClearingOperationsNumberFeatures(self):
if Configuration.DEBUG == True:print(".....ClearingOperationsNumberFeaturesTestCase.testClearingOperationsNumberFeatures")
print("Importing toolbox...")
arcpy.ImportToolbox(self.toolboxUnderTest)
arcpy.env.overwriteOutput = True
#inputs
fieldToNumber = "Number"
output = os.path.join(self.scratchGDB, "numFields")
# Start Test
runToolMsg="Running tool (Number Features)"
arcpy.AddMessage(runToolMsg)
Configuration.Logger.info(runToolMsg)
toolOutput = None
try:
#Calling the NumberFeatures_ClearingOperations Script Tool
toolOutput = arcpy.NumberFeatures_clrops(self.inputArea, self.pointFeatures, fieldToNumber, output)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
# 1: Check the expected return value (output feature class)
if toolOutput is None:
returnedValue = "BAD"
else:
returnedValue = toolOutput.getOutput(0)
self.assertEqual(returnedValue, output)
# 2: Check the number of records
result = arcpy.GetCount_management(output)
count = int(result.getOutput(0))
# print("number features: " + str(count))
# Important only 90 of 120 records are in the area of interest
self.assertEqual(count, 90)
# 3: Check that the "number" field was created/updated for each row
cursor = arcpy.SearchCursor(output)
row = cursor.next()
while row is not None:
val = row.getValue(fieldToNumber)
# Debug: print("Field number first row: " + str(val) + " should not be null")
self.assertIsNotNone(val)
row = cursor.next()
def setUp(self):
if Configuration.DEBUG == True: print(".....CountIncidentsByLOCTestCase.setUp")
UnitTestUtilities.checkArcPy()
Configuration.incidentDataPath = DataDownload.runDataDownload(Configuration.patternsPaths, Configuration.incidentGDBName, Configuration.incidentURL)
if (Configuration.incidentScratchGDB == None) or (not arcpy.Exists(Configuration.incidentScratchGDB)):
Configuration.incidentScratchGDB = UnitTestUtilities.createScratch(Configuration.incidentDataPath)
Configuration.incidentInputGDB = os.path.join(Configuration.incidentDataPath, Configuration.incidentGDBName)
Configuration.incidentResultGDB = os.path.join(Configuration.incidentDataPath, Configuration.incidentResultGDBName)
UnitTestUtilities.checkFilePaths([Configuration.incidentDataPath, Configuration.incidentInputGDB, Configuration.patterns_ProToolboxPath, Configuration.patterns_DesktopToolboxPath])
# set up inputs
self.inputPointsFeatures = os.path.join(Configuration.incidentInputGDB, "Incidents")
self.inputLinesFeatures = os.path.join(Configuration.incidentInputGDB, "Roads")
self.inputAOIFeatures = os.path.join(Configuration.incidentInputGDB, "Districts")
self.resultCompareFeatures0001 = os.path.join(Configuration.incidentResultGDB, "resultsCountIncidentsByLOC_0001")
def test_local_peaks(self):
try:
arcpy.AddMessage("Testing Find Local Peaks (unit).")
if arcpy.CheckExtension("Spatial") == "Available":
arcpy.CheckOutExtension("Spatial")
else:
raise Exception("LicenseError")
print("Importing Visibility and Range Toolbox...")
arcpy.ImportToolbox(Configuration.visandRangeToolbox, "VandR")
arcpy.env.overwriteOutput = True
inputFeatureCount = int(arcpy.GetCount_management(self.inputPolygonFC).getOutput(0))
print("Input FeatureClass: " + str(self.inputPolygonFC))
print("Input Feature Count: " + str(inputFeatureCount))
self.assertTrue(inputFeatureCount > 0)
# if (inputFeatureCount < 1):
# print("Invalid Input Feature Count: " + str(inputFeatureCount))
numberOfPeaks = 3
########################################################
# Execute the Model under test:
arcpy.FindLocalPeaks_VandR(self.inputPolygonFC, numberOfPeaks, self.inputSurface, self.outputPointsFC)
########################################################
# Verify the results
outputFeatureCount = int(arcpy.GetCount_management(self.outputPointsFC).getOutput(0))
print("Output FeatureClass: " + str(self.outputPointsFC))
print("Output Feature Count: " + str(outputFeatureCount))
self.assertEqual(outputFeatureCount, 3)
# if (outputPointsFC < 3):
# print("Invalid Output Feature Count: " + str(outputFeatureCount))
# raise Exception("Test Failed")
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
finally:
arcpy.CheckInExtension("Spatial")
def setUp(self):
if Configuration.DEBUG == True: print(".....HotSpotsByAreaTestCase.setUp")
''' Initialization needed if running Test Case standalone '''
Configuration.GetLogger()
Configuration.GetPlatform()
''' End standalone initialization '''
self.toolboxUnderTest = Configuration.incidentToolboxPath + Configuration.GetToolboxSuffix()
UnitTestUtilities.checkArcPy()
DataDownload.runDataDownload(Configuration.incidentAnalysisDataPath, Configuration.incidentInputGDB, Configuration.incidentURL)
if (self.incidentScratchGDB == None) or (not arcpy.Exists(self.incidentScratchGDB)):
self.incidentScratchGDB = UnitTestUtilities.createScratch(Configuration.incidentAnalysisDataPath)
self.inputAOIFeatures = os.path.join(Configuration.incidentInputGDB, "Districts")
self.inputIncidents = os.path.join(Configuration.incidentInputGDB, "Incidents")
UnitTestUtilities.checkFilePaths([Configuration.incidentAnalysisDataPath])
UnitTestUtilities.checkGeoObjects([Configuration.incidentInputGDB, \
self.incidentScratchGDB, \
self.toolboxUnderTest, \
self.inputAOIFeatures, \
self.inputIncidents])
def setUp(self):
if Configuration.DEBUG == True: print(" DistanceToAssetsTestCase.setUp")
''' Initialization needed if running Test Case standalone '''
Configuration.GetLogger()
Configuration.GetPlatform()
''' End standalone initialization '''
self.toolboxUnderTest = Configuration.distancetoAssetsToolboxPath + \
Configuration.GetToolboxSuffix()
self.suffix = Configuration.GetToolboxSuffix()
UnitTestUtilities.checkArcPy()
DataDownload.runDataDownload(Configuration.distanceToAssetsDataPath, \
Configuration.distanceToAssetsInputGDB, Configuration.distanceToAssetsURL)
self.inputLocator = os.path.join(Configuration.distanceToAssetsDataPath, r"DistanceToAssetsTestData\Sample Locations\arcgisonline\World.GeocodeServer")
if (self.scratchGDB == None) or (not arcpy.Exists(self.scratchGDB)):
self.scratchGDB = UnitTestUtilities.createScratch(Configuration.distanceToAssetsDataPath)
UnitTestUtilities.checkFilePaths([Configuration.distanceToAssetsDataPath])
UnitTestUtilities.checkGeoObjects([Configuration.distanceToAssetsInputGDB, self.toolboxUnderTest, self.scratchGDB, self.inputLocator])
def setUp(self):
if Configuration.DEBUG is True: print(" CreateReferenceSystemGRGFromAreaTestCase.setUp")
''' Initialization needed if running Test Case standalone '''
Configuration.GetLogger()
Configuration.GetPlatform()
''' End standalone initialization '''
self.toolboxUnderTest = Configuration.grgToolboxPath
UnitTestUtilities.checkArcPy()
DataDownload.runDataDownload(Configuration.grgPath,
Configuration.grgInputGDB,
Configuration.grgURL)
if (self.scratchGDB is None) or (not arcpy.Exists(self.scratchGDB)):
self.scratchGDB = UnitTestUtilities.createScratch(Configuration.grgPath)
# set up inputs
self.inputArea = os.path.join(Configuration.grgInputGDB, r"inputAO")
self.inputArea10m = os.path.join(Configuration.grgInputGDB, r"inputAO10m")
self.ref_grid = "MGRS"
self.large_grid_handling = "ALLOW_LARGE_GRIDS"
self.ignore_options = ["IGNORE_M",
"IGNORE_Z",
"IGNORE_POINTID",
"IGNORE_EXTENSION_PROPERTIES",
"IGNORE_SUBTYPES",
"IGNORE_RELATIONSHIPCLASSES",
"IGNORE_REPRESENTATIONCLASSES"]
UnitTestUtilities.checkFilePaths([Configuration.grgPath])
UnitTestUtilities.checkGeoObjects([Configuration.grgInputGDB,
self.toolboxUnderTest,
self.scratchGDB,
self.inputArea])
def setUp(self):
''' set-up code '''
if Configuration.DEBUG == True: print(" HLZTouchdownPoints.setUp")
UnitTestUtilities.checkArcPy()
self.testDataFolderPath = DataDownload.createDataFolder(Configuration.capabilityPath)
print("Created Capability test data folder.")
UnitTestUtilities.checkFilePaths([self.testDataFolderPath,
self.tbxProFolderPath,
self.tbxDesktopFolderPath])
self.testDataGeodatabase = os.path.join(self.testDataFolderPath, r"test_hlz_tools.gdb")
# Check the test inputs (do they exist? or not?)
if (self.scratchGDB == None) or (not arcpy.Exists(self.scratchGDB)):
self.scratchGDB = UnitTestUtilities.createScratch(self.testDataFolderPath)
# Setup the test inputs
self.inputAirframeTable = os.path.join(self.testDataGeodatabase, r"Aircraft_Specifications")
self.inputSuitableAreas = os.path.join(self.testDataGeodatabase, r"HLZSelectionArea")
self.inputSlope = os.path.join(self.testDataGeodatabase, r"SRTMPctSlope")
self.outputGeodatabase = os.path.join(self.scratchGDB)
self.outputCenterpoints = os.path.join(self.outputGeodatabase, r"centerPoints")
self.outputCircles = os.path.join(self.outputGeodatabase, r"tdCircles")
UnitTestUtilities.checkGeoObjects([self.testDataGeodatabase,
self.outputGeodatabase,
self.inputAirframeTable,
self.inputSuitableAreas,
self.inputSlope])
return
def setUp(self):
if Configuration.DEBUG == True: print(" SunPositionAndHillshadeTestCase.setUp")
''' Initialization needed if running Test Case standalone '''
Configuration.GetLogger()
Configuration.GetPlatform()
''' End standalone initialization '''
self.toolboxUnderTest = Configuration.sunPositionAnalysisToolboxPath + \
Configuration.GetToolboxSuffix()
UnitTestUtilities.checkArcPy()
DataDownload.runDataDownload(Configuration.sunPositionAnalysisDataPath, \
Configuration.sunPositionInputGDB, Configuration.sunPositionAnalysisURL)
if (self.scratchGDB == None) or (not arcpy.Exists(self.scratchGDB)):
self.scratchGDB = UnitTestUtilities.createScratch(Configuration.sunPositionAnalysisDataPath)
# set up inputs
self.inputArea = os.path.join(Configuration.sunPositionInputGDB, r"inputArea")
self.inputSurface = os.path.join(Configuration.sunPositionInputGDB, r"Jbad_SRTM_USGS_EROS")
self.compareResults = os.path.join(Configuration.sunPositionInputGDB, r"compareResults_2017_8_10_16_30_00")
UnitTestUtilities.checkFilePaths([Configuration.sunPositionAnalysisDataPath])
UnitTestUtilities.checkGeoObjects([Configuration.sunPositionInputGDB, \
self.toolboxUnderTest, self.scratchGDB, \
self.inputArea, self.inputSurface, \
self.compareResults])
def setUp(self):
if Configuration.DEBUG == True: print(" DistanceToAssetsTestCase.setUp")
''' Initialization needed if running Test Case standalone '''
Configuration.GetLogger()
Configuration.GetPlatform()
''' End standalone initialization '''
self.toolboxUnderTest = Configuration.distancetoAssetsToolboxPath + \
Configuration.GetToolboxSuffix()
UnitTestUtilities.checkArcPy()
DataDownload.runDataDownload(Configuration.distanceToAssetsDataPath, \
Configuration.distanceToAssetsInputGDB, Configuration.distanceToAssetsURL)
self.suffix = Configuration.GetToolboxSuffix()
#self.inputND = os.path.join(Configuration.distanceToAssetsInputNDGDB, "Transportation/Streets_ND")
self.inputND=r"\\redarchive2\disl\Development\Commercial\TestData\DistanceToAssets\SanFrancisco.gdb\Transportation\Streets_ND"
self.inputAssetsPro = os.path.join(Configuration.distanceToAssetsInputGDB, "AssetsGeocoded_pro_SF")
self.inputAssets = os.path.join(Configuration.distanceToAssetsInputGDB, "AssetsGeocoded_SF")
self.inputBasesPro = os.path.join(Configuration.distanceToAssetsInputGDB, "BasesGeocoded_pro_SF")
self.inputBases = os.path.join(Configuration.distanceToAssetsInputGDB, "BasesGeocoded_SF")
if (self.scratchGDB == None) or (not arcpy.Exists(self.scratchGDB)):
self.scratchGDB = UnitTestUtilities.createScratch(Configuration.distanceToAssetsDataPath)
UnitTestUtilities.checkFilePaths([Configuration.distanceToAssetsDataPath])
UnitTestUtilities.checkGeoObjects([Configuration.distanceToAssetsInputGDB, self.toolboxUnderTest, self.scratchGDB, self.inputAssets, self.inputBases, self.inputND])
def test_hot_spots_by_area(self):
'''test_hot_spots_by_area'''
if Configuration.DEBUG == True: print(".....HotSpotsByAreaTestCase.test_hot_spots_by_area")
arcpy.env.overwriteOutput = True
arcpy.ImportToolbox(self.toolboxUnderTest, self.toolboxUnderTestAlias)
runToolMessage = "Running tool (Hot Spots By Area)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
incidentFieldName = "district"
outputWorkspace = self.incidentScratchGDB
results = None
try:
# second parameter: inputIncidents must be a Feature Layer
layerName = "incidentsLayer"
arcpy.MakeFeatureLayer_management(self.inputIncidents, layerName)
# Tools have slightly different names in Pro vs. ArcMap ("By" vs. "by")
if Configuration.Platform == Configuration.PLATFORM_PRO :
results = arcpy.HotSpotsByArea_iaTools(self.inputAOIFeatures, layerName, \
incidentFieldName, outputWorkspace)
else:
# WORKAROUND:
# ArcMap version of tool ignores outputWorkspace parameter
arcpy.env.scratchWorkspace = outputWorkspace
arcpy.env.workspace = outputWorkspace
# End WORKAROUNG
results = arcpy.HotSpotsbyArea_iaTools(self.inputAOIFeatures, layerName, \
incidentFieldName, outputWorkspace)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except Exception as e:
UnitTestUtilities.handleGeneralError(e)
self.assertIsNotNone(results)
outputFeatureClasses = results[0].split(';')
for outputFeatureClass in outputFeatureClasses:
self.assertTrue(arcpy.Exists(outputFeatureClass))
def test_import_wmo_station_data(self):
try:
if Configuration.DEBUG == True: print(" ImportWMOStationDataTestCase.test_import_wmo_station_data")
arcpy.AddMessage("Testing Import WMO Station Data (Desktop)")
arcpy.ImportToolbox(Configuration.maow_ToolboxPath, "maow")
runToolMessage = "Running tool (Import WMO Station Data)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
arcpy.ImportWMOStationData_maow(self.WMOGDB, self.outputFCName, self.WMOFolder, self.StationDataInputFC)
wmoStationCount = int(arcpy.GetCount_management(self.StationDataOutputFC).getOutput(0))
self.assertEqual(wmoStationCount, int(252))
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
def setUp(self):
''' setup for tests'''
if Configuration.DEBUG == True: print(" RangeRingsUtilsTestCase.setUp")
UnitTestUtilities.checkArcPy()
self.proToolboxPath = os.path.join(Configuration.vis_ToolboxesPath,
"Visibility and Range Tools.tbx")
self.desktopToolboxPath = os.path.join(Configuration.vis_ToolboxesPath,
"Visibility and Range Tools_10.4.tbx")
self.srWebMerc = arcpy.SpatialReference(3857) #WGS_1984_Web_Mercator
self.srWGS84 = arcpy.SpatialReference(4326) #GCS_WGS_1984
self.srWAZED = arcpy.SpatialReference(54032) #World_Azimuthal_Equidistant
self.deleteme = []
self.DataGDB = None
self.rrDataPath = os.path.join(Configuration.visibilityPaths, 'data')
if (self.DataGDB == None) or (not arcpy.Exists(self.DataGDB)):
self.DataGDB = UnitTestUtilities.createScratch(self.rrDataPath)
UnitTestUtilities.checkFilePaths([self.proToolboxPath,
self.desktopToolboxPath,
Configuration.visibilityPaths,
self.rrDataPath,
self.DataGDB])
#create a temp point feature class
ptCoords = [[0.0, 0.0], [10.0, 10.0], [3.0, 3.0], [5.5, 1.5]]
tempfcPath = os.path.join("in_memory", "tempfc")
if arcpy.Exists(tempfcPath):
arcpy.Delete_management(tempfcPath)
self.pointGeographic = arcpy.CreateFeatureclass_management(os.path.dirname(tempfcPath),
os.path.basename(tempfcPath),
"POINT", "#", "DISABLED",
"DISABLED", self.srWGS84)[0]
with arcpy.da.InsertCursor(self.pointGeographic, ["SHAPE@XY"]) as cursor:
for (x, y) in ptCoords:
cursor.insertRow([(x, y)])
del cursor
self.deleteme.append(self.pointGeographic)
return
def test_incident_hot_spots(self):
'''test_incident_hot_spots'''
if Configuration.DEBUG == True: print(".....IncidentHotSpotsTestCase.test_incident_hot_spots")
arcpy.ImportToolbox(self.toolboxUnderTest, self.toolboxUnderTestAlias)
runToolMessage = "Running tool (Incident Hot Spots)"
arcpy.AddMessage(runToolMessage)
Configuration.Logger.info(runToolMessage)
outputFeatures = os.path.join(Configuration.incidentResultGDB, "outputHotSpots")
# Delete the feature class used to load if already exists
if arcpy.Exists(outputFeatures) :
arcpy.Delete_management(outputFeatures)
try:
if Configuration.Platform == Configuration.PLATFORM_PRO :
# Pro requires these to be layers
incidentsLayer = arcpy.MakeFeatureLayer_management(self.inputPointFeatures)
boundariesLayer = arcpy.MakeFeatureLayer_management(self.inputBoundaryFeatures)
arcpy.IncidentHotSpots_iaTools(incidentsLayer, boundariesLayer, outputFeatures)
else:
# Note: ArcMap has different parameter order
arcpy.IncidentHotSpots_iaTools(self.inputPointFeatures, outputFeatures, \
self.inputBoundaryFeatures)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except Exception as e:
UnitTestUtilities.handleGeneralError(e)
result = arcpy.GetCount_management(outputFeatures)
featureCount = int(result.getOutput(0))
print("Number of features in output: " + str(featureCount))
# Note: Pro and ArcMap returning different counts (4200 vs. 7400)
self.assertGreater(featureCount, int(4000))
def setUp(self):
if Configuration.DEBUG == True:
print(" CalculateRepRuleTestCase.setUp")
''' Initialization needed if running Test Case standalone '''
Configuration.GetLogger()
Configuration.GetPlatform()
''' End standalone initialization '''
self.toolboxUnderTest = Configuration.militaryFeaturesToolboxPath + \
Configuration.GetToolboxSuffix()
UnitTestUtilities.checkArcPy()
DataDownload.runDataDownload(Configuration.militaryFeaturesDataPath, \
Configuration.militaryFeaturesInputGDB, Configuration.militaryFeaturesURL)
self.inputPointsFC = os.path.join(Configuration.militaryFeaturesInputGDB, \
r"FriendlyOperations/FriendlyUnits")
UnitTestUtilities.checkFilePaths(
[Configuration.militaryFeaturesDataPath])
UnitTestUtilities.checkGeoObjects([self.toolboxUnderTest, \
self.inputPointsFC])
def test_sun_position_analysis(self):
if Configuration.DEBUG == True:
print(
".....SunPositionAndHillshadeTestCase.test_sun_position_analysis"
)
print("Importing toolbox... ")
arcpy.ImportToolbox(self.toolboxUnderTest)
arcpy.env.overwriteOutput = True
# Inputs
print("Setting up inputs... ")
# '''
# Tool comparison is based on static dataset in Web Mercator
# over Afghanistan, for 8/10/2017 at 16:30
# '''
dtCompare = datetime.datetime(2017, 8, 10, 16, 30, 30)
print("Set date...")
utcAfghanistan = r'(UTC+4:30) Afghanistan'
print("Set UTCAfg...")
outHillshade = os.path.join(self.scratchGDB, "outputHS")
print("Set output hillshade...")
# Testing
runToolMsg = "Running tool (Sun Position and Hillshade)"
arcpy.AddMessage(runToolMsg)
Configuration.Logger.info(runToolMsg)
try:
arcpy.SunPositionAnalysis_sunpos(self.inputArea, self.inputSurface, \
dtCompare, utcAfghanistan, outHillshade)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
compareMessage = "Comparing expected values with tool results from " + str(
dtCompare) + " in " + str(utcAfghanistan)
Configuration.Logger.info(compareMessage)
compareResults = self.compareResults
# Diff requires Spatial Analyst extension
requiredExtension = "Spatial"
if arcpy.CheckExtension(requiredExtension) == "Available":
arcpy.CheckOutExtension(requiredExtension)
else:
raise Exception(requiredExtension + " license is not available.")
# Results Testing Method:
# Run a diff on the result surface above and a known good previous run
# There should be no differences between the raster datasets
# No differences -> max diff = min diff = 0, unique values = 1
diff = Minus(Raster(outHillshade), Raster(compareResults))
diff.save(os.path.join(self.scratchGDB, "diff"))
arcpy.CalculateStatistics_management(diff)
rasMinimum = abs(
float(
arcpy.GetRasterProperties_management(diff,
"MINIMUM").getOutput(0)))
rasMaximum = abs(
float(
arcpy.GetRasterProperties_management(diff,
"MAXIMUM").getOutput(0)))
rasMean = float(
arcpy.GetRasterProperties_management(diff, "MEAN").getOutput(0))
rasSTD = float(
arcpy.GetRasterProperties_management(diff, "STD").getOutput(0))
rasUnique = int(
arcpy.GetRasterProperties_management(
diff, "UNIQUEVALUECOUNT").getOutput(0))
arcpy.CheckInExtension(requiredExtension)
tolerance = 3 # allow this much variation in the outputs (ArcMap and Pro vary a tiny bit)
if (rasMaximum <= float(tolerance)) and (
rasMinimum <= float(tolerance)) and (rasUnique <=
int(tolerance)):
Configuration.Logger.info(
"No differences between tool output and expected results.")
else:
msg = "ERROR IN TOOL RESULTS: \n"\
+ "Difference between tool output and expected results found:\n"\
+ "Difference Minimum: " + str(rasMinimum) + "\n"\
+ "Difference Maximum: " + str(rasMaximum) + "\n"\
+ "Difference Mean: " + str(rasMean) + "\n"\
+ "Difference Std. Deviation: " + str(rasSTD) + "\n"\
+ "Difference Number of Unique Values: " + str(rasUnique) + "\n"
Configuration.Logger.error(msg)
self.assertLessEqual(rasMaximum, float(tolerance))
self.assertLessEqual(rasMinimum, float(tolerance))
self.assertLessEqual(rasUnique, int(tolerance))
def tearDown(self):
''' clean up after tests'''
if Configuration.DEBUG == True:
print(" ERGByChemical.tearDown")
UnitTestUtilities.deleteScratch(self.scratchGDB)
return
def tearDown(self):
if Configuration.DEBUG == True:
print(".....IncidentDensityTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.incidentScratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(" DistanceToAssets.tearDown")
UnitTestUtilities.deleteScratch(self.scratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(" ClearingOperationsTestCase.tearDown")
UnitTestUtilities.deleteScratch(self.scratchGDB)
def tearDownClass(cls):
Configuration.Logger.debug(
" GRGCreateGRGFromAreaTestCase.tearDownClass")
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(".....FindPercentChangeTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.incidentScratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(" VisibilityRangeAtSeaTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.maritimeScratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(" SubDepthRestrictionSuitabilityTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.maritimeScratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(".....AddRLOSObserverFieldsTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
return
def test_toolboxMain(self):
arcpy.ImportToolbox(Configuration.toolboxUnderTest)
if arcpy.CheckExtension("3D") == "Available":
arcpy.CheckOutExtension("3D")
else:
raise Exception("3D license is not available.")
inputObserverPoints = os.path.join(Configuration.militaryInputDataGDB,
"RLOS_Observers")
elevationRaster = os.path.join(Configuration.militaryInputDataGDB,
"ElevationUTM_Zone10")
outerRadiusInput = '1000'
leftAzimuthInput = '90'
rightAzimuthInput = '180'
observerOffsetInput = '20'
innerRadiusInput = '500'
viewshed = r'in_memory\viewshed'
sectorWedge = r'in_memory\wedge'
fullWedge = r'in_memory\fullwedge'
toolOutput = None
try:
toolOutput = arcpy.RadialLineOfSightAndRange_mt(inputObserverPoints, elevationRaster, \
outerRadiusInput, leftAzimuthInput, rightAzimuthInput, observerOffsetInput, \
innerRadiusInput, viewshed, sectorWedge, fullWedge)
except:
UnitTestUtilities.handleArcPyError()
# 1: Check the expected return value
self.assertIsNotNone(toolOutput, "No output returned from tool")
viewshedOut = toolOutput.getOutput(0)
sectorWedgeOut = toolOutput.getOutput(1)
fullWedgeOut = toolOutput.getOutput(2)
self.assertEqual(viewshed, viewshedOut,
"Unexpected return value from tool")
self.assertEqual(sectorWedge, sectorWedgeOut,
"Unexpected return value from tool")
self.assertEqual(fullWedge, fullWedgeOut,
"Unexpected return value from tool")
# 2: Verify some output was created
viewshedFeaturesCount = int(
arcpy.GetCount_management(viewshedOut).getOutput(0))
sectorWedgeFeaturesCount = int(
arcpy.GetCount_management(sectorWedgeOut).getOutput(0))
fullWedgeFeaturesCount = int(
arcpy.GetCount_management(fullWedgeOut).getOutput(0))
self.assertGreater(
viewshedFeaturesCount, 0,
"No output features created for " + str(viewshedFeaturesCount))
self.assertGreater(
sectorWedgeFeaturesCount, 0,
"No output features created for " + str(sectorWedgeFeaturesCount))
self.assertGreater(
fullWedgeFeaturesCount, 0,
"No output features created for " + str(fullWedgeFeaturesCount))
def tearDown(self):
if Configuration.DEBUG == True:
print(".....LowestPointsTestCase.tearDown")
arcpy.CheckInExtension("Spatial")
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
def test_sun_position_analysis(self, toolboxPath):
try:
print("Importing toolbox... ")
arcpy.ImportToolbox(toolboxPath)
arcpy.env.overwriteOutput = True
# Inputs
print("Setting up inputs... ")
# '''
# Tool comparison is based on static dataset in Web Mercator
# over Afghanistan, for 7/30/2015 at 14:28:36.
# '''
dtCompare = datetime.datetime(2015, 7, 30, 14, 28, 36)
print("Set date...")
utcAfghanistan = r'(UTC+4:30) Afghanistan'
print("Set UTCAfg...")
# outHillshade = os.path.join(Configuration.vis_ScratchPath, "outputHS")
outHillshade = os.path.join(self.scratchGDB, "outputHS")
print("Set output hillshade...")
# Testing
runToolMsg = "Running tool (Sun Position and Hillshade)"
arcpy.AddMessage(runToolMsg)
Configuration.Logger.info(runToolMsg)
arcpy.SunPositionAnalysis_sunpos(self.inputArea, self.inputSurface,
dtCompare, utcAfghanistan,
outHillshade)
compareMessage = "Comparing expected values with tool results from " + str(
dtCompare) + " in " + str(utcAfghanistan)
Configuration.Logger.info(compareMessage)
compareResults = self.compareResults
arcpy.CheckOutExtension("Spatial")
diff = Minus(Raster(outHillshade), Raster(compareResults))
diff.save(os.path.join(self.scratchGDB, "diff"))
arcpy.CalculateStatistics_management(diff)
rasMinimum = float(
arcpy.GetRasterProperties_management(diff,
"MINIMUM").getOutput(0))
rasMaximum = float(
arcpy.GetRasterProperties_management(diff,
"MAXIMUM").getOutput(0))
rasMean = float(
arcpy.GetRasterProperties_management(diff,
"MEAN").getOutput(0))
rasSTD = float(
arcpy.GetRasterProperties_management(diff, "STD").getOutput(0))
rasUnique = int(
arcpy.GetRasterProperties_management(
diff, "UNIQUEVALUECOUNT").getOutput(0))
self.assertEqual(rasMaximum, float(0))
self.assertEqual(rasMinimum, float(0))
self.assertEqual(rasUnique, int(1))
# if (rasMaximum == float(0)) and (rasMinimum == float(0)) and (rasUnique == int(1)):
# print("No differences between tool output and expected results.")
# print("Test Passed")
# else:
# msg = "ERROR IN TOOL RESULTS: \n"\
# + "Difference between tool output and expected results found:\n"\
# + "Difference Minimum: " + str(rasMinimum) + "\n"\
# + "Difference Maximum: " + str(rasMaximum) + "\n"\
# + "Difference Mean: " + str(rasMean) + "\n"\
# + "Difference Std. Deviation: " + str(rasSTD) + "\n"\
# + "Difference Number of Unique Values: " + str(rasUnique) + "\n"
# raise ValueDifferenceError(msg)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
finally:
arcpy.CheckInExtension("Spatial")
def tearDown(self):
''' clean up after tests'''
if Configuration.DEBUG:
print(".....ERGScript.tearDown")
UnitTestUtilities.deleteScratch(self.scratchGDB)
return
def tearDown(self):
Configuration.Logger.debug(".....HighestPointsTestCase.tearDown")
arcpy.CheckInExtension("Spatial");
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
def testGRGPointTarget(self):
Configuration.Logger.debug(".....GRGCreateGRGFromPointTestCase.testGRGPointTarget")
#inputs
rows = 5
cols = 10
cellWidth = 100
cellHeight = 100
cellUnits = "Meters"
labelStart = "Lower-Left"
labelStyle = "Alpha-Numeric"
labelSeparator = "-" # TRICKY: Only used for Alpha-Alpha but required parameter?
gridRotationAngle = 0 # No Rotation
output = os.path.join(Configuration.militaryScratchGDB, "ptTarget")
#Testing
runToolMsg="Running tool (Point Target)"
arcpy.AddMessage(runToolMsg)
Configuration.Logger.info(runToolMsg)
toolOutput = None
try:
# Calling the PointTargetGRG Script Tool
toolOutput = arcpy.CreateGRGFromPoint_mt(self.pointTarget, \
rows, cols, \
cellWidth, cellHeight, cellUnits, \
labelStart, labelStyle, labelSeparator, gridRotationAngle, \
output)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
# 1: Check the expected return value and that output exists
self.assertIsNotNone(toolOutput, "No output returned from tool")
outputOut = toolOutput.getOutput(0)
self.assertEqual(output, outputOut, "Unexpected return value from tool")
self.assertTrue(arcpy.Exists(outputOut), "Output does not exist")
# 2: Check the number of features created
result = arcpy.GetCount_management(output)
count = int(result.getOutput(0))
expectedCount = rows * cols
self.assertEqual(count, expectedCount, "Unexpected number of output feature created")
# 3: Checks 3 and 4 - check size of feature shape and grid zone label
# for each feature matches the expected values
expectedPerimeter = (cellWidth * 2.0) + (cellHeight * 2.0)
tolerance = 0.001
field_names = ["Grid", "Shape_Length"]
with arcpy.da.SearchCursor(outputOut, field_names) as cursor:
for row in cursor:
gridDesignator = row[0]
perimeterLength = row[1]
perimeterDelta = abs(expectedPerimeter - perimeterLength)
# Check 3 - Grid Perimeter length matched expected (within tolerance)
self.assertLessEqual(perimeterDelta, tolerance)
# Check 4 - Grid Zone Designator matches expected format
regexExpression = '[A-Z][0-9]+$' # [LETTER A-Z][One or more digits]
# assertRegex (Python 3) vs assertRegexpMatches (Python 2.7)
if sys.version_info >= (3,2):
self.assertRegex(gridDesignator, regexExpression)
else:
self.assertRegexpMatches(gridDesignator, regexExpression)
def tearDown(self):
''' clean up after tests'''
UnitTestUtilities.deleteScratch(self.scratchGDB)
def tearDown(self):
''' clean up after tests'''
if Configuration.DEBUG == True:
print(".....HLZTouchdownPoints.tearDown")
UnitTestUtilities.deleteScratch(self.scratchGDB)
return
def tearDown(self):
if Configuration.DEBUG == True:
print(".....HotSpotsByAreaTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.incidentScratchGDB)
def testGRGAreaGRG(self):
Configuration.Logger.debug(
".....GRGCreateGRGFromAreaTestCase.testGRGAreaGRG")
#inputs
cellWidth = randint(100, 500)
cellHeight = randint(100, 500)
cellunits = "Meters"
labelStart = "Lower-Left"
labelStyle = "Numeric"
labelSeparator = "-" # Only used for Alpha-Alpha but required parameter?
output = os.path.join(Configuration.militaryScratchGDB, "grg")
Configuration.Logger.debug("Cell Width: " + str(cellWidth))
Configuration.Logger.debug("Cell Height: " + str(cellHeight))
#Testing
runToolMsg = "Running tool (Canvas Area GRG)"
arcpy.AddMessage(runToolMsg)
Configuration.Logger.info(runToolMsg)
toolOutput = None
try:
# Calling the Create GRG From Area script tool
toolOutput = arcpy.CreateGRGFromArea_mt(self.inputArea, \
cellWidth, cellHeight, cellunits, \
labelStart, labelStyle, labelSeparator, output)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
Configuration.Logger.debug('''
==================================================================
Check #1 Check the size of the grids that have been created using the
assertLessEqual. Comparing this to the cellwidth and height times 2.
If the number returned is less than 1 the test passes.This is used
because of the percision of the field does not produce the exact number.
==================================================================
''')
primter_area = (cellWidth * 2) + (cellHeight * 2)
field_name = "Shape_Length"
with arcpy.da.SearchCursor(output, field_name) as cursor:
for row in cursor:
testlen = primter_area - int(row[0])
self.assertLessEqual(testlen, 1)
Configuration.Logger.debug('''
==================================================================
Check #2 Check to see if all the correct numeric labels have been
created. This is tested by comparing the numbers to objectID to the
number sin the Grid attribute.
==================================================================
''')
oid = []
grid = []
#Create a list with the attributes from the OID in output
with arcpy.da.SearchCursor(output, "ObjectID") as cursor:
for row in cursor:
oid.append(row[0])
#Create a list with the attributes from the Grid in output
with arcpy.da.SearchCursor(output, "Grid") as cursor:
for row in cursor:
grid.append(int(row[0]))
#sort the oid and grid to allow each list to be compared correctly
list.sort(oid)
list.sort(grid)
Configuration.Logger.debug(oid)
Configuration.Logger.debug(grid)
#Compare the oid list and the grid list
self.assertEquals(oid, grid)
def tearDown(self):
if Configuration.DEBUG == True:
print(".....ConversionUtilitiesTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
def testGRGAreaGRGSimple(self):
'''
Test GRG from area with a input of 100 meters as the cell width and height.
The checks in the tis test will check:
If the output feature class has been created
If the expected amount of features have been created
'''
Configuration.Logger.debug(
".....GRGCreateGRGFromAreaTestCase.testGRGAreaGRGSimple")
#inputs
cellWidth = 100
cellHeight = 100
cellunits = "Meters"
labelStart = "Lower-Left"
labelStyle = "Numeric"
labelSeparator = "-" # Only used for Alpha-Alpha but required parameter?
output = os.path.join(Configuration.militaryScratchGDB, "grg")
Configuration.Logger.debug("Cell Width: " + str(cellWidth))
Configuration.Logger.debug("Cell Height: " + str(cellHeight))
#Testing
runToolMsg = "Running tool (Canvas Area GRG)"
arcpy.AddMessage(runToolMsg)
Configuration.Logger.info(runToolMsg)
toolOutput = None
try:
# Calling the Create GRG From Area script tool
toolOutput = arcpy.CreateGRGFromArea_mt(self.inputArea, \
cellWidth, cellHeight, cellunits, \
labelStart, labelStyle, labelSeparator, output)
except arcpy.ExecuteError:
UnitTestUtilities.handleArcPyError()
except:
UnitTestUtilities.handleGeneralError()
Configuration.Logger.debug('''
==================================================================
Check #1 Check to see if the output featureclass is created
==================================================================
''')
self.assertIsNotNone(toolOutput, "No output returned from tool")
outputOut = toolOutput.getOutput(0)
self.assertEqual(output, outputOut,
"Unexpected return value from tool")
# 2: Check the number of features created
Configuration.Logger.debug('''
=================================================================
Check #2 Check to see if the amount of features created is the
number expected.
==================================================================
''')
result = arcpy.GetCount_management(output)
count = int(result.getOutput(0))
Configuration.Logger.debug("Output number features: " + str(count))
self.assertEqual(count, 40)
def configCheck():
UnitTestUtilities.checkFilePaths([Configuration.militaryDataPath, \
Configuration.militaryInputDataGDB, Configuration.militaryResultsGDB, \
Configuration.military_ProToolboxPath, Configuration.military_DesktopToolboxPath])
def tearDown(self):
Configuration.Logger.debug(" RadialLineOfSightTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
def tearDownClass(cls):
Configuration.Logger.debug(
" DistanceAndDirectionTestCase.tearDownClass")
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(" FindSubmarinesTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.maritimeScratchGDB)
def tearDown(self):
if Configuration.DEBUG == True:
print(" SunPositionAndHillshadeTestCase.tearDown")
UnitTestUtilities.deleteScratch(self.scratchGDB)
def tearDown(self):
if Configuration.DEBUG == True: print(" TableToPointTestCase.tearDown")
UnitTestUtilities.deleteScratch(Configuration.militaryScratchGDB)
def tearDown(self):
if Configuration.DEBUG is True: print(" CreateReferenceSystemGRGFromAreaTestCase.tearDown")
UnitTestUtilities.deleteScratch(self.scratchGDB)
