import unittest
import psycopg2
import pandas as pd

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 get_query_result(self):
        with open("query.sql", "r") as f:
            query = f.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        return pd.DataFrame(rows, columns=columns)

    def test_columns_present_and_order(self):
        """Check that the output columns are exactly name, capital, continent in the correct order."""
        df = self.get_query_result()
        expected_columns = ['name', 'capital', 'continent']
        condition = list(df.columns) == expected_columns
        _dynamic_test(
            self,
            condition,
            "The output columns are correct and in the right order.",
            f"Expected columns {expected_columns}, but got {list(df.columns)}."
        )

    def test_no_european_countries(self):
        """Ensure that no row in the result has continent='Europe'."""
        df = self.get_query_result()
        has_europe = (df['continent'] == 'Europe').any()
        _dynamic_test(
            self,
            not has_europe,
            "No European countries are present in the result.",
            "There are countries from Europe in your result, but they should be excluded."
        )

    def test_all_non_european_countries_included(self):
        """Check that all non-European countries are included in the result."""
        # Reference data (remove trailing whitespace in "Japan ")
        all_countries = [
            {"name": "Japan", "capital": "Tokyo", "continent": "Asia"},
            {"name": "Mexico", "capital": "Mexico City", "continent": "North America"},
            {"name": "United States", "capital": "Washington", "continent": "North America"},
            {"name": "Thailand", "capital": "Bangkok", "continent": "Asia"},
            {"name": "Paraguay", "capital": "Asunción", "continent": "South America"},
            {"name": "Philippines", "capital": "Manila", "continent": "Asia"},
            {"name": "New Zealand", "capital": "Wellington", "continent": "Oceania"}
        ]
        df = self.get_query_result().copy()
        # Strip whitespace from all string columns for comparison
        for col in ['name', 'capital', 'continent']:
            df[col] = df[col].astype(str).str.strip()
        missing = []
        for country in all_countries:
            mask = (
                (df['name'] == country['name']) &
                (df['capital'] == country['capital']) &
                (df['continent'] == country['continent'])
            )
            if not mask.any():
                missing.append(country)
        condition = len(missing) == 0
        if not condition:
            failure_msg = f"Missing non-European countries: {missing}"
        else:
            failure_msg = ""
        _dynamic_test(
            self,
            condition,
            "All non-European countries are included in the result.",
            failure_msg
        )

    def test_sorted_by_capital(self):
        """Ensure that the result is sorted by capital (ascending)."""
        df = self.get_query_result()
        capitals = df['capital'].tolist()
        condition = capitals == sorted(capitals)
        _dynamic_test(
            self,
            condition,
            "The result is sorted by capital in ascending order.",
            f"The capitals are not sorted: {capitals}"
        )

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):
    import re
    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

This course is perfect for beginners ready to explore the world of SQL. Whether you're just starting out in database management or aiming to use SQL for your application development projects, this course covers the essentials. You'll quickly learn how to leverage the full potential of SQL, from querying and managing data to seamlessly integrating it into real-world applications. By the end of the course, you'll have the confidence and skills to solve practical problems with SQL and enhance your development process.

In this section, we will learn how to use the SQL SELECT statement to get a single table column, multiple table columns, and all table columns. We will also find out how to return unique values.

In this section, we’ll explore how to organize and prioritize the data returned by a query using the ORDER BY clause. Placed at the end of a SELECT statement, this clause lets you sort your results by one or multiple columns, either in ascending or descending order, enabling more meaningful and easily interpretable data output.

In this section, we will learn how to filter returned data using the SELECT statement's WHERE clause. We will learn how to test for equality, inequality, more and less significant than value ranges, and NULL values.

In this section, we’ll explore how to refine your search conditions by combining WHERE clauses with the AND and OR operators. We’ll also cover how the NOT operator can be used to exclude certain results.

In this section, we will learn what the SQL aggregate functions are and how to use them to summarize table data.

Challenge: Non-Europe Capitals Sort

Solution