def test_windowsDrawingArtifacts(self): """Test that windows rendering does not make artifacts""" # sometimes spurious lines are drawn on the layout LOGGER.info('Testing windowsDrawingArtifacts') myPath = unique_filename( prefix='artifacts', suffix='.pdf', dir=temp_dir('test')) myMap = Map(IFACE) setup_printer(myPath) myMap.setup_composition() myImage = QtGui.QImage(10, 10, QtGui.QImage.Format_RGB32) myImage.setDotsPerMeterX(dpi_to_meters(300)) myImage.setDotsPerMeterY(dpi_to_meters(300)) #myImage.fill(QtGui.QColor(250, 250, 250)) # Look at the output, you will see antialiasing issues around some # of the boxes drawn... # myImage.fill(QtGui.QColor(200, 200, 200)) myImage.fill(200 + 200 * 256 + 200 * 256 * 256) myFilename = os.path.join(temp_dir(), 'greyBox') myImage.save(myFilename, 'PNG') for i in range(10, 190, 10): myPicture = QgsComposerPicture(myMap.composition) myPicture.setPictureFile(myFilename) if qgis_version() >= 10800: # 1.8 or newer myPicture.setFrameEnabled(False) else: myPicture.setFrame(False) myPicture.setItemPosition(i, # x i, # y 10, # width 10) # height myMap.composition.addItem(myPicture) # Same drawing drawn directly as a pixmap # noinspection PyCallByClass,PyTypeChecker,PyArgumentList myPixmapItem = myMap.composition.addPixmap( QtGui.QPixmap.fromImage(myImage)) myPixmapItem.setOffset(i, i + 20) # Same drawing using our drawImage Helper myWidthMM = 1 myMap.draw_image(myImage, myWidthMM, i, i + 40) myImagePath, _, _ = myMap.render() # when this test no longer matches our broken render hash # we know the issue is fixed myTolerance = 0 myFlag, myMessage = check_images( 'windowsArtifacts', myImagePath, myTolerance) myMessage += ('\nWe want these images to match, if they do not ' 'there may be rendering artifacts in windows.\n') assert myFlag, myMessage
def test_renderHtmlToImage(self): """Test that we can render html to a pixmap.""" LOGGER.debug('InaSAFE HtmlRenderer testing renderHtmlToImage') myHtml = self.sampleHtml(20) LOGGER.debug(myHtml) myPageDpi = 300 myRenderer = HtmlRenderer(myPageDpi) myPath = unique_filename(prefix='testHtmlToImage', suffix='.png', dir=temp_dir('test')) LOGGER.debug(myPath) myWidth = 250 myPixmap = myRenderer.renderHtmlToImage(myHtml, myWidth) assert not myPixmap.isNull() LOGGER.debug(myPixmap.__class__) myPixmap.save(myPath) myMessage = 'Rendered output does not exist: %s' % myPath assert os.path.exists(myPath), myMessage myControlImages = [ 'renderHtmlToImage.png', 'renderHtmlToImage-variantWindosVistaSP2-32.png', 'renderHtmlToImage-variantUB11.04-64.png', 'renderHtmlToImage-variantUB11.10-64.png' ] myTolerance = 1000 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages(myControlImages, myPath, myTolerance) assert myFlag, myMessage
def test_getVectorLegend(self): """Getting a legend for a vector layer works.""" myLayer, _ = loadLayer('test_shakeimpact.shp') myMapLegend = MapLegend( myLayer, theLegendNotes='Thousand separator represented by \'.\'', theLegendUnits='(people per cell)') myImage = myMapLegend.getVectorLegend() myPath = unique_filename(prefix='getVectorLegend', suffix='.png', dir=temp_dir('test')) myImage.save(myPath, 'PNG') print myMapLegend.legendUnits print myMapLegend.legendNotes print myPath LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages( 'getVectorLegend.png', myPath, myTolerance) myMessage += ('\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control ' 'image.') assert myFlag, myMessage
def test_addClassToLegend(self): """Test we can add a class to the map legend.""" myLayer, _ = loadLayer('test_shakeimpact.shp') myMapLegend = MapLegend(myLayer) myColour = QtGui.QColor(12, 34, 126) myMapLegend.addClassToLegend(myColour, theMin=None, theMax=None, theCategory=None, theLabel='bar') myMapLegend.addClassToLegend(myColour, theMin=None, theMax=None, theCategory=None, theLabel='foo') myPath = unique_filename(prefix='addClassToLegend', suffix='.png', dir=temp_dir('test')) myMapLegend.getLegend().save(myPath, 'PNG') LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so place any other possible # variants in the safe_qgis/test_data/test_images/ dir e.g. # addClassToLegend-variantUbuntu13.04.png myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages('addClassToLegend.png', myPath, myTolerance) myMessage += ('\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control ' 'image.') assert myFlag, myMessage
def test_addSymbolToLegend(self): """Test we can add a symbol to the legend.""" myLayer, _ = loadLayer('test_floodimpact.tif') myMapLegend = MapLegend(myLayer) mySymbol = QgsSymbol() mySymbol.setColor(QtGui.QColor(12, 34, 56)) myMapLegend.addSymbolToLegend(mySymbol, theMin=0, # expect 2.0303 in legend theMax=2.02030, theCategory=None, theLabel='Foo') myPath = unique_filename(prefix='addSymbolToLegend', suffix='.png', dir=temp_dir('test')) myMapLegend.getLegend().save(myPath, 'PNG') LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages('addSymbolToLegend.png', myPath, myTolerance) myMessage += ('\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control ' 'image.') assert myFlag, myMessage
def test_generate_html_reports(self): """Test generate_html_reports function.""" self.mock_the_dialog(test_entire_mode=False) self.impact_merge_dialog.prepare_input() self.impact_merge_dialog.validate_all_layers() first_postprocessing_report = \ self.impact_merge_dialog.first_impact['postprocessing_report'] second_postprocessing_report = \ self.impact_merge_dialog.second_impact['postprocessing_report'] first_report = ('<body>' + first_postprocessing_report + '</body>') second_report = ('<body>' + second_postprocessing_report + '</body>') # Now create a dom document for each first_document = minidom.parseString(first_report) second_document = minidom.parseString(second_report) first_impact_tables = first_document.getElementsByTagName('table') second_impact_tables = second_document.getElementsByTagName('table') first_report_dict = \ self.impact_merge_dialog.generate_report_dictionary_from_dom( first_impact_tables) second_report_dict = \ self.impact_merge_dialog.generate_report_dictionary_from_dom( second_impact_tables) self.impact_merge_dialog.generate_html_reports(first_report_dict, second_report_dict) # There should be 4 HTML files generated on temp_dir() html_list = glob(os.path.join(temp_dir(), '*.html')) expected_html_number = 4 self.assertEqual(len(html_list), expected_html_number)
def make_pdf(self, filename): """Generate the printout for our final map. :param filename: Path on the file system to which the pdf should be saved. If None, a generated file name will be used. :type filename: str :returns: File name of the output file (equivalent to filename if provided). :rtype: str """ LOGGER.debug('InaSAFE Map printToPdf called') if filename is None: map_pdf_path = unique_filename(prefix='report', suffix='.pdf', dir=temp_dir()) else: # We need to cast to python string in case we receive a QString map_pdf_path = str(filename) self.load_template() resolution = self.composition.printResolution() self.printer = setup_printer(map_pdf_path, resolution=resolution) _, image, rectangle = self.render() painter = QtGui.QPainter(self.printer) painter.drawImage(rectangle, image, rectangle) painter.end() return map_pdf_path
def render(self): """Render the map composition to an image and save that to disk. :returns: A three-tuple of: * str: image_path - absolute path to png of rendered map * QImage: image - in memory copy of rendered map * QRectF: target_area - dimensions of rendered map :rtype: tuple """ LOGGER.debug('InaSAFE Map renderComposition called') # NOTE: we ignore self.composition.printAsRaster() and always rasterise width = int(self.page_dpi * self.page_width / 25.4) height = int(self.page_dpi * self.page_height / 25.4) image = QtGui.QImage(QtCore.QSize(width, height), QtGui.QImage.Format_ARGB32) image.setDotsPerMeterX(dpi_to_meters(self.page_dpi)) image.setDotsPerMeterY(dpi_to_meters(self.page_dpi)) # Only works in Qt4.8 #image.fill(QtGui.qRgb(255, 255, 255)) # Works in older Qt4 versions image.fill(55 + 255 * 256 + 255 * 256 * 256) image_painter = QtGui.QPainter(image) source_area = QtCore.QRectF(0, 0, self.page_width, self.page_height) target_area = QtCore.QRectF(0, 0, width, height) self.composition.render(image_painter, target_area, source_area) image_painter.end() image_path = unique_filename(prefix='mapRender_', suffix='.png', dir=temp_dir()) image.save(image_path) return image_path, image, target_area
def test_getVectorLegend(self): """Getting a legend for a vector layer works.""" myLayer, _ = loadLayer('test_shakeimpact.shp') myMapLegend = MapLegend(myLayer) myImage = myMapLegend.getVectorLegend() myPath = unique_filename(prefix='getVectorLegend', suffix='.png', dir=temp_dir('test')) myImage.save(myPath, 'PNG') LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myControlImages = ['getVectorLegend.png', 'getVectorLegend-variantWindosVistaSP2-32.png', 'getVectorLegend-variantUB12.04-64.png', 'getVectorLegend-variantUB11.04-64.png', 'getVectorLegend-variantJenkins.png'] myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages(myControlImages, myPath, myTolerance) myMessage += ('\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control image.') assert myFlag, myMessage
def test_addClassToLegend(self): """Test we can add a class to the map legend.""" myLayer, _ = loadLayer('test_shakeimpact.shp') myMapLegend = MapLegend(myLayer) myColour = QtGui.QColor(12, 34, 126) myMapLegend.addClassToLegend(myColour, theMin=None, theMax=None, theCategory=None, theLabel='bar') myMapLegend.addClassToLegend(myColour, theMin=None, theMax=None, theCategory=None, theLabel='foo') myPath = unique_filename(prefix='addClassToLegend', suffix='.png', dir=temp_dir('test')) myMapLegend.getLegend().save(myPath, 'PNG') LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myControlImages = ['getClassToLegend.png', 'getClassToLegend-variantWindosVistaSP2-32.png', 'getClassToLegend-variantUB12.04-64.png', 'getClassToLegend-variantUB11.04-64.png', 'getClassToLegend-variantJenkins.png'] myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages(myControlImages, myPath, myTolerance) myMessage += ('\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control image.') assert myFlag, myMessage
def test_printToPdf(self): """Test making a pdf of the map - this is the most typical use of map. """ LOGGER.info('Testing printToPdf') myLayer, _ = loadLayer('test_shakeimpact.shp') myCanvasLayer = QgsMapCanvasLayer(myLayer) CANVAS.setLayerSet([myCanvasLayer]) myRect = QgsRectangle(106.7894, -6.2308, 106.8004, -6.2264) CANVAS.setExtent(myRect) CANVAS.refresh() myMap = Map(IFACE) myMap.setImpactLayer(myLayer) myMap.composeMap() myPath = unique_filename(prefix='mapPdfTest', suffix='.pdf', dir=temp_dir('test')) myMap.printToPdf(myPath) LOGGER.debug(myPath) myMessage = 'Rendered output does not exist: %s' % myPath assert os.path.exists(myPath), myMessage # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. mySize = os.stat(myPath).st_size myExpectedSizes = [ 441541, # as rendered on ub 13.04 post 17 May 2013 447217, # Nadia Linux Mint 14 0, # as rendered on Jenkins post 24 April 2013 447138, # Windows 7 SP1 AMD64 ] myMessage = 'Expected rendered map pdf to be in %s, got %s' % ( myExpectedSizes, mySize) self.assertIn(mySize, myExpectedSizes, myMessage)
def test_defaultTemplate(self): """Test that loading default template works""" LOGGER.info('Testing defaultTemplate') myLayer, _ = load_layer('test_shakeimpact.shp') myCanvasLayer = QgsMapCanvasLayer(myLayer) CANVAS.setLayerSet([myCanvasLayer]) myRect = QgsRectangle(106.7894, -6.2308, 106.8004, -6.2264) CANVAS.setExtent(myRect) CANVAS.refresh() myMap = Map(IFACE) myMap.set_impact_layer(myLayer) myPath = unique_filename(prefix='mapDefaultTemplateTest', suffix='.pdf', dir=temp_dir('test')) myMap.make_pdf(myPath) LOGGER.debug(myPath) myMessage = 'Rendered output does not exist: %s' % myPath assert os.path.exists(myPath), myMessage # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. mySize = os.stat(myPath).st_size # Note: You should replace, not append the numbers for a given # platform. Also note that this test will break every time the # version number of InaSAFE changes so we should ultimately come up # with a lower maintenance test strategy. myExpectedSizes = [ 400350, # Slackware64 14.0 ] myMessage = '%s\nExpected rendered map pdf to be in %s, got %s' % ( myPath, myExpectedSizes, mySize) self.assertIn(mySize, myExpectedSizes, myMessage)
def make_pdf(self, filename): """Generate the printout for our final map. :param filename: Path on the file system to which the pdf should be saved. If None, a generated file name will be used. :type filename: str :returns: File name of the output file (equivalent to filename if provided). :rtype: str """ LOGGER.debug('InaSAFE Map printToPdf called') if filename is None: myMapPdfPath = unique_filename( prefix='report', suffix='.pdf', dir=temp_dir('work')) else: # We need to cast to python string in case we receive a QString myMapPdfPath = str(filename) self.compose_map() self.printer = setup_printer(myMapPdfPath) _, myImage, myRectangle = self.render() myPainter = QtGui.QPainter(self.printer) myPainter.drawImage(myRectangle, myImage, myRectangle) myPainter.end() return myMapPdfPath
def printToPdf(self, theFilename): """Generate the printout for our final map. Args: theFilename: str - optional path on the file system to which the pdf should be saved. If None, a generated file name will be used. Returns: str: file name of the output file (equivalent to theFilename if provided). Raises: None """ LOGGER.debug('InaSAFE Map printToPdf called') if theFilename is None: myMapPdfPath = unique_filename(prefix='report', suffix='.pdf', dir=temp_dir('work')) else: # We need to cast to python string in case we receive a QString myMapPdfPath = str(theFilename) self.composeMap() self.printer = setupPrinter(myMapPdfPath) _, myImage, myRectangle = self.renderComposition() myPainter = QtGui.QPainter(self.printer) myPainter.drawImage(myRectangle, myImage, myRectangle) myPainter.end() return myMapPdfPath
def to_pdf(self, html, filename=None): """Render an html snippet into the printer, paginating as needed. :param html: A string containing an html snippet. It will have a header and footer appended to it in order to make it a valid html document. The header will also apply the bootstrap theme to the document. :type html: str :param filename: String containing a pdf file path that the output will be written to. If no file name is given we will make up one for you - nice eh? :type filename: str :returns: The file path of the output pdf (which is the same as the filename parameter if it was specified). :rtype: str """ LOGGER.info('InaSAFE Map printToPdf called') if filename is None: myHtmlPdfPath = unique_filename(prefix='table', suffix='.pdf', dir=temp_dir('work')) else: # We need to cast to python string in case we receive a QString myHtmlPdfPath = str(filename) self.printer = setup_printer(myHtmlPdfPath) self.load_and_wait(html_snippet=html) self.webView.print_(self.printer) return myHtmlPdfPath
def render(self): """Render the map composition to an image and save that to disk. :returns: A three-tuple of: * str: myImagePath - absolute path to png of rendered map * QImage: myImage - in memory copy of rendered map * QRectF: myTargetArea - dimensions of rendered map :rtype: tuple """ LOGGER.debug('InaSAFE Map renderComposition called') # NOTE: we ignore self.composition.printAsRaster() and always rasterise myWidth = (int)(self.pageDpi * self.pageWidth / 25.4) myHeight = (int)(self.pageDpi * self.pageHeight / 25.4) myImage = QtGui.QImage(QtCore.QSize(myWidth, myHeight), QtGui.QImage.Format_ARGB32) myImage.setDotsPerMeterX(dpi_to_meters(self.pageDpi)) myImage.setDotsPerMeterY(dpi_to_meters(self.pageDpi)) # Only works in Qt4.8 #myImage.fill(QtGui.qRgb(255, 255, 255)) # Works in older Qt4 versions myImage.fill(55 + 255 * 256 + 255 * 256 * 256) myImagePainter = QtGui.QPainter(myImage) mySourceArea = QtCore.QRectF(0, 0, self.pageWidth, self.pageHeight) myTargetArea = QtCore.QRectF(0, 0, myWidth, myHeight) self.composition.render(myImagePainter, myTargetArea, mySourceArea) myImagePainter.end() myImagePath = unique_filename(prefix='mapRender_', suffix='.png', dir=temp_dir()) myImage.save(myImagePath) return myImagePath, myImage, myTargetArea
def clone_shp_layer(name='tsunami_polygon', include_keywords=False, source_directory=TESTDATA, target_directory='testing'): """Helper function that copies a test shp layer and returns it. :param name: The default name for the shp layer. :type name: str :param include_keywords: Include keywords file if True. :type include_keywords: bool :param source_directory: Directory where the file is located. :type source_directory: str :param target_directory: Subdirectory in InaSAFE temp dir that we want to put the files into. Default to 'testing'. :type target_directory: str """ extensions = ['.shp', '.shx', '.dbf', '.prj'] if include_keywords: extensions.append('.keywords') temp_path = unique_filename(dir=temp_dir(target_directory)) # copy to temp file for ext in extensions: src_path = os.path.join(source_directory, name + ext) if os.path.exists(src_path): target_path = temp_path + ext shutil.copy2(src_path, target_path) shp_path = '%s.shp' % temp_path layer = QgsVectorLayer(shp_path, os.path.basename(shp_path), 'ogr') return layer
def test_renderHtmlToImage(self): """Test that we can render html to a pixmap.""" LOGGER.debug('InaSAFE HtmlRenderer testing renderHtmlToImage') myHtml = self.sampleHtml(20) LOGGER.debug(myHtml) myPageDpi = 300 myRenderer = HtmlRenderer(myPageDpi) myPath = unique_filename(prefix='testHtmlToImage', suffix='.png', dir=temp_dir('test')) LOGGER.debug(myPath) myWidth = 250 myPixmap = myRenderer.renderHtmlToImage(myHtml, myWidth) assert not myPixmap.isNull() LOGGER.debug(myPixmap.__class__) myPixmap.save(myPath) myMessage = 'Rendered output does not exist: %s' % myPath assert os.path.exists(myPath), myMessage myControlImages = ['renderHtmlToImage.png', 'renderHtmlToImage-variantOSX10.8.png', 'renderHtmlToImage-variantWindosVistaSP2-32.png', 'renderHtmlToImage-variantWindowsXPSP3-32.png', 'renderHtmlToImage-variantUB11.04-64.png', 'renderHtmlToImage-variantLinuxMint-14-x86_64.png', 'renderHtmlToImage-variantWindows7-SP1-AMD64.png', 'renderHtmlToImage-variantUB11.10-64.png'] myTolerance = 1000 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages(myControlImages, myPath, myTolerance) assert myFlag, myMessage
def render(self): """Render the map composition to an image and save that to disk. :returns: A three-tuple of: * str: myImagePath - absolute path to png of rendered map * QImage: myImage - in memory copy of rendered map * QRectF: myTargetArea - dimensions of rendered map :rtype: tuple """ LOGGER.debug('InaSAFE Map renderComposition called') # NOTE: we ignore self.composition.printAsRaster() and always rasterise myWidth = int(self.pageDpi * self.pageWidth / 25.4) myHeight = int(self.pageDpi * self.pageHeight / 25.4) myImage = QtGui.QImage(QtCore.QSize(myWidth, myHeight), QtGui.QImage.Format_ARGB32) myImage.setDotsPerMeterX(dpi_to_meters(self.pageDpi)) myImage.setDotsPerMeterY(dpi_to_meters(self.pageDpi)) # Only works in Qt4.8 #myImage.fill(QtGui.qRgb(255, 255, 255)) # Works in older Qt4 versions myImage.fill(55 + 255 * 256 + 255 * 256 * 256) myImagePainter = QtGui.QPainter(myImage) mySourceArea = QtCore.QRectF(0, 0, self.pageWidth, self.pageHeight) myTargetArea = QtCore.QRectF(0, 0, myWidth, myHeight) self.composition.render(myImagePainter, myTargetArea, mySourceArea) myImagePainter.end() myImagePath = unique_filename(prefix='mapRender_', suffix='.png', dir=temp_dir()) myImage.save(myImagePath) return myImagePath, myImage, myTargetArea
def test_printImpactTable(self): """Test that we can render html from impact table keywords.""" LOGGER.debug('InaSAFE HtmlRenderer testing printImpactTable') myFilename = 'test_floodimpact.tif' myLayer, _ = loadLayer(myFilename) myMessage = 'Layer is not valid: %s' % myFilename assert myLayer.isValid(), myMessage myPageDpi = 300 myHtmlRenderer = HtmlRenderer(myPageDpi) myPath = unique_filename(prefix='impactTable', suffix='.pdf', dir=temp_dir('test')) myKeywordIO = KeywordIO() myKeywords = myKeywordIO.readKeywords(myLayer) myPath = myHtmlRenderer.printImpactTable(myKeywords, theFilename=myPath) myMessage = 'Rendered output does not exist: %s' % myPath assert os.path.exists(myPath), myMessage # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. mySize = os.stat(myPath).st_size myExpectedSize = 20936 # as rendered on linux ub 12.04 64 myMessage = ('Expected rendered table pdf to be at least %s, got %s' % (myExpectedSize, mySize)) assert mySize >= myExpectedSize, myMessage
def test_getRasterLegend(self): """Getting a legend for a raster layer works.""" myLayer, _ = loadLayer('test_floodimpact.tif') myMapLegend = MapLegend(myLayer) myImage = myMapLegend.getRasterLegend() myPath = unique_filename(prefix='getRasterLegend', suffix='.png', dir=temp_dir('test')) myImage.save(myPath, 'PNG') LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myControlImages = [ 'getRasterLegend.png', 'getRasterLegend-variantWindosVistaSP2-32.png', 'getRasterLegend-variantUB12.04-64.png', 'getRasterLegend-variantUB11.04-64.png', 'getRasterLegend-variantJenkins.png' ] myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages(myControlImages, myPath, myTolerance) myMessage += ( '\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control image.') assert myFlag, myMessage
def test_addSymbolToLegend(self): """Test we can add a symbol to the legend.""" myLayer, _ = loadLayer('test_floodimpact.tif') myMapLegend = MapLegend(myLayer) mySymbol = QgsSymbol() mySymbol.setColor(QtGui.QColor(12, 34, 56)) myMapLegend.addSymbolToLegend(mySymbol, theMin=0, theMax=2, theCategory=None, theLabel='Foo') myPath = unique_filename(prefix='addSymblToLegend', suffix='.png', dir=temp_dir('test')) myMapLegend.getLegend().save(myPath, 'PNG') LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myControlImages = [ 'addSymbolToLegend.png', 'addSymbolToLegend-variantWindosVistaSP2-32.png', 'addSymbolToLegend-variantUB12.04-64.png', 'addSymbolToLegend-variantUB11.04-64.png', 'addSymbolToLegend-variantJenkins.png' ] myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages(myControlImages, myPath, myTolerance) myMessage += ( '\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control image.') assert myFlag, myMessage
def test_getVectorLegend(self): """Getting a legend for a vector layer works. @note This test is not related do thousand separator since we insert our own legend notes and our own layer. """ myLayer, _ = load_layer('test_shakeimpact.shp') myMapLegend = MapLegend( myLayer, theLegendNotes='Thousand separator represented by \',\'', theLegendUnits='(people per cell)') myImage = myMapLegend.getVectorLegend() myPath = unique_filename( prefix='getVectorLegend', suffix='.png', dir=temp_dir('test')) myImage.save(myPath, 'PNG') LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = check_images( 'getVectorLegend', myPath, myTolerance) myMessage += ('\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control ' 'image.') assert myFlag, myMessage
def test_getVectorLegend(self): """Getting a legend for a vector layer works.""" myLayer, _ = loadLayer('test_shakeimpact.shp') myMapLegend = MapLegend( myLayer, theLegendNotes='Thousand separator represented by \'.\'', theLegendUnits='(people per cell)') myImage = myMapLegend.getVectorLegend() myPath = unique_filename(prefix='getVectorLegend', suffix='.png', dir=temp_dir('test')) myImage.save(myPath, 'PNG') print myMapLegend.legendUnits print myMapLegend.legendNotes print myPath LOGGER.debug(myPath) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. myControlImages = ['getVectorLegend.png', 'getVectorLegend-variantWindowsVistaSP2-32.png', 'getVectorLegend-variantWindowsXPSP3-32.png', 'getVectorLegend-variantOSXml.png', 'getVectorLegend-variantUB12.04-64.png', 'getVectorLegend-variantUB11.04-64.png', 'getVectorLegend-variantLinuxMint-14-x86_64.png', 'getVectorLegend-variantWindows7-SP1-AMD64.png', 'getVectorLegend-variantJenkins.png'] myTolerance = 0 # to allow for version number changes in disclaimer myFlag, myMessage = checkImages(myControlImages, myPath, myTolerance) myMessage += ('\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control ' 'image.') assert myFlag, myMessage
def extentToKml(theExtent): """A helper to get a little kml doc for an extent so that we can use it with gdal warp for clipping.""" myBottomLeftCorner = '%f,%f' % (theExtent[0], theExtent[1]) myTopLeftCorner = '%f,%f' % (theExtent[0], theExtent[3]) myTopRightCorner = '%f,%f' % (theExtent[2], theExtent[3]) myBottomRightCorner = '%f,%f' % (theExtent[2], theExtent[1]) myKml = ("""<?xml version="1.0" encoding="utf-8" ?> <kml xmlns="http://www.opengis.net/kml/2.2"> <Document> <Folder> <Placemark> <Polygon> <outerBoundaryIs> <LinearRing> <coordinates> %s %s %s %s %s </coordinates> </LinearRing> </outerBoundaryIs> </Polygon> </Placemark> </Folder> </Document> </kml>""" % (myBottomLeftCorner, myTopLeftCorner, myTopRightCorner, myBottomRightCorner, myBottomLeftCorner)) myFilename = tempfile.mkstemp('.kml', 'extent_', temp_dir())[1] myFile = file(myFilename, 'wt') myFile.write(myKml) myFile.close() return myFilename
def test_get_vector_legend(self): """Getting a legend for a vector layer works. .. note:: This test is not related do thousand separator since we insert our own legend notes and our own layer. """ layer, _ = load_layer('test_shakeimpact.shp') map_legend = MapLegend( layer, legend_notes='Thousand separator represented by \',\'', legend_units='(people per cell)') image = map_legend.vector_legend() path = unique_filename( prefix='getVectorLegend', suffix='.png', dir=temp_dir('test')) image.save(path, 'PNG') LOGGER.debug(path) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. tolerance = 0 # to allow for version number changes in disclaimer flag, message = check_images( 'getVectorLegend', path, tolerance) message += ( '\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control image.') self.assertTrue(flag, message)
def to_pdf(self, html, filename=None): """Render an html snippet into the printer, paginating as needed. :param html: A string containing an html snippet. It will have a header and footer appended to it in order to make it a valid html document. The header will also apply the bootstrap theme to the document. :type html: str :param filename: String containing a pdf file path that the output will be written to. If no file name is given we will make up one for you - nice eh? :type filename: str :returns: The file path of the output pdf (which is the same as the filename parameter if it was specified). :rtype: str """ LOGGER.info('InaSAFE Map printToPdf called') if filename is None: html_pdf_path = unique_filename( prefix='table', suffix='.pdf', dir=temp_dir()) else: # We need to cast to python string in case we receive a QString html_pdf_path = str(filename) self.printer = setup_printer(html_pdf_path) self.load_and_wait(html_snippet=html) self.web_view.print_(self.printer) return html_pdf_path
def test_add_class_to_legend(self): """Test we can add a class to the map legend.""" layer, _ = load_layer('test_shakeimpact.shp') map_legend = MapLegend(layer) colour = QtGui.QColor(12, 34, 126) map_legend.add_class( colour, label='bar') map_legend.add_class( colour, label='foo') path = unique_filename( prefix='addClassToLegend', suffix='.png', dir=temp_dir('test')) map_legend.get_legend().save(path, 'PNG') LOGGER.debug(path) # As we have discovered, different versions of Qt and # OS platforms cause different output, so place any other possible # variants in the safe_qgis/test_data/test_images/ dir e.g. # addClassToLegend-variantUbuntu13.04.png tolerance = 0 # to allow for version number changes in disclaimer flag, message = check_images( 'addClassToLegend', path, tolerance) message += ( '\nWe want these images to match, if they do already copy the test' ' image generated to create a new control image.') self.assertTrue(flag, message)
def test_get_legend(self): """Getting a legend for a generic layer works.""" LOGGER.debug('test_get_legend called') layer, _ = load_layer('test_shakeimpact.shp') map_legend = MapLegend(layer) self.assertTrue(map_legend.layer is not None) legend = map_legend.get_legend() path = unique_filename( prefix='getLegend', suffix='.png', dir=temp_dir('test')) legend.save(path, 'PNG') LOGGER.debug(path) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. tolerance = 0 # to allow for version number changes in disclaimer flag, message = check_images('getLegend', path, tolerance) message += ( '\nWe want these images to match, if they do already ' 'copy the test image generated to create a new control ' 'image.') self.assertTrue(flag, message) LOGGER.debug('test_getLegend done')
def clone_shp_layer( name='tsunami_polygon', include_keywords=False, source_directory=TESTDATA, target_directory='testing'): """Helper function that copies a test shp layer and returns it. :param name: The default name for the shp layer. :type name: str :param include_keywords: Include keywords file if True. :type include_keywords: bool :param source_directory: Directory where the file is located. :type source_directory: str :param target_directory: Subdirectory in InaSAFE temp dir that we want to put the files into. Default to 'testing'. :type target_directory: str """ extensions = ['.shp', '.shx', '.dbf', '.prj'] if include_keywords: extensions.append('.keywords') temp_path = unique_filename(dir=temp_dir(target_directory)) # copy to temp file for ext in extensions: src_path = os.path.join(source_directory, name + ext) if os.path.exists(src_path): target_path = temp_path + ext shutil.copy2(src_path, target_path) shp_path = '%s.shp' % temp_path layer = QgsVectorLayer(shp_path, os.path.basename(shp_path), 'ogr') return layer
def test_add_symbol_to_legend(self): """Test we can add a symbol to the legend.""" layer, _ = load_layer('test_floodimpact.tif') map_legend = MapLegend(layer) symbol = QgsFillSymbolV2() symbol.setColor(QtGui.QColor(12, 34, 56)) map_legend.add_symbol( symbol, minimum=0, # expect 2.0303 in legend maximum=2.02030, label='Foo') path = unique_filename( prefix='addSymbolToLegend', suffix='.png', dir=temp_dir('test')) map_legend.get_legend().save(path, 'PNG') LOGGER.debug(path) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. tolerance = 0 # to allow for version number changes in disclaimer flag, message = check_images( 'addSymbolToLegend', path, tolerance) message += ( '\nWe want these images to match, if they do already, copy the ' 'test image generated to create a new control image.') self.assertTrue(flag, message)
def test_printToPdf(self): """Test making a pdf of the map - this is the most typical use of map. """ LOGGER.info('Testing printToPdf') myLayer, _ = loadLayer('test_shakeimpact.shp') myCanvasLayer = QgsMapCanvasLayer(myLayer) CANVAS.setLayerSet([myCanvasLayer]) myRect = QgsRectangle(106.7894, -6.2308, 106.8004, -6.2264) CANVAS.setExtent(myRect) CANVAS.refresh() myMap = Map(IFACE) myMap.setImpactLayer(myLayer) myMap.composeMap() myPath = unique_filename(prefix='mapPdfTest', suffix='.pdf', dir=temp_dir('test')) myMap.printToPdf(myPath) LOGGER.debug(myPath) myMessage = 'Rendered output does not exist: %s' % myPath assert os.path.exists(myPath), myMessage # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. mySize = os.stat(myPath).st_size myExpectedSize = 352798 # as rendered on linux ub 12.04 64 myMessage = 'Expected rendered map pdf to be at least %s, got %s' % ( myExpectedSize, mySize) assert mySize >= myExpectedSize, myMessage
def make_pdf(self, filename): """Generate the printout for our final map. :param filename: Path on the file system to which the pdf should be saved. If None, a generated file name will be used. :type filename: str :raises: TemplateElementMissingError - when template elements are missing :returns: File name of the output file (equivalent to filename if provided). :rtype: str """ LOGGER.debug('InaSAFE Map printToPdf called') self.setup_composition() self.load_template() if filename is None: map_pdf_path = unique_filename( prefix='report', suffix='.pdf', dir=temp_dir()) else: # We need to cast to python string in case we receive a QString map_pdf_path = str(filename) self.composition.exportAsPDF(map_pdf_path) return map_pdf_path
def make_pdf(self, filename): """Generate the printout for our final map. :param filename: Path on the file system to which the pdf should be saved. If None, a generated file name will be used. :type filename: str :raises: TemplateElementMissingError - when template elements are missing :returns: File name of the output file (equivalent to filename if provided). :rtype: str """ LOGGER.debug('InaSAFE Map printToPdf called') self.setup_composition() self.load_template() if filename is None: map_pdf_path = unique_filename(prefix='report', suffix='.pdf', dir=temp_dir()) else: # We need to cast to python string in case we receive a QString map_pdf_path = str(filename) self.composition.exportAsPDF(map_pdf_path) return map_pdf_path
def test_printToPdf(self): """Test that we can render some html to a pdf (most common use case). """ LOGGER.debug('InaSAFE HtmlRenderer testing printToPdf') html = self.sample_html() page_dpi = 300 renderer = HtmlRenderer(page_dpi) path = unique_filename( prefix='testHtmlTable', suffix='.pdf', dir=temp_dir('test')) LOGGER.debug(path) # If it fails new_path will come back as None new_path = renderer.to_pdf(html, path) message = 'Rendered output does not exist: %s' % new_path assert os.path.exists(new_path), message # Also it should use our desired output file name message = 'Incorrect path - got: %s\nExpected: %s\n' % ( new_path, path) assert new_path == path, message # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. size = os.stat(new_path).st_size expected_size = 16600 # as rendered on linux ub 13.04-64 (MB) message = ( 'Expected rendered map pdf to be at least %s, got %s. ' 'Please update expected_size if the rendered output ' 'is acceptible on your system.' % (expected_size, size)) assert size >= expected_size, message
def test_print_to_pdf(self): """Test that we can render some html to a pdf (most common use case). """ LOGGER.debug('InaSAFE HtmlRenderer testing printToPdf') html = self.sample_html() page_dpi = 300 renderer = HtmlRenderer(page_dpi) path = unique_filename(prefix='testHtmlTable', suffix='.pdf', dir=temp_dir('test')) LOGGER.debug(path) # If it fails new_path will come back as None new_path = renderer.to_pdf(html, path) message = 'Rendered output does not exist: %s' % new_path self.assertTrue(os.path.exists(new_path), message) # Also it should use our desired output file name message = 'Incorrect path - got: %s\nExpected: %s\n' % (new_path, path) self.assertEqual(path, new_path, message) # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. size = os.stat(new_path).st_size expected_size = 16600 # as rendered on linux ub 13.04-64 (MB) message = ('Expected rendered map pdf to be at least %s, got %s. ' 'Please update expected_size if the rendered output ' 'is acceptible on your system.' % (expected_size, size)) self.assertTrue(size >= expected_size, message)
def printToPdf(self, theFilename): """Generate the printout for our final map. Args: theFilename: str - optional path on the file system to which the pdf should be saved. If None, a generated file name will be used. Returns: str: file name of the output file (equivalent to theFilename if provided). Raises: None """ LOGGER.debug("InaSAFE Map printToPdf called") if theFilename is None: myMapPdfPath = unique_filename(prefix="report", suffix=".pdf", dir=temp_dir("work")) else: # We need to cast to python string in case we receive a QString myMapPdfPath = str(theFilename) self.composeMap() self.printer = setupPrinter(myMapPdfPath) _, myImage, myRectangle = self.renderComposition() myPainter = QtGui.QPainter(self.printer) myPainter.drawImage(myRectangle, myImage, myRectangle) myPainter.end() return myMapPdfPath
def printToPdf(self, theHtml, theFilename=None): """Render an html snippet into the printer, paginating as needed. Args: * theHtml: str A string containing an html snippet. It will have a header and footer appended to it in order to make it a valid html document. The header will also apply the bootstrap theme to the document. * theFilename: str String containing a pdf file path that the output will be written to. Returns: str: The file path of the output pdf (which is the same as the theFilename parameter if it was specified. Raises: None """ LOGGER.info('InaSAFE Map printToPdf called') if theFilename is None: myHtmlPdfPath = unique_filename( prefix='table', suffix='.pdf', dir=temp_dir('work')) else: # We need to cast to python string in case we receive a QString myHtmlPdfPath = str(theFilename) self.printer = setup_printer(myHtmlPdfPath) self.loadAndWait(theHtmlSnippet=theHtml) self.webView.print_(self.printer) return myHtmlPdfPath
def test_printImpactTable(self): """Test that we can render html from impact table keywords.""" LOGGER.debug('InaSAFE HtmlRenderer testing printImpactTable') myFilename = 'test_floodimpact.tif' myLayer, _ = load_layer(myFilename) myMessage = 'Layer is not valid: %s' % myFilename assert myLayer.isValid(), myMessage myPageDpi = 300 myHtmlRenderer = HtmlRenderer(myPageDpi) myPath = unique_filename(prefix='impactTable', suffix='.pdf', dir=temp_dir('test')) myKeywordIO = KeywordIO() myKeywords = myKeywordIO.read_keywords(myLayer) myPath = myHtmlRenderer.print_impact_table(myKeywords, filename=myPath) myMessage = 'Rendered output does not exist: %s' % myPath assert os.path.exists(myPath), myMessage # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. mySize = os.stat(myPath).st_size myExpectedSizes = [20936, # as rendered on linux ub 12.04 64 21523, # as rendered on linux ub 12.10 64 20605, # as rendered on linux ub 13.04 64 21527, # as rendered on Jenkins post 22 June 2013 377191, # as rendered on OSX 252699L, # as rendered on Windows 7 64 bit 251782L, # as rendered on Windows 8 64 bit amd 21491, # as rendered on Slackware64 14.0 ] print 'Output pdf to %s' % myPath self.assertIn(mySize, myExpectedSizes)
def test_printToPdf(self): """Test that we can render some html to a pdf (most common use case). """ LOGGER.debug('InaSAFE HtmlRenderer testing printToPdf') myHtml = self.sampleHtml() myPageDpi = 300 myRenderer = HtmlRenderer(myPageDpi) myPath = unique_filename(prefix='testHtmlTable', suffix='.pdf', dir=temp_dir('test')) LOGGER.debug(myPath) # If it fails myNewPath will come back as None myNewPath = myRenderer.to_pdf(myHtml, myPath) myMessage = 'Rendered output does not exist: %s' % myNewPath assert os.path.exists(myNewPath), myMessage # Also it should use our desired output file name myMessage = 'Incorrect path - got: %s\nExpected: %s\n' % ( myNewPath, myPath) assert myNewPath == myPath, myMessage # pdf rendering is non deterministic so we can't do a hash check # test_renderComposition renders just the image instead of pdf # so we hash check there and here we just do a basic minimum file # size check. mySize = os.stat(myNewPath).st_size myExpectedSize = 18449 # as rendered on linux ub 11.04-64 myMessage = ('Expected rendered map pdf to be at least %s, got %s. ' 'Please update myExpectedSize if the rendered output ' 'is acceptible on your system.' % (myExpectedSize, mySize)) assert mySize >= myExpectedSize, myMessage
def printImpactTable(self, theKeywords, theFilename=None): """High level table generator to print layer keywords. It gets the summary and impact table from a QgsMapLayer's keywords and renders to pdf, returning the resulting PDF file path. Args: theKeywords: dic containing impact layer keywords (required) Returns: str: Path to generated pdf file. Raises: None """ myFilePath = theFilename if theFilename is None: myFilePath = unique_filename(suffix='.pdf', dir=temp_dir()) try: mySummaryTable = theKeywords['impact_summary'] except KeyError: mySummaryTable = None myAttributionTable = impact_attribution(theKeywords) try: myFullTable = theKeywords['impact_table'] except KeyError: myFullTable = None try: myAggregationTable = theKeywords['postprocessing_report'] except KeyError: myAggregationTable = None myHtml = '' if mySummaryTable != myFullTable and mySummaryTable is not None: myHtml = '<h2>%s</h2>' % self.tr('Summary Table') myHtml += mySummaryTable if myAggregationTable is not None: myHtml += myAggregationTable if myAttributionTable is not None: myHtml += myAttributionTable.to_html() myHtml += '<h2>%s</h2>' % self.tr('Detailed Table') myHtml += myFullTable else: if myAggregationTable is not None: myHtml = myAggregationTable if myFullTable is not None: myHtml += myFullTable if myAttributionTable is not None: myHtml += myAttributionTable.to_html() # myNewFilePath should be the same as myFilePath myNewFilePath = self.printToPdf(myHtml, myFilePath) return myNewFilePath
def test_windowsDrawingArtifacts(self): """Test that windows rendering does not make artifacts""" # sometimes spurious lines are drawn on the layout LOGGER.info("Testing windowsDrawingArtifacts") myPath = unique_filename(prefix="artifacts", suffix=".pdf", dir=temp_dir("test")) myMap = Map(IFACE) setupPrinter(myPath) myMap.setupComposition() myImage = QtGui.QImage(10, 10, QtGui.QImage.Format_RGB32) myImage.setDotsPerMeterX(dpiToMeters(300)) myImage.setDotsPerMeterY(dpiToMeters(300)) # myImage.fill(QtGui.QColor(250, 250, 250)) # Look at the output, you will see antialiasing issues around some # of the boxes drawn... # myImage.fill(QtGui.QColor(200, 200, 200)) myImage.fill(200 + 200 * 256 + 200 * 256 * 256) myFilename = os.path.join(temp_dir(), "greyBox") myImage.save(myFilename, "PNG") for i in range(10, 190, 10): myPicture = QgsComposerPicture(myMap.composition) myPicture.setPictureFile(myFilename) if qgisVersion() >= 10800: # 1.8 or newer myPicture.setFrameEnabled(False) else: myPicture.setFrame(False) myPicture.setItemPosition(i, i, 10, 10) # x # y # width # height myMap.composition.addItem(myPicture) # Same drawing drawn directly as a pixmap myPixmapItem = myMap.composition.addPixmap(QtGui.QPixmap.fromImage(myImage)) myPixmapItem.setOffset(i, i + 20) # Same drawing using our drawImage Helper myWidthMM = 1 myMap.drawImage(myImage, myWidthMM, i, i + 40) myImagePath, _, _ = myMap.renderComposition() # when this test no longer matches our broken render hash # we know the issue is fixed myControlImages = ["windowsArtifacts.png"] myTolerance = 0 myFlag, myMessage = checkImages(myControlImages, myImagePath, myTolerance) myMessage += "\nWe want these images to match, if they do not " "there may be rendering artifacts in windows.\n" assert myFlag, myMessage
def test_save_scenario(self): """Test saving Current scenario.""" result, message = setup_scenario( DOCK, hazard='Flood in Jakarta', exposure='Penduduk Jakarta', function='Be impacted', function_id='Categorised Hazard Population Impact Function') self.assertTrue(result, message) # Enable on-the-fly reprojection set_canvas_crs(GEOCRS, True) set_jakarta_extent(dock=DOCK) # create unique file scenario_file = unique_filename( prefix='scenarioTest', suffix='.txt', dir=temp_dir('test')) self.save_scenario_dialog.save_scenario( scenario_file_path=scenario_file) with open(scenario_file) as f: data = f.readlines() title = data[0][:-1] exposure = data[1][:-1] hazard = data[2][:-1] function = data[3][:-1] extent = data[4][:-1] self.assertTrue( os.path.exists(scenario_file), 'File %s does not exist' % scenario_file) self.assertTrue(title == '[Flood in Jakarta]', 'Title is not the same') self.assertTrue( exposure.startswith('exposure =') and exposure.endswith( 'Population_Jakarta_geographic.asc'), 'Exposure is not the same') self.assertTrue( hazard.startswith('hazard =') and hazard.endswith( 'jakarta_flood_category_123.asc'), 'Hazard is not the same') self.assertTrue( function == ( 'function = Categorised Hazard Population Impact Function'), 'Impact function is not same') # TODO: figure out why this changed between releases if qgis_version() < 20400: # For QGIS 2.0 expected_extent = ( 'extent = 106.313333, -6.380000, 107.346667, -6.070000') self.assertEqual(expected_extent, extent) else: # for QGIS 2.4 expected_extent = ( 'extent = 106.287500, -6.380000, 107.372500, -6.070000') self.assertEqual(expected_extent, expected_extent)
def test_save_scenario(self): """Test saving Current scenario.""" result, message = setup_scenario( DOCK, hazard='Flood in Jakarta', exposure='Penduduk Jakarta', function='Be impacted', function_id='Categorised Hazard Population Impact Function') self.assertTrue(result, message) # Enable on-the-fly reprojection set_canvas_crs(GEOCRS, True) set_jakarta_extent() # create unique file scenario_file = unique_filename( prefix='scenarioTest', suffix='.txt', dir=temp_dir('test')) self.save_scenario_dialog.save_scenario( scenario_file_path=scenario_file) with open(scenario_file) as f: data = f.readlines() title = data[0][:-1] exposure = data[1][:-1] hazard = data[2][:-1] function = data[3][:-1] extent = data[4][:-1] self.assertTrue( os.path.exists(scenario_file), 'File %s does not exist' % scenario_file) self.assertTrue(title == '[Flood in Jakarta]', 'Title is not the same') self.assertTrue( exposure.startswith('exposure =') and exposure.endswith( 'Population_Jakarta_geographic.asc'), 'Exposure is not the same') self.assertTrue( hazard.startswith('hazard =') and hazard.endswith( 'jakarta_flood_category_123.asc'), 'Hazard is not the same') self.assertTrue( function == ( 'function = Categorised Hazard Population Impact Function'), 'Impact function is not same') # TODO: figure out why this changed between releases if qgis_version() < 20400: # For QGIS 2.0 expected_extent = ( 'extent = 106.313333, -6.380000, 107.346667, -6.070000') self.assertEqual(expected_extent, extent) else: # for QGIS 2.4 expected_extent = ( 'extent = 106.287500, -6.380000, 107.372500, -6.070000') self.assertEqual(expected_extent, expected_extent)
def test_runSingleScenario(self): """Test run single scenario.""" myDialog = BatchDialog(PARENT, IFACE, DOCK) myDialog.show_results_popup = False myDialog.scenario_directory_radio.setChecked(False) myDialog.source_directory.setText(SCENARIO_DIR) myDialog.source_directory.textChanged.emit(SCENARIO_DIR) myOutputDir = temp_dir() myDialog.output_directory.setText(myOutputDir) myDialog.table.selectRow(1) myButton = myDialog.run_selected_button myButton.click() myStatus = myDialog.table.item(1, 1).text() assert myStatus == 'Report Ok'
def test_run_single_scenario(self): """Test run single scenario.""" dialog = BatchDialog(PARENT, IFACE, DOCK) dialog.show_results_popup = False dialog.scenario_directory_radio.setChecked(False) dialog.source_directory.setText(SCENARIO_DIR) dialog.source_directory.textChanged.emit(SCENARIO_DIR) out_path = temp_dir() dialog.output_directory.setText(out_path) dialog.table.selectRow(1) button = dialog.run_selected_button button.click() status = dialog.table.item(1, 1).text() self.assertTrue(status == 'Report Ok')