Status: ✅ passed · 🚧 partial or not re-run · ❌ not started

Each level checks one artifact of the design, from the requirements down to single modules.

The suite follows the test pyramid: the 1,323 unit and in-process tests run in about 20 seconds, the HTTP suites in under 30 seconds, and the two end-to-end flows in 5–7 minutes.

flowchart LR
  dev["Developer"] -->|"push to main or pull request"| ci["GitHub Actions"]
  ci --> be["Backend pytest<br/>795 tests"]
  ci --> http["HTTP suites<br/>8 scripts, live local server"]
  ci --> app["App unit tests, lint, debug build<br/>528 tests"]
  dev -->|"on demand"| qa["qa/demo/run.py<br/>UI Automator on an emulator"]
  qa --> local["Throwaway local server"]
  qa --> shared["Shared server, new QA account"]

• Fault injection: tests simulate a failed Kakao route lookup (test_route_failure; the live route reports degraded), a failed address search while place search still works (test_address_failure_preserves_working_place_search), a token refresh that hits a 5xx or a network error (RefreshOutcomeTest), server timeouts and 503s (ColdStartRetryInterceptorTest), and an older server that omits new fields (null-safety tests)
• Malformed input: malformed_json_is_400, deeply_nested_json_does_not_crash, out-of-range coordinates and τ, inverted block ranges, oversized batches
• Not used yet: fuzzing at scale, mutation testing

• Backend: config/settings/test.py pins an in-memory SQLite database and blanks every external API key, so client code takes its "no key" path. The Kakao and Seoul clients are replaced with stubs through monkeypatch or mock.patch. Real external calls are checked by hand with check_external_apis.py
• App: no mocking library. Rules that would need a device are pulled into pure functions and objects (SyncDecision, RouteRefreshDecision, TripGeofence, MorningSession) and tested on the JVM. ColdStartRetryInterceptorTest puts a fake interceptor at the end of the chain and counts calls. Audit tests read src/main to enforce rules that are hard to run without a device: owner-scoped stores, init order, the token guard
• Integration: each run uses a new SQLite file in the temp folder and a server on a free port
• End-to-end: a separate QA app (com.swpp.wakeup.qa), a throwaway local server or a new QA account on the shared server, and GPS fixes sent through adb along the Kakao route

Tests are named after one behavior and its expected outcome, e.g., test_resend_does_not_overwrite or `POST 는 503 이어도 재시도하지 않는다` (a POST is not retried on 503).

• CI runs on every push to main and every pull request, with no secrets. Checks that need a Kakao key are skipped, not failed
• 57 runs since 2026-09-22: 53 passed, 2 failed, 2 cancelled. The failures were the first run while CI was being set up (8c5af19), and 9a07472, where the contract check flagged a field the app reads but the server doesn't send yet (route badges); the check was refined in a21861d
• In Iteration 1 most changes went to main directly, with CI on every push; one went through a pull request (#1). The team plans to merge through pull requests with CI and review from Iteration 2 (AI Collaboration Report, section 7)
• Team members specified the behavior and chose the test scenarios; AI wrote parts of the test code and QA scripts to those specifications (AI Collaboration Report, section 1)

backend/apps/*/tests: 26 files, 795 tests. Pure modules (distributions, estimators) are tested directly; endpoints through the Django test client on the in-memory database.

backend/scripts/run_local_suite.py starts runserver, runs the scripts below in order and stops. They catch what in-process tests miss: URL routing, middleware, real serialization and throttles. The runner pins a throwaway SQLite file, because an emptied variable once sent 21 test accounts to the shared database, and it refuses a busy port, because a leftover server once made the suite test old code.

Run by hand, outside CI:

• check_db_defaults.py: read-only check on the shared Postgres that columns added later have a database default. A missing one once made writes fail with 500 while reads and health looked normal, because migrations reach the database before the new code is deployed
• check_external_apis.py: the external keys work
• check_deployed.py: the deployed server end to end

APP/app/src/test: 57 files, 66 classes, 528 tests (JUnit 4, kotlinx-coroutines-test).

Built by Junha Park. qa/demo/run.py builds the QA app, prepares the server and the emulator, and runs two UI Automator tests on the real UI.

• Each run saves result.json, server-evidence.json, a screenshot and UI dump per step, logs and optional screen video
• To keep a run to 5–7 minutes, the event's start time is adjusted through the API: before the alarm, so it rings about 30 s after setup, and after the arrival, so the weekly report counts the event. Prep blocks are declared as 1–2 minutes and marked done after 5 s each; the trip is simulated in 65 s
• Not covered: push notifications, recovery after reboot or offline periods, process restart, real GPS. The runner works on macOS and Linux only

• docs/demo-checklist.md: steps D01–D12 with pass criteria and a result template, for the presentation device
• Reboot re-registration (AT-6) was checked on the emulator: the alarm is restored from disk at the same time (dumpsys alarm)
• Physical device: a Galaxy S24 (Android 16) has 0.10.0 installed and launched. No functional checks yet

HTTP suites in detail:

The Iteration 1 flow (sign in → add an event → the server computes the alarm → it rings → departure and arrival reach the server) passes end to end on the emulator against a local server, and passed on the shared server at 0.9.0.

Each acceptance test from the Requirements page and the tests that check it. Test files are under backend/apps/<app>/tests/ or APP/app/src/test/.

Non-functional requirements with automated checks:

Every fixed bug gets a test so it can't come back.

Open defects, without a test yet:

1. The arrival result is not restored after the app process restarts
2. When the tracking service restarts, the moving state and the live route are lost
3. Map panning can jump twice as far during consecutive gestures while a response is slow
4. A small pinch (12%) snaps a whole zoom level

To be documented in Iteration 3, as the course schedules. The plan in the full specification:

cd backend && python -m pytest                     # 795 tests; in-memory SQLite, no network
cd backend && python scripts/run_local_suite.py    # 8 HTTP suites on a throwaway local server
cd APP && ./gradlew testDebugUnitTest lintDebug assembleDebug   # 528 tests, lint, build
backend/.venv/bin/python qa/demo/run.py --public-e2e --no-video  # end to end on an emulator (macOS/Linux)

Use .venv\Scripts\python.exe and .\gradlew.bat on Windows. Setup for the end-to-end run is in the iteration-1-demo README.