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 test_returns_three_rows(self):
        """Check that the query returns exactly 3 rows."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        _dynamic_test(
            self,
            len(rows) == 3,
            "Query returns exactly 3 rows.",
            f"Query should return 3 rows, but returned {len(rows)}."
        )

    def test_row_structure(self):
        """Check that each row contains customer_id, name, and order_count."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        expected_cols = set(["customer_id", "name", "order_count"])
        _dynamic_test(
            self,
            expected_cols.issubset(set([col.lower() for col in columns])),
            "Each row contains customer_id, name, and order_count.",
            f"Each row must contain columns: customer_id, name, order_count. Found columns: {columns}."
        )

    def test_top_customers(self):
        """Check that the top customers by order count are returned in correct order."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        # Solution: order counts per customer
        # Alice Johnson (1): 2 orders
        # Bob Smith (2): 2 orders
        # Carol Lee (3): 2 orders
        # David Kim (4): 2 orders
        # Eva Brown (5): 2 orders
        # All have 2 orders, so top 3 are IDs 1,2,3
        expected = [
            (1, 'Alice Johnson', 2),
            (2, 'Bob Smith', 2),
            (3, 'Carol Lee', 2)
        ]
        # Convert all rows to comparable format
        result = [(r[0], r[1], r[2]) for r in rows]
        _dynamic_test(
            self,
            result == expected,
            "Top 3 customers by order count and ID are correct.",
            f"Expected top 3 customers: {expected}, got: {result}."
        )

    def test_tie_breaker_on_customer_id(self):
        """Check that tie-breaker is by customer_id ascending when order counts are equal."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        customer_ids = [r[0] for r in rows]
        _dynamic_test(
            self,
            customer_ids == sorted(customer_ids),
            "Tie-breaker on customer_id ascending is applied.",
            f"Expected customer IDs in ascending order, got: {customer_ids}."
        )

    def test_query_uses_subquery(self):
        """Check that the query uses a subquery to count orders per customer."""
        with open("query.sql", "r") as file:
            query = file.read().lower()
        # Check for a subquery that groups by customer_id and counts
        has_subquery = (
            "select" in query and
            "from" in query and
            "group by" in query and
            "count" in query
        )
        _dynamic_test(
            self,
            has_subquery,
            "Query uses a subquery to count orders per customer.",
            "Query does not use a subquery to count orders per customer."
        )

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

Master the art of writing and applying subqueries in SQL through real-world scenarios. This course covers the theory and practice of subqueries, including their use in SELECT, WHERE, and FROM clauses, as well as correlated subqueries. Each section features a unique dataset and practical challenges to reinforce your learning.

Explore subqueries using an e-commerce dataset, focusing on orders, customers, and products. Learn to extract insights and solve business problems using subqueries.

Apply subqueries to HR data, including employees, departments, and salaries. Tackle real-world HR analytics tasks.

Use subqueries to solve problems in a library management system, including books, members, and borrowings.

Challenge: Top Customers by Order Count

Løsning