def initGui(self):
layout = QVBoxLayout()
self.tab = QTabWidget()
self.table = QTableView()
self.setLayout(layout)
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
settings = QSettings()
self.canvas.enableAntiAliasing(settings.value("/qgis/enable_anti_aliasing", False, type = bool))
self.canvas.useImageToRender(settings.value("/qgis/use_qimage_to_render", False, type = bool))
self.canvas.mapSettings().setDestinationCrs(self.crs)
action = settings.value("/qgis/wheel_action", 0, type = float)
zoomFactor = settings.value("/qgis/zoom_factor", 2, type = float)
self.canvas.setWheelAction(QgsMapCanvas.WheelAction(action), zoomFactor)
self.panTool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.panTool)
execute(self.createLayers)
model = GeomDiffTableModel(self.data)
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.table.resizeRowsToContents()
self.tab.addTab(self.canvas, "Map view")
self.tab.addTab(self.table, "Table view")
layout.addWidget(self.tab)
self.resize(600, 500)
self.setWindowTitle("Geometry comparison")
def linkClicked(self):
timepositions = self.coverage.timePositions()
dlg = DownloadDialog(timepositions, self.tree)
dlg.show()
dlg.exec_()
if dlg.timepositions:
folder = os.path.join(dlg.folder, self.coverage.name())
if not os.path.exists(folder):
try:
os.makedirs(folder)
except:
iface.messageBar().pushMessage("",
"Wrong output directory or error creating it",
level=QgsMessageBar.WARNING)
return
bandsFile = os.path.join(folder, "bands.json")
with open(bandsFile, "w") as f:
json.dump(self.coverage.bands, f)
startProgressBar("Downloading datacube subset", len(timepositions))
for i, time in enumerate(timepositions):
setProgressValue(i)
layer = self.coverage.layerForTimePosition(time)
execute(lambda: layer.saveTo(folder, dlg.roi))
closeProgressBar()
if dlg.openInDatacubePanel:
execute(lambda: self.widget.addEndpoint(dlg.folder))
def delete(self):
ret = QMessageBox.question(self.tree, 'Delete layer',
'Are you sure you want to delete this layer from this branch?',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if ret == QMessageBox.No:
return
execute(lambda: self._removeLayer())
def initGui(self):
layout = QVBoxLayout()
self.tab = QTabWidget()
self.table = QTableView()
self.setLayout(layout)
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
settings = QSettings()
self.canvas.enableAntiAliasing(
settings.value("/qgis/enable_anti_aliasing", False, type=bool))
self.canvas.useImageToRender(
settings.value("/qgis/use_qimage_to_render", False, type=bool))
self.canvas.mapSettings().setDestinationCrs(self.crs)
action = settings.value("/qgis/wheel_action", 0, type=float)
zoomFactor = settings.value("/qgis/zoom_factor", 2, type=float)
self.canvas.setWheelAction(QgsMapCanvas.WheelAction(action),
zoomFactor)
self.panTool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.panTool)
execute(self.createLayers)
model = GeomDiffTableModel(self.data)
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.table.resizeRowsToContents()
self.tab.addTab(self.canvas, "Map view")
self.tab.addTab(self.table, "Table view")
layout.addWidget(self.tab)
self.resize(600, 500)
self.setWindowTitle("Geometry comparison")
def revertChanges(self):
execute(lambda: revertToBaseRevision(self.gpkgPath, self.layername))
self.deletedFeatures = []
self.modifiedFeatures = []
self.addedFeatures = []
self.localChangesAvailable.emit(self.hasLocalChanges())
self.layer.triggerRepaint()
def __init__(self, repo, layer=None):
self.repo = repo
self.layer = layer
self.ref = None
QDialog.__init__(self, config.iface.mainWindow(),
Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
execute(self.initGui)
def __init__(self, repo, layer=None):
self.repo = repo
self.layer = layer
self.ref = None
QDialog.__init__(self, config.iface.mainWindow(),
Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
execute(self.initGui)
def setDiffContent(self, commit, commit2):
if self.layer is None:
layers = set(self.server.layers(self.user, self.repo, commit.commitid))
layers2 = set(self.server.layers(self.user, self.repo, commit2))
layers = layers.union(layers2)
else:
layers = [self.layer]
diffs = {layer: execute(lambda: self.server.diff(self.user, self.repo, layer, commit.commitid, commit2)) for layer in layers}
diffs = {key:value for (key,value) in diffs.items() if len(value) !=0}
layers = [l for l in diffs.keys()]
self.diffViewer.setChanges(diffs)
self.canvas.setLayers([])
self.removeMapLayers()
extent = QgsRectangle()
for layer in layers:
if not diffs[layer]:
continue
beforeLayer, afterLayer = execute(lambda: self._getLayers(diffs[layer]))
if afterLayer is not None:
resourcesPath = os.path.join(os.path.dirname(__file__), os.pardir, "resources")
oldStylePath = os.path.join(resourcesPath, "{}_before.qml".format(
QgsWkbTypes.geometryDisplayString(beforeLayer.geometryType())))
newStylePath = os.path.join(resourcesPath, "{}_after.qml".format(
QgsWkbTypes.geometryDisplayString(afterLayer.geometryType())))
beforeLayer.loadNamedStyle(oldStylePath)
afterLayer.loadNamedStyle(newStylePath)
QgsProject.instance().addMapLayer(beforeLayer, False)
QgsProject.instance().addMapLayer(afterLayer, False)
extent.combineExtentWith(beforeLayer.extent())
extent.combineExtentWith(afterLayer.extent())
self.extraLayers.append(beforeLayer)
self.extraLayers.append(afterLayer)
# make extent a bit bit (10%) bigger
# this gives some margin around the dataset (not cut-off at edges)
if not extent.isEmpty():
widthDelta = extent.width() * 0.05
heightDelta = extent.height() * 0.05
extent = QgsRectangle(extent.xMinimum() - widthDelta,
extent.yMinimum() - heightDelta,
extent.xMaximum() + widthDelta,
extent.yMaximum() + heightDelta)
layers = self.extraLayers
hasChanges = False
for layer in layers:
if layer is not None and layer.featureCount() > 0:
hasChanges = True
break
self.canvas.setLayers(layers)
self.canvas.setExtent(extent)
self.canvas.refresh()
self.canvas.setVisible(hasChanges)
self.labelNoChanges.setVisible(not hasChanges)
def updateCurrentRepo(self, repo, force=False):
if repo == self.currentRepo and not force:
return
def _update():
self.currentRepo = repo
self.versionsTree.updateContent(repo)
try:
self.repoTree.setSelectionMode(QAbstractItemView.NoSelection)
self.repoTree.blockSignals(True)
execute(_update)
finally:
self.repoTree.setSelectionMode(QAbstractItemView.SingleSelection)
self.repoTree.blockSignals(False)
def summaryTextBrowserAnchorClicked(self,url):
url = url.url() #convert to string
item = self.history.currentItem()
if item is None:
return
commitid = item.commit.commitid
cmd,layerName = url.split(".",1)
if cmd == "addLive":
execute(lambda: self.history.exportVersion(layerName,commitid,True))
elif cmd == "addGeoPKG":
self.history.exportVersion(layerName,commitid,False)
elif cmd == "exportDiff":
execute(lambda: self.history.exportDiff(item, None,layer=layerName))
def plot(self,
_filter=None,
parameter=None,
coverage=None,
dataset=None,
pt=None,
rectangle=None):
self.parameter = parameter or self.parameter
self.coverage = coverage or self.coverage
self.dataset = dataset or self.dataset
self.pt = pt
self.rectangle = rectangle
self.filter = _filter
execute(self._plot)
def local(self):
if self.conflict.localFeature is None:
if self._local is None:
self._local = execute(lambda: self.conflict.repo.feature(self.conflict.path, self.conflict.localCommit))
return self._local
else:
return self.conflict.localFeature
def local(self):
if self.conflict.localFeature is None:
if self._local is None:
self._local = execute(lambda: self.conflict.repo.feature(
self.conflict.path, self.conflict.localCommit))
return self._local
else:
return self.conflict.localFeature
def addRepoEndpoint(url, title):
global repoEndpoints
global repos
repoEndpoints[title] = url
saveRepoEndpoints()
_repos = execute(lambda: repositoriesFromUrl(url, title))
repos.extend(_repos)
availableRepoEndpoints[title] = url
return _repos
def textPullRequestInfoAnchorClicked(self, url):
url = url.url() # convert to string
cmd, layerName = url.split(".", 1)
if cmd == "editDesc":
dlg = EditDescription(self.prDescription)
r = dlg.exec_()
if r:
self.prDescription = dlg.description
self.setupInfo()
if cmd == "exportDiff":
execute(lambda: self.exportDiff(layer=layerName))
if cmd == "exportDiffLocal":
execute(lambda: self.exportDiffLocal(layer=layerName))
if cmd == "sync":
if self.creatingPr:
user = self.user
repo = self.repo
user2, repo2 = self.comboTarget.currentText().split(":")
syncDialog = SynchronizeDialog(user, repo, self.server, user2,
repo2, False)
syncDialog.exec_()
try:
self.showNormal()
self.raise_()
self.activateWindow()
except:
pass
else:
pr = self.prs[self.comboPr.currentText()]
user = pr["sourceRepo"]["owner"]["identity"]
repo = pr["sourceRepo"]["identity"]
user2 = pr["targetRepo"]["owner"]["identity"]
repo2 = pr["targetRepo"]["identity"]
syncDialog = SynchronizeDialog(user, repo, self.server, user2,
repo2, False)
syncDialog.exec_()
try:
self.showNormal()
self.raise_()
self.activateWindow()
except:
pass
self.fillWithPrData()
def tabChanged(self, tabIdx):
THRESHOLD = 1500
if tabIdx != 2: # the full changed view
return
if self.fullHistory is not None:
return
if not self.fullDiffSummary:
return
if self.fullDiffSummaryTotal > THRESHOLD:
text = QTextBrowser()
text.setHtml(
"<br><br><br><center><font size=+3><b>Too many changes to show - {:,} features changed</b></font>"
.format(self.fullDiffSummaryTotal))
layout = self.tabWidget.widget(2).layout()
self.clearLayout(layout)
#layout.setMargin(0)
layout.addWidget(text)
self.fullHistory = layout
#self.tabWidget.widget(2).setLayout(layout)
return
# need to set it up
layout = self.tabWidget.widget(2).layout()
self.clearLayout(layout)
#layout.setMargin(0)
pr = self.prs[self.comboPr.currentText()]
prid = pr["id"]
total, diffsummary = self.server.diffSummaryPR(self.user, self.repo,
prid)
if total is None:
text = QTextBrowser()
text.setHtml(
"<br><br><br><center><font size=+3><b>PR is in Conflict - Please Synchronize</b></font>"
.format(self.fullDiffSummaryTotal))
layout = self.tabWidget.widget(2).layout()
#layout.setMargin(0)
self.clearLayout(layout)
layout.addWidget(text)
self.fullHistory = layout
#self.tabWidget.widget(2).setLayout(layout)
return
layers = [l["path"] for l in diffsummary.values()]
diffs = {
layer: execute(lambda: list(
self.server.diffPR(self.user, self.repo, layer, prid)[1]))
for layer in layers
}
fullDiffView = DiffViewerWidget(diffs)
fullDiffView.selectFirstChangedFeature()
layout.addWidget(fullDiffView)
self.fullHistory = layout
def computeDiffs(self):
self.commit1 = self.commit1Panel.getRef()
self.commit2 = self.commit2Panel.getRef()
self.featuresTree.clear()
changes = execute(lambda: self.repo.diff(self.commit1.commitid, self.
commit2.commitid))
layerItems = {}
layerSubItems = {}
self.changes = {}
for c in changes:
self.changes[c.path] = c
layername = c.path.split("/")[0]
featureid = c.path.split("/")[-1]
if layername not in layerItems:
item = QTreeWidgetItem()
item.setText(0, layername)
item.setIcon(0, layerIcon)
layerItems[layername] = item
addedItem = QTreeWidgetItem()
addedItem.setText(0, "Added")
addedItem.setIcon(0, addedIcon)
removedItem = QTreeWidgetItem()
removedItem.setText(0, "Removed")
removedItem.setIcon(0, removedIcon)
modifiedItem = QTreeWidgetItem()
modifiedItem.setText(0, "Modified")
modifiedItem.setIcon(0, modifiedIcon)
layerSubItems[layername] = {
FEATURE_ADDED: addedItem,
FEATURE_REMOVED: removedItem,
FEATURE_MODIFIED: modifiedItem
}
item = FeatureItem(layername, featureid)
layerSubItems[layername][c.changetype].addChild(item)
for layername, item in layerItems.iteritems():
for i in [FEATURE_ADDED, FEATURE_REMOVED, FEATURE_MODIFIED]:
subItem = layerSubItems[layername][i]
item.addChild(subItem)
subItem.setText(
0, "%s [%i features]" %
(subItem.text(0), subItem.childCount()))
self.featuresTree.addTopLevelItem(item)
self.attributesTable.clear()
self.attributesTable.verticalHeader().hide()
self.attributesTable.horizontalHeader().hide()
self.featuresTree.expandAll()
def pull(self):
dlg = RemoteRefDialog(self.repo)
dlg.exec_()
if dlg.remote is not None:
conflicts = execute(lambda: self.repo.pull(dlg.remote, dlg.branch))
if conflicts:
ret = QMessageBox.warning(
iface.mainWindow(), "Conflict(s) found while syncing",
"There are conflicts between local repository and connection.\n"
"Do you want to continue and fix them?",
QMessageBox.Yes | QMessageBox.No)
if ret == QMessageBox.No:
self.repo.closeTransaction(conflicts[0].transactionId)
return
dlg = ConflictDialog(conflicts)
dlg.exec_()
solved, resolvedConflicts = dlg.solved, dlg.resolvedConflicts
if not solved:
self.repo.closeTransaction(conflicts[0].transactionId)
return
for conflict, resolution in zip(
conflicts, list(resolvedConflicts.values())):
if resolution == ConflictDialog.LOCAL:
conflict.resolveWithLocalVersion()
elif resolution == ConflictDialog.REMOTE:
conflict.resolveWithRemoteVersion()
elif resolution == ConflictDialog.DELETE:
conflict.resolveDeletingFeature()
else:
conflict.resolveWithNewFeature(resolution)
user, email = config.getUserInfo()
if user is None:
return
self.repo.commitAndCloseMergeAndTransaction(
user, email, "Resolved merge conflicts",
conflicts[0].transactionId)
config.iface.messageBar().pushMessage(
"Changes have been correctly pulled from the connection",
level=QgsMessageBar.INFO,
duration=5)
repoWatcher.repoChanged.emit(self.repo)
else:
config.iface.messageBar().pushMessage(
"Changes have been correctly pulled from the connection",
level=QgsMessageBar.INFO,
duration=5)
repoWatcher.repoChanged.emit(self.repo)
def computeDiffs(self):
self.commit1 = self.commit1Panel.getRef()
self.commit2 = self.commit2Panel.getRef()
self.featuresTree.clear()
changes = execute(lambda: self.repo.diff(self.commit1.commitid, self.commit2.commitid))
layerItems = {}
layerSubItems = {}
self.changes = {}
for c in changes:
self.changes[c.path] = c
layername = c.path.split("/")[0]
featureid = c.path.split("/")[-1]
if layername not in layerItems:
item = QTreeWidgetItem()
item.setText(0, layername)
item.setIcon(0, layerIcon)
layerItems[layername] = item
addedItem = QTreeWidgetItem()
addedItem.setText(0, "Added")
addedItem.setIcon(0, addedIcon)
removedItem = QTreeWidgetItem()
removedItem.setText(0, "Removed")
removedItem.setIcon(0, removedIcon)
modifiedItem = QTreeWidgetItem()
modifiedItem.setText(0, "Modified")
modifiedItem.setIcon(0, modifiedIcon)
layerSubItems[layername] = {FEATURE_ADDED: addedItem,
FEATURE_REMOVED: removedItem,
FEATURE_MODIFIED:modifiedItem}
item = FeatureItem(layername, featureid)
layerSubItems[layername][c.changetype].addChild(item)
for layername, item in layerItems.iteritems():
for i in [FEATURE_ADDED, FEATURE_REMOVED, FEATURE_MODIFIED]:
subItem = layerSubItems[layername][i]
item.addChild(subItem)
subItem.setText(0, "%s [%i features]" %
(subItem.text(0),
subItem.childCount()))
self.featuresTree.addTopLevelItem(item)
self.attributesTable.clear()
self.attributesTable.verticalHeader().hide()
self.attributesTable.horizontalHeader().hide()
self.featuresTree.expandAll()
def refreshEndpoint(name):
global repos
global repoEndpoints
global availableRepoEndpoints
if name in availableRepoEndpoints:
del availableRepoEndpoints[name]
for repo in repos[::-1]:
if repo.group == name:
repos.remove(repo)
if name in repoEndpoints:
try:
_repos = execute(
lambda: repositoriesFromUrl(repoEndpoints[name], name))
repos.extend(_repos)
availableRepoEndpoints[name] = repoEndpoints[name]
except:
pass
def readRepos():
global repos
global repoEndpoints
global availableRepoEndpoints
repos = []
repoEndpoints = {}
availableRepoEndpoints = {}
filename = os.path.join(userFolder(), "repositories")
if os.path.exists(filename):
repoDescs = json.load(open(filename))
for r in repoDescs:
repoEndpoints[r["title"]] = r["url"]
try:
_repos = execute(
lambda: repositoriesFromUrl(r["url"], r["title"]))
repos.extend(_repos)
availableRepoEndpoints[r["title"]] = r["url"]
except:
pass
def createRepo(self):
name, ok = QInputDialog.getText(self, 'Create repository',
'Enter the repository name:')
if ok:
group = self.comboEndpoint.currentText()
url = repository.repoEndpoints[group]
try:
repo = execute(lambda: createRepoAtUrl(url, group, name))
except GeoGigException as e:
config.iface.messageBar().pushMessage("Error", str(e),
level=QgsMessageBar.CRITICAL,
duration=5)
return
item = RepoItem(self, self.repoTree, repo)
addRepo(repo)
self.repoTree.addTopLevelItem(item)
config.iface.messageBar().pushMessage("Create repository", "Repository correctly created",
level=QgsMessageBar.INFO,
duration=5)
def addOrRemoveLayer(self):
source = self.layer.source()
if self.checkState(0) == Qt.Checked:
try:
layer = layerFromSource(source)
except WrongLayerSourceException:
layer = execute(self.layer.layer)
if layer.isValid():
coverageName = self.layer.coverageName()
name = self.layer.datasetName()
addLayerIntoGroup(layer, name, coverageName, self.layer.bands())
mosaicWidget.updateDates()
else:
iface.messageBar().pushMessage("", "Invalid layer.",
level=QgsMessageBar.WARNING)
else:
try:
layer = layerFromSource(source)
QgsMapLayerRegistry.instance().removeMapLayers([layer.id()])
except WrongLayerSourceException:
pass
def pull(self):
dlg = RemoteRefDialog(self.repo)
dlg.exec_()
if dlg.remote is not None:
conflicts = execute(lambda: self.repo.pull(dlg.remote, dlg.branch))
if conflicts:
ret = QMessageBox.warning(iface.mainWindow(), "Conflict(s) found while syncing",
"There are conflicts between local repository and connection.\n"
"Do you want to continue and fix them?",
QMessageBox.Yes | QMessageBox.No)
if ret == QMessageBox.No:
self.repo.closeTransaction(conflicts[0].transactionId)
return
dlg = ConflictDialog(conflicts)
dlg.exec_()
solved, resolvedConflicts = dlg.solved, dlg.resolvedConflicts
if not solved:
self.repo.closeTransaction(conflicts[0].transactionId)
return
for conflict, resolution in zip(conflicts, list(resolvedConflicts.values())):
if resolution == ConflictDialog.LOCAL:
conflict.resolveWithLocalVersion()
elif resolution == ConflictDialog.REMOTE:
conflict.resolveWithRemoteVersion()
elif resolution == ConflictDialog.DELETE:
conflict.resolveDeletingFeature()
else:
conflict.resolveWithNewFeature(resolution)
user, email = config.getUserInfo()
if user is None:
return
self.repo.commitAndCloseMergeAndTransaction(user, email, "Resolved merge conflicts", conflicts[0].transactionId)
config.iface.messageBar().pushMessage("Changes have been correctly pulled from the connection",
level = QgsMessageBar.INFO, duration = 5)
repoWatcher.repoChanged.emit(self.repo)
else:
config.iface.messageBar().pushMessage("Changes have been correctly pulled from the connection",
level = QgsMessageBar.INFO, duration = 5)
repoWatcher.repoChanged.emit(self.repo)
def addEndpoint(self, endpoint):
execute(lambda: self.widget.addEndpoint(endpoint))
def createMosaic(self):
execute(self._createMosaic)
def _apicall(self, command, payload={}, transaction=False):
return execute(lambda: self.__apicall(command, payload, transaction))
def remote(self):
if self._remote is None:
self._remote = execute(lambda: self.conflict.repo.feature(
self.conflict.path, self.conflict.remoteCommit))
return self._remote
def origin(self):
if self._origin is None:
self._origin = execute(lambda: self.conflict.repo.feature(self.conflict.path, self.conflict.originCommit))
return self._origin
def remote(self):
if self._remote is None:
self._remote = execute(lambda: self.conflict.repo.feature(self.conflict.path, self.conflict.remoteCommit))
return self._remote
def origin(self):
if self._origin is None:
self._origin = execute(lambda: self.conflict.repo.feature(
self.conflict.path, self.conflict.originCommit))
return self._origin
def runNextStep(self):
self.stopBlinking()
test = self.tests[self.currentTest]
step = test.steps[self.currentTestStep]
self.btnSkip.setEnabled(True)
self.btnCancel.setEnabled(True)
if os.path.exists(step.description):
with open(step.description) as f:
html = "".join(f.readlines())
self.webView.setHtml(html)
else:
if step.function is not None:
self.webView.setHtml(
step.description +
"<p><b>[This is an automated step. Please, wait until it has been completed]</b></p>"
)
else:
self.webView.setHtml(
step.description +
"<p><b>[Click on the right-hand side buttons once you have performed this step]</b></p>"
)
QCoreApplication.processEvents()
if self.currentTestStep == len(test.steps) - 1:
if step.function is not None:
self.btnTestOk.setEnabled(False)
self.btnTestFailed.setEnabled(False)
self.btnNextStep.setEnabled(False)
self.btnSkip.setEnabled(False)
self.btnCancel.setEnabled(False)
self.webView.setEnabled(False)
QCoreApplication.processEvents()
try:
execute(step.function)
self.testPasses()
except Exception as e:
if isinstance(e, AssertionError):
self.testFails("%s\n%s" %
(str(e), traceback.format_exc()))
else:
self.testContainsError(
"%s\n%s" % (str(e), traceback.format_exc()))
else:
self.btnTestOk.setEnabled(True)
self.btnTestOk.setText("Test passes")
self.btnTestFailed.setEnabled(True)
self.btnTestFailed.setText("Test fails")
self.webView.setEnabled(True)
self.btnNextStep.setEnabled(False)
if step.prestep:
try:
execute(step.prestep)
except Exception as e:
if isinstance(e, AssertionError):
self.testFailsAtSetup(
"%s\n%s" % (str(e), traceback.format_exc()))
else:
self.testContainsError(
"%s\n%s" % (str(e), traceback.format_exc()))
else:
if step.function is not None:
self.btnTestOk.setEnabled(False)
self.btnTestFailed.setEnabled(False)
self.btnNextStep.setEnabled(False)
self.btnSkip.setEnabled(False)
self.btnCancel.setEnabled(False)
self.webView.setEnabled(False)
QCoreApplication.processEvents()
try:
execute(step.function)
self.currentTestStep += 1
self.runNextStep()
except Exception as e:
if isinstance(e, AssertionError):
self.testFails("%s\n%s" %
(str(e), traceback.format_exc()))
else:
self.testContainsError(
"%s\n%s" % (str(e), traceback.format_exc()))
else:
self.currentTestStep += 1
self.webView.setEnabled(True)
self.btnNextStep.setEnabled(not step.isVerifyStep)
if step.isVerifyStep:
self.btnTestOk.setEnabled(True)
self.btnTestOk.setText("Step passes")
self.btnTestFailed.setEnabled(True)
self.btnTestFailed.setText("Step fails")
else:
self.btnTestOk.setEnabled(False)
self.btnTestFailed.setEnabled(False)
if step.prestep:
try:
execute(step.prestep)
except Exception as e:
if isinstance(e, AssertionError):
self.testFailsAtSetup(
"%s\n%s" % (str(e), traceback.format_exc()))
else:
self.testContainsError(
"%s\n%s" % (str(e), traceback.format_exc()))
if step.function is None:
self.startBlinking()
def runNextStep(self):
self.stopBlinking()
test = self.tests[self.currentTest]
step = test.steps[self.currentTestStep]
self.btnSkip.setEnabled(True)
self.btnCancel.setEnabled(True)
if os.path.exists(step.description):
with open(step.description) as f:
html = "".join(f.readlines())
self.webView.setHtml(html)
else:
if step.function is not None:
self.webView.setHtml(step.description + "<p><b>[This is an automated step. Please, wait until it has been completed]</b></p>")
else:
self.webView.setHtml(step.description + "<p><b>[Click on the right-hand side buttons once you have performed this step]</b></p>")
QCoreApplication.processEvents()
if self.currentTestStep == len(test.steps) - 1:
if step.function is not None:
self.btnTestOk.setEnabled(False)
self.btnTestFailed.setEnabled(False)
self.btnNextStep.setEnabled(False)
self.btnSkip.setEnabled(False)
self.btnCancel.setEnabled(False)
self.webView.setEnabled(False)
QCoreApplication.processEvents()
try:
execute(step.function)
self.testPasses()
except Exception as e:
if isinstance(e, AssertionError):
self.testFails("%s\n%s" % (str(e), traceback.format_exc()))
else:
self.testContainsError("%s\n%s" % (str(e), traceback.format_exc()))
else:
self.btnTestOk.setEnabled(True)
self.btnTestOk.setText("Test passes")
self.btnTestFailed.setEnabled(True)
self.btnTestFailed.setText("Test fails")
self.webView.setEnabled(True)
self.btnNextStep.setEnabled(False)
if step.prestep:
try:
execute(step.prestep)
except Exception as e:
if isinstance(e, AssertionError):
self.testFailsAtSetup("%s\n%s" % (str(e), traceback.format_exc()))
else:
self.testContainsError("%s\n%s" % (str(e), traceback.format_exc()))
else:
if step.function is not None:
self.btnTestOk.setEnabled(False)
self.btnTestFailed.setEnabled(False)
self.btnNextStep.setEnabled(False)
self.btnSkip.setEnabled(False)
self.btnCancel.setEnabled(False)
self.webView.setEnabled(False)
QCoreApplication.processEvents()
try:
execute(step.function)
self.currentTestStep += 1
self.runNextStep()
except Exception as e:
if isinstance(e, AssertionError):
self.testFails("%s\n%s" % (str(e), traceback.format_exc()))
else:
self.testContainsError("%s\n%s" % (str(e), traceback.format_exc()))
else:
self.currentTestStep += 1
self.webView.setEnabled(True)
self.btnNextStep.setEnabled(not step.isVerifyStep)
if step.isVerifyStep:
self.btnTestOk.setEnabled(True)
self.btnTestOk.setText("Step passes")
self.btnTestFailed.setEnabled(True)
self.btnTestFailed.setText("Step fails")
else:
self.btnTestOk.setEnabled(False)
self.btnTestFailed.setEnabled(False)
if step.prestep:
try:
execute(step.prestep)
except Exception as e:
if isinstance(e, AssertionError):
self.testFailsAtSetup("%s\n%s" % (str(e), traceback.format_exc()))
else:
self.testContainsError("%s\n%s" % (str(e), traceback.format_exc()))
if step.function is None:
self.startBlinking()
def exportAllDiff(self):
execute(lambda: self.exportDiff())
