Removed placeholder exercise and added first real one

Author: razorblade23

conftest.py

@@ -94,3 +94,84 @@ def _expect(stdout, line_number, expected):
             )
 
     return _expect
+
+
+@pytest.fixture
+def expect_variables():
+    """Assert that several variables in a script's namespace all match
+    expected values at once, with a single friendly summary of everything
+    that's missing or wrong — instead of stopping at the first problem
+    like expect_variable does.
+
+    Usage:
+        def test_conversions_are_correct(run_script, expect_variables):
+            _, namespace = run_script("fahrenheit.py")
+            expect_variables(namespace, {"fahrenheit": 68.0, "kelvin": 293.15})
+    """
+
+    def _expect(namespace, expected):
+        missing = [name for name in expected if name not in namespace]
+        wrong = {
+            name: (namespace[name], expected_value)
+            for name, expected_value in expected.items()
+            if name in namespace and namespace[name] != expected_value
+        }
+
+        if not missing and not wrong:
+            return
+
+        lines = []
+        if missing:
+            names = ", ".join(f"'{name}'" for name in missing)
+            lines.append(f"Missing variable(s): {names}. Have you created them yet?")
+        for name, (actual, expected_value) in wrong.items():
+            lines.append(
+                f"'{name}' should be {expected_value!r}, but it was {actual!r}."
+            )
+
+        pytest.fail("\n".join(lines), pytrace=False)
+
+    return _expect
+
+
+@pytest.fixture
+def expect_variable_type():
+    """Assert that a variable exists and is of a given type, without caring
+    about its exact value — e.g. "is this a string" rather than "is this
+    exactly 'hello'".
+
+    Usage:
+        def test_name_is_a_string(run_script, expect_variable_type):
+            _, namespace = run_script("about_you.py")
+            expect_variable_type(namespace, "name", str)
+    """
+
+    friendly_names = {
+        str: "text (str)",
+        int: "a whole number (int)",
+        float: "a decimal number (float)",
+        bool: "True or False (bool)",
+        list: "a list",
+        dict: "a dictionary",
+        tuple: "a tuple",
+    }
+
+    def _friendly(t):
+        return friendly_names.get(t, t.__name__)
+
+    def _expect(namespace, name, expected_type):
+        if name not in namespace:
+            pytest.fail(
+                f"Expected a variable named '{name}', but it doesn't exist.\n"
+                f"Have you created a variable called '{name}' yet?",
+                pytrace=False,
+            )
+        actual = namespace[name]
+        if not isinstance(actual, expected_type):
+            pytest.fail(
+                f"Expected '{name}' to be {_friendly(expected_type)}, "
+                f"but it was {_friendly(type(actual))} ({actual!r}).",
+                pytrace=False,
+            )
+
+    return _expect

foundations/02_add_numbers/README.md

@@ -0,0 +1,18 @@
+# Exercise 02 - Datatypes
+
+## Description
+Welcome to your first real excercise. In the last one, we checked if everything is working correctly, now its time to put your knowlege to test. This and feature excercises contain multiple tests which are skipped by default (only first one is enabled). Your job is to finish one thing at a time and run the test. To run the next test, go to `test_<lesson_name>.py` and remove the `@pytest.mark.skip` line from the next test. Your goal is to make all tests pass.
+
+In this excercise you will define datatypes we talked about in lesson: **String**, **Integer**, **Float**, **Boolean**, **None**.
+
+You need to define the following variables:
+* `mystring` - set it to some string
+* `myinteger` - set it to some integer
+* `myfloat` - set it to some float
+* `myboolean` - set it to some boolean
+* `mynonevalue` - set it to some None
+
+You need to make sure the variables are named **exactly** like written here, otherwise the tests will fail, values can be anything you want.
+
+## Notes
+To finish this excercise, visit our first lesson in TPL - [Datatypes](https://thepythonledger.github.io/Docusaurus-engine/lessons/python-foundations/core-datatypes)

foundations/02_add_numbers/add_numbers.py

@@ -0,0 +1,14 @@
+# 1. Define variable with a name "mystring" and assign it to some string
+
+
+# 2. Define variable with a name "myinteger" and assign it to some integer
+
+
+# 3. Define variable with a name "myfloat" and assign it to some float
+
+
+# 4. Define variable with a name "myboolean" and assign it to some bool
+
+
+# 5. Define a variable with a name "mynonevalue" and assign it to None
+

foundations/02_add_numbers/solution/add_numbers_solution.py

@@ -0,0 +1,14 @@
+# 1. Define variable with a name "mystring" and assign it to some string
+mystring = "some_string"
+
+# 2. Define variable with a name "myinteger" and assign it to some integer
+myinteger = 5
+
+# 3. Define variable with a name "myfloat" and assign it to some float
+myfloat = 14.5
+
+# 4. Define variable with a name "myboolean" and assign it to some bool
+myboolean = True
+
+# 5. Define a variable with a name "mynonevalue" and assign it to None
+mynonevalue = None

foundations/02_add_numbers/solution/test_add_numbers_solution.py

@@ -0,0 +1,23 @@
+def test_string_definition(run_script, expect_variable_type):
+    _, namespace = run_script("datatypes_solution.py")
+    expect_variable_type(namespace, "mystring", str)
+
+
+def test_integer_definition(run_script, expect_variable_type):
+    _, namespace = run_script("datatypes_solution.py")
+    expect_variable_type(namespace, "myinteger", int)
+
+
+def test_float_definition(run_script, expect_variable_type):
+    _, namespace = run_script("datatypes_solution.py")
+    expect_variable_type(namespace, "myfloat", float)
+
+
+def test_boolean_definition(run_script, expect_variable_type):
+    _, namespace = run_script("datatypes_solution.py")
+    expect_variable_type(namespace, "myboolean", bool)
+
+
+def test_none_definition(run_script, expect_variable_type):
+    _, namespace = run_script("datatypes_solution.py")
+    expect_variable_type(namespace, "mynonevalue", type(None))