def setUp(self):
self.iface = get_iface()
myShpFile = os.path.join(TEST_DATA_DIR, 'rectangles.shp')
layer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
QgsProject.instance().addMapLayer(layer)
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({'color': '#fdbf6f'})
sym2 = QgsFillSymbol.createSimple({'color': '#71bd6c'})
sym3 = QgsFillSymbol.createSimple({'color': '#1f78b4'})
self.r1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, '"id" = 1')
self.r2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"id" = 2')
self.r3 = QgsRuleBasedRenderer.Rule(sym3, 0, 0, 'ELSE')
self.rootrule = QgsRuleBasedRenderer.Rule(None)
self.rootrule.appendChild(self.r1)
self.rootrule.appendChild(self.r2)
self.rootrule.appendChild(self.r3)
self.renderer = QgsRuleBasedRenderer(self.rootrule)
layer.setRenderer(self.renderer)
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
rendered_layers = [layer]
self.mapsettings.setLayers(rendered_layers)
def setUp(self):
self.iface = get_iface()
QgsProject.instance().removeAllMapLayers()
self.iface.mapCanvas().viewport().resize(400, 400)
# For some reason the resizeEvent is not delivered, fake it
self.iface.mapCanvas().resizeEvent(QResizeEvent(QSize(400, 400), self.iface.mapCanvas().size()))
def setUp(self):
self.iface = get_iface()
myShpFile = os.path.join(TEST_DATA_DIR, "rectangles.shp")
layer = QgsVectorLayer(myShpFile, "Points", "ogr")
QgsMapLayerRegistry.instance().addMapLayer(layer)
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({"color": "#fdbf6f"})
sym2 = QgsFillSymbol.createSimple({"color": "#71bd6c"})
sym3 = QgsFillSymbol.createSimple({"color": "#1f78b4"})
self.r1 = QgsRuleBasedRenderer.Rule(sym1, 0, 0, '"id" = 1')
self.r2 = QgsRuleBasedRenderer.Rule(sym2, 0, 0, '"id" = 2')
self.r3 = QgsRuleBasedRenderer.Rule(sym3, 0, 0, "ELSE")
self.rootrule = QgsRuleBasedRenderer.Rule(None)
self.rootrule.appendChild(self.r1)
self.rootrule.appendChild(self.r2)
self.rootrule.appendChild(self.r3)
self.renderer = QgsRuleBasedRenderer(self.rootrule)
layer.setRenderer(self.renderer)
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
rendered_layers = [layer.id()]
self.mapsettings.setLayers(rendered_layers)
def setUp(self):
self.iface = get_iface()
polys_shp = os.path.join(TEST_DATA_DIR, 'polys.shp')
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.polys_layer = QgsVectorLayer(polys_shp, 'Polygons', 'ogr')
self.points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
QgsProject.instance().addMapLayer(self.polys_layer)
QgsProject.instance().addMapLayer(self.lines_layer)
QgsProject.instance().addMapLayer(self.points_layer)
# Create style
sym1 = QgsFillSymbol.createSimple({'color': '#fdbf6f', 'outline_color': 'black'})
sym2 = QgsLineSymbol.createSimple({'color': '#fdbf6f'})
sym3 = QgsMarkerSymbol.createSimple({'color': '#fdbf6f', 'outline_color': 'black'})
self.polys_layer.setRenderer(QgsSingleSymbolRenderer(sym1))
self.lines_layer.setRenderer(QgsSingleSymbolRenderer(sym2))
self.points_layer.setRenderer(QgsSingleSymbolRenderer(sym3))
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52))
def setUp(self):
self.iface = get_iface()
polys_shp = os.path.join(TEST_DATA_DIR, "polys.shp")
points_shp = os.path.join(TEST_DATA_DIR, "points.shp")
lines_shp = os.path.join(TEST_DATA_DIR, "lines.shp")
self.polys_layer = QgsVectorLayer(polys_shp, "Polygons", "ogr")
self.points_layer = QgsVectorLayer(points_shp, "Points", "ogr")
self.lines_layer = QgsVectorLayer(lines_shp, "Lines", "ogr")
QgsMapLayerRegistry.instance().addMapLayer(self.polys_layer)
QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer)
QgsMapLayerRegistry.instance().addMapLayer(self.points_layer)
# Create style
sym1 = QgsFillSymbol.createSimple({"color": "#fdbf6f"})
sym2 = QgsLineSymbol.createSimple({"color": "#fdbf6f"})
sym3 = QgsMarkerSymbol.createSimple({"color": "#fdbf6f"})
self.polys_layer.setRenderer(QgsSingleSymbolRenderer(sym1))
self.lines_layer.setRenderer(QgsSingleSymbolRenderer(sym2))
self.points_layer.setRenderer(QgsSingleSymbolRenderer(sym3))
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52))
def iface():
"""Helper method to get the iface for testing.
:return: The QGIS interface.
:rtype: QgsInterface
"""
from qgis.utils import iface
if iface is not None:
return iface
else:
from qgis.testing.mocked import get_iface
return get_iface()
def setUp(self):
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.layer = QgsVectorLayer(myShpFile, 'Polys', 'ogr')
QgsProject.instance().addMapLayer(self.layer)
self.iface = get_iface()
rendered_layers = [self.layer]
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
self.mapsettings.setLayers(rendered_layers)
def setUp(self):
myShpFile = os.path.join(TEST_DATA_DIR, "polys.shp")
self.layer = QgsVectorLayer(myShpFile, "Polys", "ogr")
QgsMapLayerRegistry.instance().addMapLayer(self.layer)
self.iface = get_iface()
rendered_layers = [self.layer.id()]
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
self.mapsettings.setLayers(rendered_layers)
def __init__(self, methodName):
"""Run once on class initialization."""
unittest.TestCase.__init__(self, methodName)
self.iface = get_iface()
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
self.mMapRegistry = QgsMapLayerRegistry.instance()
# create point layer
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
self.mPointLayer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.mMapRegistry.addMapLayer(self.mPointLayer)
self.mSimplifyMethod = QgsVectorSimplifyMethod()
self.mSimplifyMethod.setSimplifyHints(QgsVectorSimplifyMethod.NoSimplification)
# create polygon layer
myShpFile = os.path.join(TEST_DATA_DIR, 'polys.shp')
self.mPolygonLayer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr')
self.mPolygonLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mPolygonLayer)
# create line layer
myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.mLineLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr')
self.mLineLayer.setSimplifyMethod(self.mSimplifyMethod)
self.mMapRegistry.addMapLayer(self.mLineLayer)
# create two raster layers
myRasterFile = os.path.join(TEST_DATA_DIR, 'rgb256x256.png')
self.mRasterLayer1 = QgsRasterLayer(myRasterFile, "raster1")
self.mRasterLayer2 = QgsRasterLayer(myRasterFile, "raster2")
myMultiBandRenderer1 = QgsMultiBandColorRenderer(self.mRasterLayer1.dataProvider(), 1, 2, 3)
self.mRasterLayer1.setRenderer(myMultiBandRenderer1)
self.mMapRegistry.addMapLayer(self.mRasterLayer1)
myMultiBandRenderer2 = QgsMultiBandColorRenderer(self.mRasterLayer2.dataProvider(), 1, 2, 3)
self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
self.mMapRegistry.addMapLayer(self.mRasterLayer2)
# to match blend modes test comparisons background
self.mCanvas = self.iface.mapCanvas()
self.mCanvas.setCanvasColor(QColor(152, 219, 249))
self.mMap = self.mCanvas.map()
self.mMap.resize(QSize(400, 400))
self.mapSettings = self.mCanvas.mapSettings()
self.mapSettings.setOutputSize(QSize(400, 400))
self.mapSettings.setOutputDpi(96)
self.extent = QgsRectangle(-118.8888888888887720, 22.8002070393376783, -83.3333333333331581, 46.8719806763287536)
def setUp(self):
self.iface = get_iface()
lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
QgsProject.instance().addMapLayer(self.lines_layer)
# Create style
sym2 = QgsLineSymbol.createSimple({'color': '#fdbf6f'})
self.lines_layer.setRenderer(QgsSingleSymbolRenderer(sym2))
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-113, 28, -91, 40))
self.mapsettings.setBackgroundColor(QColor("white"))
def setUp(self):
self.iface = get_iface()
myShpFile = os.path.join(TEST_DATA_DIR, 'polys_overlapping.shp')
layer = QgsVectorLayer(myShpFile, 'Polys', 'ogr')
QgsProject.instance().addMapLayer(layer)
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({'color': '#fdbf6f', 'outline_color': 'black'})
self.renderer = QgsSingleSymbolRenderer(sym1)
layer.setRenderer(self.renderer)
rendered_layers = [layer]
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
self.mapsettings.setLayers(rendered_layers)
def setUpClass(cls):
"""Run before all tests"""
# qgis iface
cls._Iface = get_iface()
cls._Canvas = cls._Iface.mapCanvas()
# verify that spatialite provider is available
msg = '\nSpatialite provider not found, SKIPPING TEST SUITE'
# noinspection PyArgumentList
res = 'spatialite' in QgsProviderRegistry.instance().providerList()
assert res, msg
cls._TestFunction = ''
cls._TestGroup = ''
cls._TestGroupPrefix = ''
cls._TestGroupAbbr = ''
cls._TestGroupCanvasAbbr = ''
cls._TestImage = ''
cls._TestMapSettings = None
cls._Mismatch = 0
cls._Mismatches = dict()
cls._ColorTol = 0
cls._ColorTols = dict()
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
# noinspection PyArgumentList
cls._MapRegistry = QgsMapLayerRegistry.instance()
cls._MapRenderer = cls._Canvas.mapRenderer()
cls._MapSettings = cls.getBaseMapSettings()
osize = cls._MapSettings.outputSize()
cls._Canvas.resize(QSize(osize.width(), osize.height())) # necessary?
# set color to match render test comparisons background
cls._Canvas.setCanvasColor(cls._MapSettings.backgroundColor())
cls.setDefaultEngineSettings()
msg = ('\nCould not initialize PAL labeling engine, '
'SKIPPING TEST SUITE')
assert cls._PalEngine, msg
cls._BaseSetup = True
def setUp(self):
"""Run before each test."""
self.iface = get_iface()
self.mapSettings = QgsMapSettings()
self.mComposition = QgsComposition(QgsProject.instance())
self.mComposition.setPaperSize(297, 210) # A4 landscape
def setUp(self):
"""Run before each test."""
self.iface = get_iface()
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
map_report,
standard_impact_report_metadata_pdf)
from safe.report.impact_report import ImpactReport
from safe.report.report_metadata import ReportMetadata
__copyright__ = "Copyright 2016, The InaSAFE Project"
__license__ = "GPL version 3"
__email__ = "*****@*****.**"
__revision__ = '$Format:%H$'
CURRENT_DIR = os.path.abspath(os.path.realpath(os.getcwd()))
PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
USAGE = file(os.path.join(PROJECT_ROOT, 'usage.txt')).read()
LOGGER = logging.getLogger('InaSAFE')
IFACE = get_iface()
class CommandLineArguments(object):
"""Instance objects class for shell arguments.
.. versionadded:: 3.2
"""
def __init__(self, arguments_=None):
LOGGER.debug('CommandLineArguments')
# Init members
self._hazard_path = None
self._exposure_path = None
self._aggregation_path = None
self.hazard_layer = None
def setUpClass(cls):
cls.iface = get_iface()
cls.vlayer = QgsVectorLayer(
test_data_folder() + '/test_data_point.shp', 'test_data', "ogr")
cls.instance = SaveAttributes(cls.iface)
def setUp(self):
self.iface = get_iface()
self.iface.mapCanvas().viewport().resize(400, 400)
# For some reason the resizeEvent is not delivered, fake it
self.iface.mapCanvas().resizeEvent(QResizeEvent(QSize(400, 400), self.iface.mapCanvas().size()))
def setUp(self):
self.iface = get_iface()
def setUpClass(cls):
cls.iface = get_iface()
def setUp(self):
"""Run before each test."""
self.iface = get_iface()
import processing
from processing.core.Processing import Processing
Processing.initialize()
# get from https://github.com/qgis/QGIS/blob/master/tests/src/python/test_qgssymbolexpressionvariables.py
from qgis.testing.mocked import get_iface
from .config.test_config import TEST_SCHEMAS_MAPPING
# PostgreSQL connection to schema with a LADM_COL model from ./etl_script_uaecd.py
DB_HOSTNAME = "postgres"
DB_PORT = "5432"
DB_NAME = "ladm_col"
DB_USER = "******"
DB_PASSWORD = "******"
iface = get_iface()
asistente_ladm_col_plugin = AsistenteLADMCOLPlugin(iface)
asistente_ladm_col_plugin.initGui()
def get_dbconn(schema):
#global DB_HOSTNAME DB_PORT DB_NAME DB_SCHEMA DB_USER DB_USER DB_PASSWORD
dict_conn = dict()
dict_conn['host'] = DB_HOSTNAME
dict_conn['port'] = DB_PORT
dict_conn['database'] = DB_NAME
dict_conn['schema'] = schema
dict_conn['user'] = DB_USER
dict_conn['password'] = DB_PASSWORD
asistente_ladm_col_plugin.qgis_utils.set_db_connection('pg', dict_conn)
def setUp(self):
"""Run before each test."""
self.iface = get_iface()
self.layout = QgsLayout(QgsProject.instance())
self.layout.initializeDefaults()
def setUp(self):
self.iface = get_iface()
self.iface.mapCanvas().viewport().resize(400, 400)
# For some reason the resizeEvent is not delivered, fake it
self.iface.mapCanvas().resizeEvent(QResizeEvent(QSize(400, 400), self.iface.mapCanvas().size()))
def setUpClass(cls):
cls.iface = get_iface()
def setUp(self):
"""Run before each test."""
self.iface = get_iface()
self.mapSettings = QgsMapSettings()
self.mComposition = QgsComposition(QgsProject.instance())
self.mComposition.setPaperSize(297, 210) # A4 landscape
"""
__author__ = '*****@*****.**'
__date__ = '12/10/2011'
__copyright__ = 'Copyright 2016, Cadasta'
import unittest
import os
from PyQt4.QtCore import (QTranslator, QCoreApplication)
from qgis.testing.mocked import get_iface
from qgis.utils import iface
if iface:
QGIS_APP = iface
else:
QGIS_APP = get_iface()
class CadastaTranslationsTest(unittest.TestCase):
"""Test translations work."""
def setUp(self):
"""Runs before each test."""
if 'LANG' in os.environ.iterkeys():
os.environ.__delitem__('LANG')
def tearDown(self):
"""Runs after each test."""
if 'LANG' in os.environ.iterkeys():
os.environ.__delitem__('LANG')
def test_qgis_translations(self):
def setUp(self):
self.iface = get_iface()
def setUp(self):
"""Run before each test."""
self.iface = get_iface()