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_count_europe_and_asia(self):
        """Check that the query counts countries from Europe and Asia only."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        result = self.cursor.fetchone()
        # Count how many countries are in Europe or Asia in the provided data
        self.cursor.execute("SELECT COUNT(*) FROM country WHERE continent='Europe' OR continent='Asia';")
        expected = self.cursor.fetchone()[0]
        actual = result[0] if result else None
        _dynamic_test(
            self,
            actual == expected,
            f"Correctly counted the number of countries in Europe and Asia: {expected}.",
            f"Incorrect count for countries in Europe and Asia. Expected {expected}, got {actual}."
        )

    def test_no_other_continents_included(self):
        """Check that only Europe and Asia countries are counted (not others)."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get the ids of countries counted by user query
        self.cursor.execute(f"SELECT id FROM country WHERE continent='Europe' OR continent='Asia';")
        valid_ids = set(row[0] for row in self.cursor.fetchall())
        # Confirm that the user query does not count more than these
        # We'll check the total count from the user query
        self.cursor.execute(query)
        user_count = self.cursor.fetchone()[0]
        # Now, check if the count for all countries is higher
        self.cursor.execute("SELECT COUNT(*) FROM country;")
        total_count = self.cursor.fetchone()[0]
        condition = user_count <= len(valid_ids) and user_count != total_count
        _dynamic_test(
            self,
            condition,
            "Query only includes countries from Europe and Asia.",
            "Query may be including countries from other continents."
        )

    def test_query_returns_single_value(self):
        """Check that the query returns exactly one row and one column."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        condition = len(rows) == 1 and len(rows[0]) == 1
        _dynamic_test(
            self,
            condition,
            "Query returns exactly one row and one column.",
            f"Query should return a single value, got {len(rows)} rows and {len(rows[0]) if rows else 0} columns."
        )

    def test_count_is_correct_value(self):
        """Check that the returned count is correct for the current data."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get expected count directly from the database
        self.cursor.execute("SELECT COUNT(*) FROM country WHERE continent='Europe' OR continent='Asia';")
        expected = self.cursor.fetchone()[0]
        self.cursor.execute(query)
        result = self.cursor.fetchone()
        actual = result[0] if result else None
        _dynamic_test(
            self,
            actual == expected,
            f"Returned count is correct: {expected}.",
            f"Returned count is incorrect. Expected {expected}, got {actual}."
        )

    def test_count_changes_if_data_changes(self):
        """Check that the count changes if a new Europe country is inserted."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get current count
        self.cursor.execute("SELECT COUNT(*) FROM country WHERE continent='Europe' OR continent='Asia';")
        before_insert = self.cursor.fetchone()[0]
        # Insert a new Europe country
        self.cursor.execute("INSERT INTO country (id, name, continent, Region, SurfaceArea, Capital, Population) VALUES (100, 'Testland', 'Europe', 'Test Region', 123, 'Testville', 1000);")
        self.connection.commit()
        try:
            self.cursor.execute(query)
            result = self.cursor.fetchone()
            after_insert = result[0] if result else None
        finally:
            self.cursor.execute("DELETE FROM country WHERE id=100;")
            self.connection.commit()
        _dynamic_test(
            self,
            after_insert == before_insert + 1,
            "Query dynamically counts new Europe country.",
            f"Query did not count new Europe country. Expected {before_insert + 1}, got {after_insert}."
        )

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

Ce cours est idéal pour les débutants souhaitant découvrir le monde de SQL. Que vous débutiez dans la gestion de bases de données ou que vous cherchiez à utiliser SQL pour vos projets de développement d'applications, ce cours couvre les notions essentielles. Vous apprendrez rapidement à exploiter tout le potentiel de SQL, de l'interrogation et la gestion des données à son intégration fluide dans des applications concrètes. À la fin du cours, vous disposerez de la confiance et des compétences nécessaires pour résoudre des problèmes pratiques avec SQL et améliorer votre processus de développement.

Dans cette section, nous apprendrons à utiliser l'instruction SQL SELECT pour obtenir une colonne d'une table, plusieurs colonnes d'une table et toutes les colonnes d'une table. Nous découvrirons également comment retourner des valeurs uniques.

Dans cette section, nous examinerons comment organiser et hiérarchiser les données renvoyées par une requête à l'aide de la clause ORDER BY. Placée à la fin d'une instruction SELECT, cette clause permet de trier les résultats selon une ou plusieurs colonnes, en ordre croissant ou décroissant, offrant ainsi une sortie de données plus significative et facilement interprétable.

Dans cette section, nous apprendrons à filtrer les données retournées à l'aide de la clause WHERE de l'instruction SELECT. Nous verrons comment tester l'égalité, l'inégalité, les plages de valeurs supérieures et inférieures, ainsi que les valeurs NULL.

Dans cette section, nous explorerons comment affiner vos conditions de recherche en combinant les clauses WHERE avec les opérateurs AND et OR. Nous aborderons également l'utilisation de l'opérateur NOT pour exclure certains résultats.

Dans cette section, nous allons découvrir ce que sont les fonctions d'agrégation SQL et comment les utiliser pour résumer les données d'une table.

Défi : Décompte Continental

Solution

Défi : Décompte Continental

Solution