@@ -0,0 +1,69 @@
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Union
+import pytest
+from sqlmodel import SQLModel
+from sqlmodel.main import default_registry
+from pydantic import BaseModel
+
+top_level_path = Path(__file__).resolve().parent.parent
+docs_src_path = top_level_path / "docs_src"
+
+
+@pytest.fixture()
+def clear_sqlmodel():
+    # Clear the tables in the metadata for the default base model
+    SQLModel.metadata.clear()
+    # Clear the Models associated with the registry, to avoid warnings
+    default_registry.dispose()
+    yield
+    SQLModel.metadata.clear()
+    default_registry.dispose()
+
+
+@pytest.fixture()
+def cov_tmp_path(tmp_path: Path):
+    yield tmp_path
+    for coverage_path in tmp_path.glob(".coverage*"):
+        coverage_destiny_path = top_level_path / coverage_path.name
+        shutil.copy(coverage_path, coverage_destiny_path)
+
+
+def coverage_run(*, module: str, cwd: Union[str, Path]) -> subprocess.CompletedProcess:
+    result = subprocess.run(
+        [
+            "coverage",
+            "run",
+            "--parallel-mode",
+            "--source=docs_src,tests,sqlmodel",
+            "-m",
+            module,
+        ],
+        cwd=str(cwd),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        encoding="utf-8",
+    )
+    return result
+
+
+def get_testing_print_function(
+    calls: List[List[Union[str, Dict[str, Any]]]]
+) -> Callable[..., Any]:
+    def new_print(*args):
+        data = []
+        for arg in args:
+            if isinstance(arg, BaseModel):
+                data.append(arg.dict())
+            elif isinstance(arg, list):
+                new_list = []
+                for item in arg:
+                    if isinstance(item, BaseModel):
+                        new_list.append(item.dict())
+                data.append(new_list)
+            else:
+                data.append(arg)
+        calls.append(data)
+
+    return new_print
@@ -0,0 +1,44 @@
+from sqlmodel.default import Default
+
+
+def test_default_bool() -> None:
+    dt1 = Default(True)
+    dt2 = Default(1)
+    dt3 = Default("foo")
+    dt4 = Default(["foo"])
+    df1 = Default(False)
+    df2 = Default(0)
+    df3 = Default("")
+    df4: list = Default([])
+    df5 = Default(None)
+
+    assert not not dt1
+    assert not not dt2
+    assert not not dt3
+    assert not not dt4
+    assert not df1
+    assert not df2
+    assert not df3
+    assert not df4
+    assert not df5
+
+
+def test_equality() -> None:
+    value1 = Default("foo")
+    value2 = Default("foo")
+
+    assert value1 == value2
+
+
+def test_not_equality() -> None:
+    value1 = Default("foo")
+    value2 = Default("bar")
+
+    assert not (value1 == value2)
+
+
+def test_not_equality_other() -> None:
+    value1 = Default("foo")
+    value2 = "foo"
+
+    assert not (value1 == value2)
@@ -0,0 +1,27 @@
+from typing import Optional
+
+from sqlalchemy import create_engine, select
+from sqlalchemy.orm import Session
+from sqlmodel import Field, SQLModel
+
+
+def test_allow_instantiation_without_arguments(clear_sqlmodel):
+    class Item(SQLModel):
+        id: Optional[int] = Field(default=None, primary_key=True)
+        name: str
+        description: Optional[str] = None
+
+        class Config:
+            table = True
+
+    engine = create_engine("sqlite:///:memory:")
+    SQLModel.metadata.create_all(engine)
+    with Session(engine) as db:
+        item = Item()
+        item.name = "Rick"
+        db.add(item)
+        db.commit()
+        result = db.execute(select(Item)).scalars().all()
+    assert len(result) == 1
+    assert isinstance(item.id, int)
+    SQLModel.metadata.clear()
@@ -0,0 +1,26 @@
+from typing import Optional
+
+from sqlmodel import Field, Session, SQLModel, create_engine
+
+
+def test_query(clear_sqlmodel):
+    class Hero(SQLModel, table=True):
+        id: Optional[int] = Field(default=None, primary_key=True)
+        name: str
+        secret_name: str
+        age: Optional[int] = None
+
+    hero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")
+
+    engine = create_engine("sqlite://")
+
+    SQLModel.metadata.create_all(engine)
+    with Session(engine) as session:
+        session.add(hero_1)
+        session.commit()
+        session.refresh(hero_1)
+
+    with Session(engine) as session:
+        query_hero = session.query(Hero).first()
+        assert query_hero
+        assert query_hero.name == hero_1.name
@@ -0,0 +1,160 @@
+from tests.conftest import get_testing_print_function
+from typing import Any, Dict, List, Union
+from unittest.mock import patch
+
+from sqlmodel import create_engine
+
+
+def check_calls(calls: List[List[Union[str, Dict[str, Any]]]]):
+    assert calls[0] == ["Before interacting with the database"]
+    assert calls[1] == [
+        "Hero 1:",
+        {
+            "id": None,
+            "name": "Deadpond",
+            "secret_name": "Dive Wilson",
+            "age": None,
+        },
+    ]
+    assert calls[2] == [
+        "Hero 2:",
+        {
+            "id": None,
+            "name": "Spider-Boy",
+            "secret_name": "Pedro Parqueador",
+            "age": None,
+        },
+    ]
+    assert calls[3] == [
+        "Hero 3:",
+        {
+            "id": None,
+            "name": "Rusty-Man",
+            "secret_name": "Tommy Sharp",
+            "age": 48,
+        },
+    ]
+    assert calls[4] == ["After adding to the session"]
+    assert calls[5] == [
+        "Hero 1:",
+        {
+            "id": None,
+            "name": "Deadpond",
+            "secret_name": "Dive Wilson",
+            "age": None,
+        },
+    ]
+    assert calls[6] == [
+        "Hero 2:",
+        {
+            "id": None,
+            "name": "Spider-Boy",
+            "secret_name": "Pedro Parqueador",
+            "age": None,
+        },
+    ]
+    assert calls[7] == [
+        "Hero 3:",
+        {
+            "id": None,
+            "name": "Rusty-Man",
+            "secret_name": "Tommy Sharp",
+            "age": 48,
+        },
+    ]
+    assert calls[8] == ["After committing the session"]
+    assert calls[9] == ["Hero 1:", {}]
+    assert calls[10] == ["Hero 2:", {}]
+    assert calls[11] == ["Hero 3:", {}]
+    assert calls[12] == ["After committing the session, show IDs"]
+    assert calls[13] == ["Hero 1 ID:", 1]
+    assert calls[14] == ["Hero 2 ID:", 2]
+    assert calls[15] == ["Hero 3 ID:", 3]
+    assert calls[16] == ["After committing the session, show names"]
+    assert calls[17] == ["Hero 1 name:", "Deadpond"]
+    assert calls[18] == ["Hero 2 name:", "Spider-Boy"]
+    assert calls[19] == ["Hero 3 name:", "Rusty-Man"]
+    assert calls[20] == ["After refreshing the heroes"]
+    assert calls[21] == [
+        "Hero 1:",
+        {
+            "id": 1,
+            "name": "Deadpond",
+            "secret_name": "Dive Wilson",
+            "age": None,
+        },
+    ]
+    assert calls[22] == [
+        "Hero 2:",
+        {
+            "id": 2,
+            "name": "Spider-Boy",
+            "secret_name": "Pedro Parqueador",
+            "age": None,
+        },
+    ]
+    assert calls[23] == [
+        "Hero 3:",
+        {
+            "id": 3,
+            "name": "Rusty-Man",
+            "secret_name": "Tommy Sharp",
+            "age": 48,
+        },
+    ]
+    assert calls[24] == ["After the session closes"]
+    assert calls[21] == [
+        "Hero 1:",
+        {
+            "id": 1,
+            "name": "Deadpond",
+            "secret_name": "Dive Wilson",
+            "age": None,
+        },
+    ]
+    assert calls[22] == [
+        "Hero 2:",
+        {
+            "id": 2,
+            "name": "Spider-Boy",
+            "secret_name": "Pedro Parqueador",
+            "age": None,
+        },
+    ]
+    assert calls[23] == [
+        "Hero 3:",
+        {
+            "id": 3,
+            "name": "Rusty-Man",
+            "secret_name": "Tommy Sharp",
+            "age": 48,
+        },
+    ]
+
+
+def test_tutorial_001(clear_sqlmodel):
+    from docs_src.tutorial.automatic_id_none_refresh import tutorial001 as mod
+
+    mod.sqlite_url = "sqlite://"
+    mod.engine = create_engine(mod.sqlite_url)
+    calls = []
+
+    new_print = get_testing_print_function(calls)
+
+    with patch("builtins.print", new=new_print):
+        mod.main()
+    check_calls(calls)
+
+
+def test_tutorial_002(clear_sqlmodel):
+    from docs_src.tutorial.automatic_id_none_refresh import tutorial002 as mod
+
+    mod.sqlite_url = "sqlite://"
+    mod.engine = create_engine(mod.sqlite_url)
+    calls = []
+
+    new_print = get_testing_print_function(calls)
+
+    with patch("builtins.print", new=new_print):
+        mod.main()
+    check_calls(calls)
@@ -0,0 +1,41 @@
+from typing import Any, Dict, List, Union
+from unittest.mock import patch
+
+from sqlalchemy import inspect
+from sqlalchemy.engine.reflection import Inspector
+from sqlmodel import create_engine
+from sqlmodel.pool import StaticPool
+
+from ...conftest import get_testing_print_function
+
+expected_calls = [
+    [
+        "Created hero:",
+        {
+            "id": 1,
+            "name": "Deadpond",
+            "age": None,
+            "secret_name": "Dive Wilson",
+            "team_id": 1,
+        },
+    ],
+    [
+        "Hero's team:",
+        {"name": "Z-Force", "headquarters": "Sister Margaret’s Bar", "id": 1},
+    ],
+]
+
+
+def test_tutorial(clear_sqlmodel):
+    from docs_src.tutorial.code_structure.tutorial001 import app, database
+
+    database.sqlite_url = "sqlite://"
+    database.engine = create_engine(database.sqlite_url)
+    app.engine = database.engine
+    calls = []
+
+    new_print = get_testing_print_function(calls)
+
+    with patch("builtins.print", new=new_print):
+        app.main()
+    assert calls == expected_calls