import unittest
import psycopg2
import pandas as pd
import re

class TestPostgresQuery(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_selected(self):
        """Check if the selected columns are name, region, capital, population in this 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 = ["name", "region", "capital", "population"]
        condition = columns == expected
        _dynamic_test(
            self,
            condition,
            "Selected columns are correct and in the right order.",
            f"Columns selected are incorrect or out of order: {columns}"
        )

    def test_filter_europe_population(self):
        """Check that only countries from Europe with population > 100000 are returned."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        df = pd.DataFrame(rows, columns=columns)
        if not df.empty:
            # Check all rows are from Europe and population > 100000
            condition = (
                (df['population'] > 100000).all() and
                ('continent' not in df.columns or True) # No continent column in result, so skip that check
            )
        else:
            condition = True  # If no rows returned, that's fine for this logic
        _dynamic_test(
            self,
            condition,
            "All rows are from Europe and have population > 100000.",
            "Some rows are not from Europe or have population <= 100000."
        )

    def test_order_by_region_capital(self):
        """Check that results are sorted by region ascending, then by capital ascending."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        df = pd.DataFrame(rows, columns=columns)
        if not df.empty:
            sorted_df = df.sort_values(by=["region", "capital"], ascending=[True, True]).reset_index(drop=True)
            df = df.reset_index(drop=True)
            condition = df.equals(sorted_df)
        else:
            condition = True
        _dynamic_test(
            self,
            condition,
            "Results are sorted by region and then by capital, both ascending.",
            "Results are not sorted by region and capital as required."
        )

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

Utforska grunderna i SQL, från att hämta och filtrera data med SELECT och WHERE till att sortera resultat med ORDER BY och sammanfatta dem med aggregeringsfunktioner som COUNT, AVG och SUM. Genom praktiska övningar bygger du färdigheter för att säkert kunna göra frågor mot verkliga datamängder.

Upptäck hur du hämtar enskilda, flera och alla kolumner från en tabell med hjälp av SQL SELECT-satsen. Lär dig att returnera unika rader och begränsa antalet resultat som returneras av en fråga.

Upptäck hur du organiserar frågeresultat med hjälp av ORDER BY-satsen. Lär dig att sortera data efter en eller flera kolumner och kontrollera sorteringsriktningen med stigande eller fallande ordning för tydligare resultat.



Upptäck hur du filtrerar frågeresultat med WHERE-satsen. Lär dig att testa för likhet och olikhet, kontrollera värden mot ett intervall och identifiera NULL-värden i dina data.

Upptäck hur du kan förfina dina sökvillkor genom att kombinera WHERE-villkor med operatorerna AND och OR. Lär dig använda operatorn NOT för att exkludera specifika resultat från din fråga.



Upptäck hur du kan sammanfatta tabelldata med hjälp av SQL:s aggregeringsfunktioner. Lär dig att beräkna medelvärden och summor med AVG och SUM, räkna rader med COUNT samt hitta extremvärden med MAX och MIN.



Utmaning: Sortering av Europa-regionen

Lösning