Develop Reference

How pyqt use unittest to check login name and password and result?

my error message is
AttributeError: type object 'MainWindow' has no attribute
'nameLineEdit'
i try use pyqt unittest check login name and password (cause my project is pyqt5)
but many unittest are for not gui python project
so i google a tutorial(the tutorial is for pyqt4 but i will need use pyqt5)
http://johnnado.com/pyqt-qtest-example/
below is my project source code
https://drive.google.com/file/d/1gxVzY2yg83_y5OmHYUprsljMoP5xhbLT/view?usp=sharing
and i record my screen
https://youtu.be/yiMUGphm6fk
about project
my simple pyqt5 project to practice unittest to check login status
i follow a pyqt4 project tutorial ,but not work the project include three scripts
first script(main.py)
# -*- coding: utf-8 -*-
"""
Module implementing MainWindow.
"""
import sys
from PyQt5.QtCore import pyqtSlot
from PyQt5.QtWidgets import QMainWindow, QApplication
from Ui_main import Ui_MainWindow
class MainWindow(QMainWindow, Ui_MainWindow):
"""
Class documentation goes here.
"""
def __init__(self, parent=None):
"""
Constructor
#param parent reference to the parent widget
#type QWidget
"""
super(MainWindow, self).__init__(parent)
self.setupUi(self)
#pyqtSlot()
def on_loginButton_clicked(self):
if self.nameLineEdit.text()=='admin' and self.passwordLineEdit.text()=='123456':
self.loginStatusLabel.setText('Success Login')
else:
self.loginStatusLabel.setText('Failed Login')
if __name__=="__main__":
app=QApplication(sys.argv)
Main=MainWindow()
Main.show()
sys.exit(app.exec_())
second script (test_login.py)
import sys
import unittest
from PyQt5 import QtCore
from PyQt5.QtWidgets import QMainWindow, QApplication
from PyQt5.QtTest import QTest
import main
app = QApplication(sys.argv)
class test01(unittest.TestCase):
'''Test the margarita mixer GUI'''
def setUp(self):
print('inital ok')
def test_defaults(self):
self.nameLineEdit=main.MainWindow.nameLineEdit
self.passwordLineEdit=main.MainWindow.passwordLineEdit
loginButton = main.MainWindow.loginButton
self.assertEqual(self.nameLineEdit.text(), 'admin')
self.assertEqual(self.passwordLineEdit.text(), '123456')
QTest.mouseClick(loginButton, QtCore.Qt.LeftButton)
if __name__ == "__main__":
unittest.main()
third script(Ui_main)
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'F:\project\pyqt_unitest01\main.ui'
#
# Created by: PyQt5 UI code generator 5.10.1
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(302, 157)
self.centralWidget = QtWidgets.QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
self.loginButton = QtWidgets.QPushButton(self.centralWidget)
self.loginButton.setGeometry(QtCore.QRect(200, 100, 81, 41))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(16)
self.loginButton.setFont(font)
self.loginButton.setObjectName("loginButton")
self.nameLineEdit = QtWidgets.QLineEdit(self.centralWidget)
self.nameLineEdit.setGeometry(QtCore.QRect(110, 10, 181, 31))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(16)
self.nameLineEdit.setFont(font)
self.nameLineEdit.setObjectName("nameLineEdit")
self.passwordLineEdit = QtWidgets.QLineEdit(self.centralWidget)
self.passwordLineEdit.setGeometry(QtCore.QRect(110, 60, 181, 31))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(16)
self.passwordLineEdit.setFont(font)
self.passwordLineEdit.setObjectName("passwordLineEdit")
self.nameLabel = QtWidgets.QLabel(self.centralWidget)
self.nameLabel.setGeometry(QtCore.QRect(20, 10, 81, 31))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(16)
self.nameLabel.setFont(font)
self.nameLabel.setObjectName("nameLabel")
self.passwordLabel = QtWidgets.QLabel(self.centralWidget)
self.passwordLabel.setGeometry(QtCore.QRect(20, 60, 81, 31))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(16)
self.passwordLabel.setFont(font)
self.passwordLabel.setObjectName("passwordLabel")
self.loginStatusLabel = QtWidgets.QLabel(self.centralWidget)
self.loginStatusLabel.setGeometry(QtCore.QRect(20, 105, 141, 31))
font = QtGui.QFont()
font.setFamily("Agency FB")
font.setPointSize(16)
self.loginStatusLabel.setFont(font)
self.loginStatusLabel.setObjectName("loginStatusLabel")
MainWindow.setCentralWidget(self.centralWidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.loginButton.setText(_translate("MainWindow", "login"))
self.nameLabel.setText(_translate("MainWindow", "name"))
self.passwordLabel.setText(_translate("MainWindow", "password"))
self.loginStatusLabel.setText(_translate("MainWindow", "login_status"))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
how to correct use unittest to test pyqt5 project (or any better idea or framework)
thank you everybody!!

The problem that you show is the little knowledge about OOP, the classes are abstractions or molds, they only serve to create objects, and that is what you have not done, so one part of the solution is to create an object of the MainWindow class.
On the other hand the testing is done to verify the correct functioning, in your case the verification could not occur in the QLineEdits since for this to have text you must place it, the correct thing is to verify the loginStatusLabel since the GUI is the one that has control about it, that is, the user places the username and password, clicks and consequently the indicated label must change.
import sys
import unittest
from PyQt5 import QtCore, QtWidgets, QtTest
from main import MainWindow
app = QtWidgets.QApplication(sys.argv)
class test01(unittest.TestCase):
'''Test the margarita mixer GUI'''
def setUp(self):
self.form = MainWindow()
def test_defaults(self):
self.form.nameLineEdit.setText('admin')
self.form.passwordLineEdit.setText('123456')
QtTest.QTest.mouseClick(self.form.loginButton, QtCore.Qt.LeftButton)
self.assertEqual(self.form.loginStatusLabel.text(), 'Success Login')
if __name__ == "__main__":
unittest.main()

update a python ui without rewrite all the button event

I'm looking for a better way to handle python UI "update" from QtDesigner without overwrite button event. The workflow I got now is:
Design UI layout in QtDesigner
convert .ui to .py by pyuic5
adding button event in .py file
excute .py to see window and button action
So if my UI keep changing the design, how do I keep all the button event I add into .py without being overwrite after convert? Thank you.

Answer my own question, what I found is have three python files. Main.py, CallUI.py and MainWindow.py. (Named as you want.)
So you can keep regenerate UI and override MainWindow.py without clear button event you wrote.
1.Main.py is the one to launch everything, name == "main". Call CAllUI.py's setup function.
#Main.py
from PyQt5 import QtCore, QtGui, QtWidgets
import sys
import CallUI
def setUp():
CallUI.setUpWindow()
raw_input()
if __name__ == "__main__":
setUp()
2.CallUI.py is the one to use "QtWidgets.QApplication(sys.argv)" to show UI and add button click functions.
#CallUI.py
import sys
from MainWindow import Ui_Dialog
from PyQt5 import QtCore, QtGui, QtWidgets
import os
class CallUI(QtWidgets.QWidget):
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.setUpBtnconnect()
def setUpBtnconnect(self):
self.ui.pushButton.clicked.connect(self.myFunction)
def myFunction(self):
os.system("ipconfig")
raw_input()
def setUpWindow():
app = QtWidgets.QApplication(sys.argv)
nowWindow = CallUI()
nowWindow.show()
sys.exit(app.exec_())
3.MainWindow.py is the one you converted from pyuic5, it's describe all the UI layout.
#MainWindow.py
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_Dialog(object):
def setupUi(self, Dialog):
Dialog.setObjectName("MainWindow")
Dialog.resize(466, 417)
self.centralwidget = QtWidgets.QWidget(Dialog)
self.centralwidget.setObjectName("centralwidget")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(160, 260, 75, 23))
self.pushButton.setObjectName("pushButton")
self.menubar = QtWidgets.QMenuBar(Dialog)
self.menubar.setGeometry(QtCore.QRect(0, 0, 466, 21))
self.menubar.setObjectName("menubar")
self.statusbar = QtWidgets.QStatusBar(Dialog)
self.statusbar.setObjectName("statusbar")
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def retranslateUi(self, Dialog):
_translate = QtCore.QCoreApplication.translate
self.pushButton.setText(_translate("MainWindow", "PushButton"))

