import os import sys import unittest from PyQt5.QtWidgets import QApplication from pygadmin.widgets.editor import EditorWidget from pygadmin.models.tablemodel import TableModel from pygadmin.database_query_executor import DatabaseQueryExecutor from pygadmin.connectionfactory import global_connection_factory class TestEditorWidgetMethods(unittest.TestCase): """ Test the functionality and methods of the editor widget. """ def test_initial_attributes(self): """ Check for the correct existence and instance of the initial attributes of the editor. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # Test for the correct instance of the table model. assert isinstance(editor_widget.table_model, TableModel) # The data list of the table model should be empty at the start. assert editor_widget.table_model.data_list == [] # The current database connection should be None at the start. assert editor_widget.current_database_connection is None # The connection identifier should be None at at the start. assert editor_widget.connection_identifier is None # Test for the correct instance of the database query executor. assert isinstance(editor_widget.database_query_executor, DatabaseQueryExecutor) def test_valid_set_connection_based_on_parameters(self): """ Test the method for setting connection parameters based on parameters in a dictionary with valid connection parameters. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # Define a connection parameter dictionary. connection_dictionary = {"host": "localhost", "database": "postgres", "port": 5432, "user": "testuser"} # Get a database connection related to the parameters in the connection dictionary. database_connection = global_connection_factory.get_database_connection(connection_dictionary["host"], connection_dictionary["user"], connection_dictionary["database"], connection_dictionary["port"]) # Set the database connection of the editor based on the connection dictionary. editor_widget.set_connection_based_on_parameters(connection_dictionary) # After a successful set of a database connection, the data list of the table model should still be empty and # without an error message. assert editor_widget.table_model.data_list == [] # The database connection of the editor should be the connection based on the connection dictionary. assert editor_widget.current_database_connection == database_connection def test_invalid_set_connection_based_on_parameters(self): """ Test the method for setting connection parameters based on parameters in a dictionary with invalid connection parameters. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # Define a connection parameter dictionary. The host parameter is an invalid parameter. connection_dictionary = {"host": "localhorst", "database": "postgres", "port": 5432, "user": "testuser"} # Try to set the connection with the function for setting a database connection. editor_widget.set_connection_based_on_parameters(connection_dictionary) # After a failed set of a database connection, there should be a warning in the table model. assert editor_widget.table_model.data_list != [] # The current database connection should be None after this kind of failure. assert editor_widget.current_database_connection is None def test_refresh_table_model(self): """ Test the method for refreshing the table model of the editor. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # Define a list with new data. new_data_list = [["column 1, column 2"], (1, "row A", "row B"), (2, "row C", "row D")] # Use the function for refreshing the data list of the table model. editor_widget.refresh_table_model(new_data_list) # The data list of the table model should be the new data list. assert editor_widget.table_model.data_list == new_data_list def test_save_current_statement_in_file(self): """ Test the function for saving the current statement in a file. User input is not necessary, because the file for saving is predefined. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # Define a test text. test_text = "This is a text for testing." # Set the text as text of the query input editor for saving. editor_widget.query_input_editor.setText(test_text) # Define a test path. test_path = os.path.join(os.path.expanduser("~"), '.pygadmin_test') # Create the test path. os.mkdir(test_path) # Define a test file. test_file = os.path.join(test_path, "test_file.txt") # Use the test file as file for saving in the editor. editor_widget.corresponding_saved_file = test_file # Save the current statement and text of the query input editor in the pre defined test file. editor_widget.save_current_statement_in_file() # Open the test file. with open(test_file, "r") as test_file: # Get the text of the file, which should be the currently saved text. saved_editor_text = test_file.read() # Remove the file and the path as a clean up. os.remove(test_file.name) os.rmdir(test_path) # Check the text: The inserted text in the editor should be the text, which is saved in the file. assert test_text == saved_editor_text def test_is_editor_empty(self): """ Test the method for an editor check: Is the editor empty or not? """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # After creating the widget, it should be empty. assert editor_widget.is_editor_empty() is True # Set a text to the editor, so it is not empty anymore. editor_widget.query_input_editor.setText("Test Text") # The method should now return False. assert editor_widget.is_editor_empty() is False # Set also an title to the editor widget. editor_widget.setWindowTitle("Test Title") # The method should still return False, because the editor is not empty. assert editor_widget.is_editor_empty() is False # Set the text of the editor back to an empty string. editor_widget.query_input_editor.setText("") # Set the text to a string with content. editor_widget.setWindowTitle("Test Title") # The editor widget should not be empty. assert editor_widget.is_editor_empty() is False def test_get_connection_status_string_for_window_title(self): """ Test the method for determining the connection part of the window title based on the different kinds of connections and their validity. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # After the creation of the editor widget, the connection status string should be an empty string. assert editor_widget.get_connection_status_string_for_window_title() == "" # Set the database connection of the editor to False for simulating a failed database connection. editor_widget.current_database_connection = False # Now there should be an alert to a failed connection. assert editor_widget.get_connection_status_string_for_window_title() == "Connection failed: None" # Simulate a valid database connection with setting it to True. editor_widget.current_database_connection = True # Define an identifier for the connection simulation. test_identifier = "Test identifier" # Set the test identifier as connection identifier of the editor. editor_widget.connection_identifier = test_identifier # The connection string for the window title should be the connection identifier for a valid database # connection. assert editor_widget.get_connection_status_string_for_window_title() == test_identifier def test_get_corresponding_file_name_string_for_window_title_and_description(self): """ Test the method for getting the name of the file save path for the editor to set the correct window title. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # After the creation and without a corresponding saved file, the method should return a tuple of empty strings. assert editor_widget.get_corresponding_file_name_string_for_window_title_and_description() == ("", "") # Define a path for the test save file. save_file_path = "test/testfile/" # Define a name for the test save file. save_file_name = "test.sql" # Create a full path with path and name together. full_save_file_path = "{}{}".format(save_file_path, save_file_name) # Set the full path as corresponding saved file for simulating the behavior of a QFileDialog. editor_widget.corresponding_saved_file = full_save_file_path # Now the output should be the name of the file and the full path. assert editor_widget.get_corresponding_file_name_string_for_window_title_and_description() == ( save_file_name, full_save_file_path) def test_get_file_save_status_string_for_window_title(self): """ Test the method for checking the current status of the text in the query input editor of the editor compared to its last saved version. """ # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # The text in the editor should empty, so there should not be a change. The file save string should be empty. assert editor_widget.get_file_save_status_string_for_window_title() == "" # Set a text to the editor, so the initial text has changed. editor_widget.query_input_editor.setText("Test text") # After the text change, there should be the information about it in the file save string. assert editor_widget.get_file_save_status_string_for_window_title() == " (*)" def test_get_query_in_input_editor(self): # Create an app, because this is necessary for testing a QWidget. app = QApplication(sys.argv) # Create an editor widget. editor_widget = EditorWidget() # Define a start text for testing, so this text can be chosen for a plain and simple selection later. test_text_start = "Test" # Define an end text for testing. test_text_end = " Text" # Put the two strings together as test text. test_text = "{}{}".format(test_text_start, test_text_end) # Set the test text as text of the query input editor. editor_widget.query_input_editor.setText(test_text) # The query in the query input editor should be the test text. assert editor_widget.get_query_in_input_editor() == test_text # Set the selection to the test text start. editor_widget.query_input_editor.setSelection(0, 0, 0, len(test_text_start)) # Now the function for getting the query should return the test text start. assert editor_widget.get_query_in_input_editor() == test_text_start