import unittest
import psycopg2
import pandas as pd

class TestTask(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.connection = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cls.cursor = cls.connection.cursor()

    def test_columns_and_order(self):
        """Test that the query returns the correct columns in the correct order."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        expected_columns = ['name', 'population', 'region', 'capital']
        condition = columns == expected_columns
        _dynamic_test(
            self,
            condition,
            "Query returns columns in correct order: name, population, region, capital.",
            f"Query columns/order incorrect. Got: {columns}, expected: {expected_columns}."
        )

    def test_population_filter(self):
        """Test that only countries with population >= 300000 are returned."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        population_idx = [desc[0] for desc in self.cursor.description].index('population')
        invalid_rows = [row for row in rows if row[population_idx] is not None and row[population_idx] < 300000]
        condition = len(invalid_rows) == 0
        _dynamic_test(
            self,
            condition,
            "All returned rows have population >= 300000.",
            f"Some rows have population < 300000: {invalid_rows}."
        )

    def test_expected_rows_present(self):
        """Test that all expected countries with population >= 300000 are included in the result."""
        solution_query = """
            SELECT name, population, region, capital 
            FROM country
            WHERE population >= 300000;
        """
        self.cursor.execute(solution_query)
        expected_rows = self.cursor.fetchall()
        with open("query.sql", "r") as file:
            user_query = file.read()
        self.cursor.execute(user_query)
        user_rows = self.cursor.fetchall()
        missing = [row for row in expected_rows if row not in user_rows]
        condition = len(missing) == 0
        _dynamic_test(
            self,
            condition,
            "All expected rows are present in the result.",
            f"Missing expected rows: {missing}."
        )

    def test_no_extra_rows(self):
        """Test that no extra countries (with population < 300000 or NULL) are included in the result."""
        with open("query.sql", "r") as file:
            user_query = file.read()
        self.cursor.execute(user_query)
        user_rows = self.cursor.fetchall()
        solution_query = """
            SELECT name, population, region, capital 
            FROM country
            WHERE population >= 300000;
        """
        self.cursor.execute(solution_query)
        expected_rows = self.cursor.fetchall()
        extra = [row for row in user_rows if row not in expected_rows]
        condition = len(extra) == 0
        _dynamic_test(
            self,
            condition,
            "No extra rows are present in the result.",
            f"Extra rows found: {extra}."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

if __name__ == "__main__":
    unittest.main()


test_solution.py

Erkunden Sie die Grundlagen von SQL, von der Abfrage und Filterung von Daten mit SELECT und WHERE bis hin zur Sortierung von Ergebnissen mit ORDER BY und deren Zusammenfassung mit Aggregatfunktionen wie COUNT, AVG und SUM. Durch praxisorientierte Aufgaben erwerben Sie die Fähigkeiten, reale Datensätze sicher abzufragen.

Erfahren Sie, wie Sie einzelne, mehrere und alle Spalten aus einer Tabelle mit der SQL-SELECT-Anweisung abrufen. Lernen Sie, wie Sie eindeutige Zeilen zurückgeben und die Anzahl der von einer Abfrage zurückgegebenen Ergebnisse begrenzen.

Erfahren Sie, wie Sie Abfrageergebnisse mit der ORDER BY-Klausel organisieren. Lernen Sie, Daten nach einer oder mehreren Spalten zu sortieren und die Sortierreihenfolge mit aufsteigender oder absteigender Ordnung für eine klarere Ausgabe zu steuern.



Erfahren Sie, wie Sie Abfrageergebnisse mit der WHERE-Klausel filtern. Gleichheits- und Ungleichheitsprüfungen, Überprüfung von Werten innerhalb eines Bereichs sowie Identifizierung von NULL-Werten in Ihren Daten.

Erfahren Sie, wie Sie Ihre Suchbedingungen verfeinern, indem Sie WHERE-Klauseln mit den Operatoren AND und OR kombinieren. Lernen Sie, den Operator NOT zu verwenden, um bestimmte Ergebnisse aus Ihrer Abfrage auszuschließen.



Erfahren Sie, wie Tabellendaten mithilfe von SQL-Aggregatfunktionen zusammengefasst werden. Lernen Sie, Durchschnittswerte und Summen mit AVG und SUM zu berechnen, Zeilen mit COUNT zu zählen und Extremwerte mit MAX und MIN zu ermitteln.



Herausforderung: Abfrage der Bevölkerungsschwelle

Lösung