Using Qt Designer 5.8 with PyQt5: problematic example from PyQt v3

I understand (more or less) content of the page of official documentation except the the final example, which is essencially as follows (I do not care the button):
from ui_imagedialog import ImageDialog
class MyImageDialog(ImageDialog):
def __init__(self):
super(MyImageDialog, self).__init__()
# Connect up the buttons.
self.okButton.clicked.connect(self.accept)
Problem: I'm stuck a bit trying to understand how to make this snippet work. It rises an error: 'cannon import name ImageDialog'.
What should I add from the first example of the aforementioned documentation page to make this code to show up a Dialog window?
What I've tried:
I've made the file with generated Python code with the name ui_imagedialog.py as requiered. It has the the following content, which obviously works on its own:
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_ImageDialog(object):
def setupUi(self, ImageDialog):
ImageDialog.setObjectName("ImageDialog")
ImageDialog.resize(303, 204)
self.pushButton = QtWidgets.QPushButton(ImageDialog)
self.pushButton.setGeometry(QtCore.QRect(200, 160, 75, 23))
self.pushButton.setObjectName("pushButton")
self.retranslateUi(ImageDialog)
QtCore.QMetaObject.connectSlotsByName(ImageDialog)
def retranslateUi(self, ImageDialog):
_translate = QtCore.QCoreApplication.translate
ImageDialog.setWindowTitle(_translate("ImageDialog", "Dialog"))
self.pushButton.setText(_translate("ImageDialog", "PushButton"))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
ImageDialog = QtWidgets.QDialog()
ui = Ui_ImageDialog()
ui.setupUi(ImageDialog)
ImageDialog.show()
sys.exit(app.exec_())
Any constructive help is appreciated.

