Validation, Authentication and Testing

Validation and sanitisation

Defensive design means writing a program that carries on behaving sensibly when people do the wrong thing, and they will. The first line of defence is input validation: checking that data is acceptable before the program uses it.

Each check is a small function that returns True or False:

def in_range(n, low, high):
    return low <= n <= high

def right_length(text, low, high):
    return low <= len(text) <= high

def is_whole_number(text):
    return text.isdigit()

def is_present(text):
    return text.strip() != ""

def in_list(value, allowed):
    return value in allowed

print(in_range(15, 0, 120), right_length("abc", 8, 20))      # True False
print(is_whole_number("42"), is_whole_number("4.2"))         # True False
print(is_present("   "), in_list("M", ["S", "M", "L"]))      # False True

A validation loop

Keep asking until the answer is acceptable. The type check has to come before the range check, because int("abc") would crash the program before the range was ever looked at.

feed = iter(["abc", "-5", "200", "15"])      # stands in for the keyboard

age = -1
while age < 0 or age > 120:
    text = next(feed)                        # in the exam: input("Age: ")
    if text.isdigit():
        age = int(text)
        if age < 0 or age > 120:
            print("Age must be between 0 and 120")
    else:
        print("Please type a whole number")
print("Accepted:", age)

Run it and follow the four attempts. "abc" fails the type check. "-5" fails it too, because a minus sign is not a digit. "200" is a whole number but fails the range check. "15" passes both.

Sanitisation

Sanitising input means cleaning it so it is safe and consistent before it is used. Remove stray spaces, fix the case, and strip out anything the program should never receive.

raw = "   aShA  kETHIRI "
clean = " ".join(raw.split()).title()
print(repr(clean))               # 'Asha Kethiri'

The most important reason to sanitise is that an attacker can type program code into a text box. A name field that is pasted into a database query can become an instruction, which is called SQL injection. The SQL topic shows the proper fix, which is never to build a query out of typed text at all.

Authentication

Authentication proves that a user is who they say they are. Validation asks "is this input acceptable?" and authentication asks "is this person allowed in?"

A login with limited attempts, using a dictionary of users:

users = {"asha": "Tr1angle!", "ben": "kEy2024#"}

def check_login(username, password):
    return username in users and users[username] == password

attempts = [("asha", "wrong"), ("asha", "also wrong"), ("asha", "Tr1angle!")]
tries = 0
logged_in = False
while tries < 3 and not logged_in:
    username, password = attempts[tries]
    tries = tries + 1
    if check_login(username, password):
        logged_in = True
    else:
        print("Incorrect, attempt", tries, "of 3")

if logged_in:
    print("Welcome")
else:
    print("Account locked")

The loop stops for two different reasons, a correct login or three failures, and the if after it has to work out which. That is a typical shape for an exam question.

Password rules

A strong password rule is a validation check on the password. Check one property at a time.

def strong_password(password):
    has_digit = False
    has_upper = False
    for ch in password:
        if ch.isdigit():
            has_digit = True
        if ch.isupper():
            has_upper = True
    return len(password) >= 8 and has_digit and has_upper

print(strong_password("password"))      # False
print(strong_password("Tr1angle!"))     # True

Writing code that can be maintained

Programs are read many more times than they are written, often by a different person, and often by you months later. Maintainability is how easily the code can be understood and changed. The exam wants these named every time:

Both of these give the same answer:

def f(a,b):
    c=a*b*0.2
    return c
x=f(50,2)
print(x)

VAT_RATE = 0.2

def vat_on_order(unit_price, quantity):
    # VAT is charged on the whole order, not on each item
    order_total = unit_price * quantity
    return order_total * VAT_RATE

vat = vat_on_order(50, 2)
print(vat)

Only the second tells you what is going on.

Testing

Testing proves the program works and finds where it does not. Two kinds of testing, at two points:

• Iterative testing happens during development. Each subprogram is tested as soon as it is written, so a fault is found while only a few lines could be responsible.
• Final testing, also called terminal testing, happens at the end on the whole program, against the original requirements.

Three kinds of error

A logic error is the dangerous one, because nothing tells you. This function is meant to say whether somebody may vote at 18:

def is_adult(age):
    return age > 18

print(is_adult(17), is_adult(30))      # False True, which looks fine
print(is_adult(18))                    # False, but an 18 year old is an adult

Only a test at the boundary finds it.

Types of test data

Imagine a program that accepts a whole number from 1 to 10.

A test plan, run by the computer

A test plan has the test data, what you expect, what actually happened and a pass or fail. Python can run the plan for you, which is how professionals do it.

def valid_age(text):
    if not text.isdigit():
        return False
    return 0 <= int(text) <= 120

tests = [
    ("normal", "15", True),
    ("normal", "60", True),
    ("boundary", "0", True),
    ("boundary", "120", True),
    ("boundary", "121", False),
    ("invalid", "150", False),
    ("erroneous", "abc", False),
    ("erroneous", "12.5", False),
    ("erroneous", "", False),
]

failed = 0
for kind, data, expected in tests:
    actual = valid_age(data)
    if actual == expected:
        result = "pass"
    else:
        result = "FAIL"
        failed = failed + 1
    print(kind.ljust(10), repr(data).ljust(7), expected, actual, result)
print(failed, "tests failed")

Key terms you must be able to define

Validation

Checking that data entered is reasonable and allowed, such as within a range, before the program uses it.

Verification

Checking that data has been entered as the user intended, such as typing a password twice.

Sanitisation

Cleaning input so that it is safe and consistent, by removing unwanted characters and fixing its form.

Authentication

Proving that a user is who they claim to be, for example with a password or a fingerprint.

Maintainability

How easily a program can be understood, corrected and improved by somebody else.

Iterative testing

Testing each part of a program during development, as soon as it is written.

Boundary data

Test data on the edge of what is allowed, and the value just beyond it.

Erroneous data

Test data of the wrong type, which the program should reject.

Logic error

A fault that lets a program run but makes it give the wrong result.

Flashcards

Say the definition out loud before you flip the card. Retrieving it from memory is what builds recall, reading it again is not.

Reach the top grade on this topic

Top marks on robust program questions are for exact terms and for test data that would really find a fault.

• Name the check: range, length, type, presence, format or lookup, and write the condition for it
• Do the type check first, so the range check never receives data it cannot compare
• Give boundary data as a pair at each edge: the last valid value and the first invalid one
• State the expected result before the actual result in every test table
• Say why, not just what: meaningful names help because another programmer must understand the code

Mistakes that cost marks here

def good_password(password):
    has_digit = False
    for ch in password:
        if ch.isdigit():
            has_digit = True
    return len(password) >= 8 and has_digit

print(good_password("Tr1angle!"), good_password("password"), good_password("a1"))

def f(a,b):
    c=a*b*0.2
    return c
x=f(50,2)
print(x)