import unittest
import psycopg2
import pandas as pd
import re

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_distinct_capital_values(self):
        """Check that only distinct capital values are returned."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        user_capitals = set([row[0] for row in user_rows])
        # Get expected distinct capitals from the table
        self.cursor.execute("SELECT DISTINCT capital FROM country;")
        expected_rows = self.cursor.fetchall()
        expected_capitals = set([row[0] for row in expected_rows])
        condition = user_capitals == expected_capitals
        _dynamic_test(
            self,
            condition,
            "Returned capitals are all unique and match expected distinct values.",
            f"Returned capitals do not match expected distinct values.\\nExpected: {expected_capitals}\\nGot: {user_capitals}"
        )

    def test_no_duplicate_capitals(self):
        """Check that there are no duplicate capital values in the result."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        user_rows = self.cursor.fetchall()
        capitals = [row[0] for row in user_rows]
        condition = len(capitals) == len(set(capitals))
        _dynamic_test(
            self,
            condition,
            "There are no duplicate capital values in the result.",
            "Duplicate capital values found in the result."
        )

    def test_column_name(self):
        """Check that the column name in the result is 'capital'."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        colnames = [desc[0] for desc in self.cursor.description]
        condition = len(colnames) == 1 and normalize_text(colnames[0]) == "capital"
        _dynamic_test(
            self,
            condition,
            "Result column name is 'capital'.",
            f"Result column name is not 'capital'. Got: {colnames}"
        )

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: Hitta Länders Huvudstäder

Lösning