Qt Designer is used to create the graphic part, but not for the logic, you must create the logical part depending on the widget you used in the design. In your case by the name I think it is QDialog.
from ui_imagedialog import Ui_ImageDialog
from PyQt5 import QtCore, QtGui, QtWidgets
class ImageDialog(QtWidgets.QDialog, Ui_ImageDialog):
def __init__(self, parent=None):
super(ImageDialog, self).__init__(parent=parent)
self.setupUi(self)
self.pushButton.clicked.connect(self.accept)
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
w = ImageDialog()
w.show()
sys.exit(app.exec_())
Observations: In the ui_imagedialog.py file there is no ImageDialog class, only the Ui_ImageDialog class, so I generated the error. Also in the design the button is called self.pushButton, so you can not call it self.okButton.

How do I hide current window while opening a new one using PyQt5

I've linked another file to a pushButton in my main window. Every time I click it, the new window does open but the old (primary window) is still there. How do I close it or hide it without affecting the new window.
PS: I'm a newcomer here. Apologies for any idiocies or mistakes while posting this query on my part. Thank you!
Here's the relevant code:
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
from create2 import Ui_MainWindow
from PyQt5.QtWidgets import QMainWindow, QWidget
from PyQt5.QtCore import QMargins
class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(813, 655)
self.widget = QtWidgets.QWidget(Form)
self.widget.setGeometry(QtCore.QRect(190, 50, 501, 591))
self.widget.setObjectName("widget")
.
.
.
def newusr_clk(self):
self.mainwin=QMainWindow()
self.ui=Ui_MainWindow()
self.ui.setupUi(self.mainwin)
self.mainwin.show()

