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

Tutustu SQL:n perusteisiin – tiedon hakemisesta sen integrointiin käytännön sovelluksiin. Olitpa vasta aloittamassa tietokantojen hallintaa tai haluat hyödyntää SQL:ää sovelluskehityksessä, tämä kurssi kattaa olennaiset asiat. Opit nopeasti hyödyntämään SQL:n koko potentiaalia tiedon hakemisesta ja hallinnasta sen sujuvaan integrointiin todellisiin sovelluksiin. Kurssin lopussa hallitset käytännön ongelmien ratkaisun SQL:llä ja kehitysprosessisi tehostuu.

Tässä osiossa opitaan käyttämään SQL SELECT -lausetta yksittäisen taulun sarakkeen, useiden taulun sarakkeiden ja kaikkien taulun sarakkeiden hakemiseen. Lisäksi selvitetään, miten palautetaan yksilölliset arvot.

Tässä osiossa tarkastellaan, kuinka kyselyn palauttamaa dataa voidaan järjestää ja priorisoida ORDER BY -lauseen avulla. Tämä lause sijoitetaan SELECT-lauseen loppuun ja sen avulla tulokset voidaan lajitella yhden tai useamman sarakkeen perusteella joko nousevaan tai laskevaan järjestykseen, mikä mahdollistaa merkityksellisemmän ja helpommin tulkittavan datan esittämisen.

Tässä osiossa opitaan suodattamaan palautettuja tietoja SELECT-lauseen WHERE-ehdon avulla. Käsitellään yhtäsuuruuden, erisuuruuden, suurempien ja pienempien arvojen sekä NULL-arvojen testaamista.

Tässä osiossa perehdytään hakuehtojen tarkentamiseen yhdistämällä WHERE-lausekkeita AND- ja OR-operaattoreiden avulla. Lisäksi käsitellään, miten NOT-operaattoria voidaan käyttää tiettyjen tulosten poissulkemiseen.

Tässä osiossa opimme, mitä SQL:n aggregaattifunktiot ovat ja kuinka niitä käytetään taulukoiden tietojen yhteenvedossa.

Haaste: Mantereiden Määrä

Ratkaisu