Here's a complete working example. The main window is just a QMainWindow. It will open a QDialog on button click. Their ui definitions:
# file ui_main.py
from PyQt5 import QtCore, QtWidgets
class Ui_MainWindow:
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(442, 205)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(180, 80, 75, 23))
self.pushButton.setObjectName("pushButton")
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.pushButton.setText(_translate("MainWindow", "PushButton"))
#file ui_dialog.py
from PyQt5 import QtCore, QtWidgets
class Ui_Dialog:
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(508, 300)
self.buttonBox = QtWidgets.QDialogButtonBox(Dialog)
self.buttonBox.setGeometry(QtCore.QRect(150, 250, 341, 32))
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel|QtWidgets.QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
self.buttonBox.accepted.connect(Dialog.accept)
self.buttonBox.rejected.connect(Dialog.reject)
QtCore.QMetaObject.connectSlotsByName(Dialog)
In another file, define the MainWindow and PreferenceDialog classes:
# file main.py
from PyQt5.QtWidgets import QMainWindow, QApplication, QDialog
from ui_dialog import Ui_Dialog
from ui_main import Ui_MainWindow
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.pushButton.clicked.connect(self.newusr_clk)
The newuser_clk slot will hide MainWindow and open up a new QDialog box via dialog.exec(). When the QDialog is closed, MainWindow is showed once again.
def newusr_clk(self):
self.hide()
dialog = PreferencesDialog(parent=self)
if dialog.exec():
pass # do stuff on success
self.show()
Here is the PreferenceDialog class:
class PreferencesDialog(QDialog):
def __init__(self, parent=None):
super(PreferencesDialog, self).__init__(parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
And here's how to run the script:
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
hope that helps!

So I finally figured out how to hide the current window while opening a new one. This was the code in my case (since I was working with a Form):
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
Form = QtWidgets.QWidget()
ui = Ui_Form()
ui.setupUi(Form)
Form.show()
sys.exit(app.exec_())
So I used this command to hide the current window:
Form.setVisible(False)

This is the easy way to hide the current window and open the new window
class placeOrder(object):
def __init__(self, Form):
Form.setObjectName("Form")
Form.setGeometry(0, 40, 1250, 650)
self.orderWindow = Form
def newWindow(self):
from newWindow import newWindow
self.windowNew = QtWidgets.QMainWindow()
self.newWindowObj=newWindow(self.windowNew)
self.orderWindow.hide()
self.windowNew.show()
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
orderWindow = QtWidgets.QMainWindow()
ui = placeOrder(orderWindow)
orderWindow.show()
sys.exit(app.exec_())

Qt Framework, PyQt5 and AttributeError: 'MyApp' object has no attribute 'myAttribute'

Last week I started to learn Python and I developed some command line apps. Now I would like to develop apps with GUI. I searched in internet and I found a project that fits my needs: Qt Project (http://qt-project.org) and PyQt (http://www.riverbankcomputing.com/software/pyqt/intro). I installed Qt 5.3.2 Open Source, SIP 4.16.4, PyQt5 5.3.2 on Mac OS X 10.10 and python 2.7.6. After some troubles on installing Qt and PyQt, finally I managed to make them work. If I open example projects from PyQt example folder the gui appears without any problems. So I created my GUI with Qt Creator and then I used pyuic5 to generate python code. This is what pyuic5 created (file name "myapp_auto.py"):
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file '/Users/andrea/Developer/Qt/mainwindow.ui'
#
# Created: Mon Nov 17 14:20:14 2014
# by: PyQt5 UI code generator 5.3.2
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(400, 300)
self.centralWidget = QtWidgets.QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
self.ok = QtWidgets.QPushButton(self.centralWidget)
self.ok.setGeometry(QtCore.QRect(140, 120, 115, 32))
self.ok.setAccessibleName("")
self.ok.setObjectName("ok")
self.text = QtWidgets.QLabel(self.centralWidget)
self.text.setGeometry(QtCore.QRect(100, 70, 181, 16))
self.text.setAccessibleName("")
self.text.setAlignment(QtCore.Qt.AlignCenter)
self.text.setObjectName("text")
self.time = QtWidgets.QDateTimeEdit(self.centralWidget)
self.time.setGeometry(QtCore.QRect(100, 180, 194, 24))
self.time.setAccessibleName("")
self.time.setObjectName("time")
MainWindow.setCentralWidget(self.centralWidget)
self.menuBar = QtWidgets.QMenuBar(MainWindow)
self.menuBar.setGeometry(QtCore.QRect(0, 0, 400, 22))
self.menuBar.setObjectName("menuBar")
self.menuMyApp = QtWidgets.QMenu(self.menuBar)
self.menuMyApp.setObjectName("menuMyApp")
self.menuEdit = QtWidgets.QMenu(self.menuBar)
self.menuEdit.setObjectName("menuEdit")
MainWindow.setMenuBar(self.menuBar)
self.mainToolBar = QtWidgets.QToolBar(MainWindow)
self.mainToolBar.setObjectName("mainToolBar")
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)
self.statusBar = QtWidgets.QStatusBar(MainWindow)
self.statusBar.setObjectName("statusBar")
MainWindow.setStatusBar(self.statusBar)
self.menuBar.addAction(self.menuMyApp.menuAction())
self.menuBar.addAction(self.menuEdit.menuAction())
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.ok.setText(_translate("MainWindow", "Ok"))
self.text.setText(_translate("MainWindow", "I\'m a GUI"))
self.menuMyApp.setTitle(_translate("MainWindow", "MyApp"))
self.menuEdit.setTitle(_translate("MainWindow", "Edit"))
After that I added a new python file where I put my code; this is what i wrote (file name "myapp.py"):
#!/usr/bin/env python
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from myapp_auto import Ui_MainWindow
import sys
import time
class MyApp(Ui_MainWindow):
parse_triggered = pyqtSignal()
def __init__(self, parent=None, name=None):
Ui_MainWindow.__init__(self)
if __name__ == "__main__":
app = QApplication(sys.argv)
MainWindow = QMainWindow()
ui = MyApp()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
Then, I run myapp.py and I verified that all GUI elements appeared to be where they should be. Well...now arrive my issue: I tried to access with code the "time" element in MainWindow modifying init def thus:
def __init__(self, parent=None, name=None):
Ui_MainWindow.__init__(self)
# Set the date to now
now = QDateTime()
now.setTime_t(int(time.time()))
self.time.setDateTime(now)
But the compiler shows alway this error:
AttributeError: 'MyApp' object has no attribute 'time'
This happen even if I try to access any other element ("ok", "text").
Will surely be a stupid mistake but I just can not figure out where I went wrong.
Thank you all guys!
Have a good day,
Andrea

You're not far off.
The MyApp class needs to inherit QMainWindow, and you don't need to use the time module. Try something like this:
class MyApp(QMainWindow, Ui_MainWindow):
parse_triggered = pyqtSignal()
def __init__(self, parent=None, name=None):
super(MyApp, self).__init__(parent)
self.setupUi(self)
# Set the date to now
self.time.setDateTime(QDateTime.currentDateTime())
if __name__ == "__main__":
app = QApplication(sys.argv)
window = MyApp()
window.show()
sys.exit(app.exec_())