Framework, Libraries & Tools — Answered Per Project (the way interviewers ask)¶
Interviewers ask this per project / per scenario, e.g. "For your REST Assured API automation, which framework, libraries and tools did you use?" or "For the Playwright UI+API project?" or "For the Python project?"
This file gives each project a clean Framework / Libraries / Tools breakdown (versions verified against 12_Frameworks_And_Libraries_By_Language.md) so you can answer whichever way they frame it.
First — the 3 words, defined (say this if they ask the difference)¶
- Framework = the test framework you build on + the design pattern — e.g. TestNG + Page Object Model, Playwright Test, pytest. It gives structure: how tests are written, ordered, grouped, run.
- Library = code you import to do a job — e.g. REST Assured (HTTP), Jackson (JSON), Hamcrest/AssertJ (assertions), Apache POI (Excel). You call its methods.
- Tool = an application you run — e.g. Maven (build), Git (version control), Jenkins/GitHub Actions (CI), Docker (containers), Postman (API client), Eclipse/VS Code (IDE).
Remember: framework = the skeleton, libraries = the muscles you import, tools = the machines you run.
Two classification traps to answer cleanly (interviewers test this): - "Is REST Assured a framework or a library?" → "A library that gives a fluent DSL for HTTP; the test framework around it is TestNG." (Same for Selenium: Selenium WebDriver is a browser-automation library/API; TestNG is the framework.) In the tables below I group by the role each plays in that project, but that's the precise answer. - "Is the language a tool?" → No — the language (Java/TypeScript/Python) and its runtime (JDK/Node/CPython) sit under the stack; Maven/npm/pip are the build tools. I list the language first in each section for completeness.
1. API Automation using REST Assured (Java) — RestAssured_API project¶
"For API automation with REST Assured, what did you use?"
Framework
| Piece | What | Why |
|---|---|---|
| REST Assured 5.1.1 | API test framework | given/when/then syntax for HTTP calls + validation |
| TestNG 7.5 | Test runner | Annotations, groups, @DataProvider, suite XML |
| Design | Helper/Service layer + request wrappers | Auth, base URI, common calls live in one place (DRY) |
Libraries
| Library | Version | Job |
|---|---|---|
| Jackson (databind) | 2.13 | JSON serialize/deserialize (POJOs) |
| Gson / org.json | — | Alternative JSON parsing |
| json-path | — | Extract values from responses ($.data.id) |
| json-schema-validator | 4.3.1 | matchesJsonSchema() — 21+ schemas, contract-drift protection ← standout |
| Hamcrest | — | Matcher assertions (equalTo, hasItem) |
| OpenCSV | — | CSV test data |
| Apache POI | — | Excel test data |
Tools | Tool | Job | |---|---| | Java 1.7 | Language | | Maven | Build, dependencies, run via Surefire | | Git / GitHub | Version control | | Postman | Manual API exploration alongside the coded tests (claim if used) | | Eclipse | IDE |
🎤 Say-this: "It's REST Assured with TestNG and Maven in Java. Libraries: Jackson for JSON, Hamcrest for assertions, json-schema-validator for contract checks — the standout — and OpenCSV/Apache POI for data. Tools are Maven, Git, Postman and Eclipse. Auth covers token and OTP flows through a service layer."
2. Playwright UI + API Automation (TypeScript) — Morrie project¶
"For your Playwright UI and API automation, what did you use?"
Framework
| Piece | What | Why |
|---|---|---|
| Playwright Test (@playwright/test) ^1.35 | UI + API test framework | Auto-wait, parallel-by-default, fixtures, Trace Viewer |
| Design | Page Object Model + 8 custom fixtures | Tests read like English; reusable setup (logged-in page / API client) |
Libraries
| Library | Version | Job |
|---|---|---|
| Axios | 1.4 | API client — BaseApi with 700ms throttle + 429 Retry-After ← standout |
| @playwright/test built-ins | — | expect assertions, storageState, tracing |
Tools
| Tool | Job |
|---|---|
| TypeScript 5.2 | Language |
| Node.js / npm | Runtime; npm ci for reproducible installs |
| Playwright HTML report + Trace Viewer | Reporting / debugging |
| JUnit XML + JSON reporters | CI-readable reports |
| Git / GitHub + GitHub Actions | Version control + CI |
| VS Code | IDE |
🎤 Say-this: "The framework is Playwright Test with TypeScript, Page Object Model plus custom fixtures. The main library is Axios for the API layer — I gave it a 700ms throttle and Retry-After handling because the platform rate-limits. storageState logs in once. Tools: npm, GitHub Actions, Playwright's HTML/Trace Viewer for reporting, and VS Code. One framework drives both UI and API."
3. Python Project (LLM Evaluation) — bkg / FMCG / HoAD¶
"For the Python project, what framework, libraries and tools?"
Framework | Piece | What | Why | |---|---|---| | pytest ≥7.4.3 | Test framework | Markers, fixtures, parametrize, release gates | | pytest-asyncio | Async plugin | Test the streaming SSE/WebSocket chatbot | | Design | LLM-as-judge + ground-truth oracle | Judge grades against real business logic, not vibes |
Libraries
| Library | Version | Job |
|---|---|---|
| Pydantic (+settings) | 2.5 | Typed config + validate LLM JSON output |
| OpenAI SDK | — | gpt-4o-mini LLM-as-judge (temp 0, JSON schema) |
| Anthropic SDK | — | claude-haiku-4-5, forced tool-use output |
| sentence-transformers | all-MiniLM-L6-v2 | Local embeddings / semantic similarity |
| psycopg2 | — | Read-only PostgreSQL (the oracle) |
| sqlglot | — | Parse/validate SQL claims |
| requests / httpx | — | REST / async HTTP to the chatbot |
| websocket-client | — | Test the chat WebSocket channel |
| Jinja2 | — | HTML eval reports |
Tools | Tool | Job | |---|---| | Python 3.10/3.11 | Language | | pip / venv | Packages / environment | | Langfuse | LLM tracing / observability | | SQLite | Judge cache (7-day TTL), regression DB | | GitHub Actions | CI gate (lint → mypy → pytest fast subset) | | black / flake8 / mypy / isort / pre-commit / detect-secrets | Code quality + secret-blocking | | VS Code | IDE |
🎤 Say-this: "Framework is pytest with pytest-asyncio for the streaming channel. Libraries: Pydantic for config/validation, the OpenAI and Anthropic SDKs as judges at temperature 0, sentence-transformers for embeddings, psycopg2 + sqlglot for the ground-truth oracle. Tools: Langfuse for tracing, SQLite for caching, GitHub Actions for the CI gate, and black/flake8/mypy + pre-commit. The metrics are custom-built — RAGAS is the open-source equivalent I know."
4. Java UI + API Automation (Selenium + REST Assured) — B2BProjectTest¶
"For your Java UI and API automation, what did you use?"
Framework | Piece | What | Why | |---|---|---| | TestNG 7.0.0 | Test runner | Suite XML, groups (smoke/regression), listeners, data providers | | Selenium WebDriver 4.0.0-alpha-5 | UI automation | Drives the browser | | REST Assured 4.4.0 | API automation | Backend/API calls in the same suite | | Design | Page Object Model — Page / Helper / Test 3-tier | Tests read like a user journey; UI changes ripple to one class |
Libraries | Library | Version | Job | |---|---|---| | WebDriverManager | 4.2.2 | Auto-downloads driver binaries | | ngwebdriver | — | Angular synchronization (the app is Angular) | | AssertJ | — | Fluent assertions + SoftAssertions | | Hamcrest | — | Matcher assertions (with REST Assured) | | Jackson / Gson | 2.13 / — | JSON handling | | ExtentReports | 2.41.1 | HTML reports + screenshot-on-failure |
Tools | Tool | Job | |---|---| | Java 1.8 | Language | | Maven | Build, dependencies, Surefire | | Git / GitHub | Version control | | Chrome / Firefox + DevTools | Test browsers | | Eclipse | IDE | | Jira | Defect / test-case tracking (claim if used) |
⚠️ CI honesty: this repo has no CI pipeline — don't claim Jenkins/Actions for it. Say: "It's not wired into CI yet — that's my top improvement; I'd add a Jenkins or GitHub Actions job." (You do have Jenkins jobs locally for other work, so Jenkins as a general skill is fair.)
Cross-cutting (mention these — they impress): ThreadLocal\<WebDriver> for parallel isolation, custom RetryAnalyzer + IAnnotationTransformer for flakiness (1 retry), parallel="classes" in the suite XML.
🎤 Say-this: "Framework is Selenium 4 + TestNG with a three-tier Page/Helper/Test POM, and REST Assured for the API side. Libraries: WebDriverManager for drivers, ngwebdriver for Angular sync, AssertJ/Hamcrest for assertions, Jackson for JSON, ExtentReports for reporting. Tools: Maven, Git, and Eclipse — it's not in CI yet, which is my top improvement. For scale I use a ThreadLocal driver with parallel=classes, and auto-retry for flakiness."
Quick-grab table (if they ask across all projects)¶
| Project / scenario | Framework | Key libraries | Tools |
|---|---|---|---|
| REST Assured API (Java) | REST Assured + TestNG | Jackson, Hamcrest, json-schema-validator, POI/OpenCSV | Maven, Git, Postman, Eclipse |
| Playwright UI+API (TS) | Playwright Test + POM/fixtures | Axios (throttle+retry), Playwright built-ins | npm, GitHub Actions, HTML/Trace report, VS Code |
| Python LLM-eval | pytest + pytest-asyncio | Pydantic, OpenAI/Anthropic SDK, sentence-transformers, psycopg2, sqlglot | Langfuse, SQLite, GitHub Actions, pre-commit, VS Code |
| Java UI+API (Selenium) | Selenium 4 + TestNG + POM 3-tier | WebDriverManager, ngwebdriver, AssertJ, Jackson, ExtentReports | Maven, Git, Eclipse, Jira (CI: none yet) |
| VAPT / security | — (manual + DAST) | — | ZAP, Burp Suite, Nmap, Nikto |
Deep-dive follow-ups (the tables above are NOT enough alone — arm these)¶
The framework/library/tool list gets you through the first question. Then they drill. Have these ready:
REST Assured API (§1)
- "How does json-schema-validator actually catch drift?" → "Each response is validated with matchesJsonSchema() against a committed schema file. If the backend renames a field or changes a type, the response no longer matches and the test fails at that line. When the API changes legitimately, I regenerate/update the schema — so the schema is the reviewed contract."
- "How do you automate OTP?" → "You can't read a real SMS in a test, so the test environment exposes the OTP a testable way — a fixed test-mode OTP, or reading it from a test DB/endpoint. I never try to bypass real OTP in prod."
- "How does it run in CI?" → Honest: "This repo isn't in CI yet — that's my top improvement; I'd add a Jenkins/GitHub Actions job running the suite and publishing the report."
Playwright (§2)
- "Why Playwright over Selenium?" → "Built-in auto-waiting (less flakiness), parallel by default, the Trace Viewer for debugging, and one API drives both browser and API tests."
- "What are the 8 fixtures?" → "Reusable setup injected into tests — e.g. a logged-in page, an API client, test data — so I don't repeat beforeEach. A test just declares what it needs."
- "How do you handle flaky locators?" → "Playwright's role/text locators + auto-wait; I avoid brittle CSS/XPath where a semantic locator exists."
Python LLM-eval (§3)
- "How does the oracle work?" (the differentiator) → "Instead of an LLM grading an LLM, a BKG-Truth agent re-runs the actual business/KPI logic against a read-only PostgreSQL to get ground truth, validates any SQL with sqlglot, and the judge only grades the answer against that truth."
- "How do you trust the judge?" → "I pin it to temperature 0 with structured JSON output, cross-check across two providers, and calibrate it against human labels using Cohen's kappa (≥0.6 = substantial) before relying on it." (See the practice-repo's calibration.py.)
- "How do you test a streaming response?" → "pytest-asyncio — I consume the SSE/WebSocket stream chunk-by-chunk, assemble it, and assert on the final result with a timeout."
Java Selenium (§4)
- "Why TestNG over JUnit?" → "Suite-XML control, groups (smoke/regression), dependsOnMethods, data providers, and listeners — better for a large UI suite."
- "How does ThreadLocal give isolation?" → "Each thread stores its own WebDriver via ThreadLocal.set/get, so parallel threads never share a browser. I call remove() in teardown — otherwise a thread-pool thread would leak its old driver into the next test."
- "Why XPath so heavily?" → "The app is built on Webix, which generates dynamic IDs (webix_tm_id/view_id), so I anchor on those stable custom attributes with relative XPath + parent/child axes — CSS couldn't navigate that structure as cleanly."
- "How do you handle waits?" → "Explicit WebDriverWait + ExpectedConditions (never Thread.sleep, never mixing implicit+explicit), plus ngwebdriver to wait for Angular to settle."
"What would you improve?" — one honest answer per project (a SCORED question)¶
Interviewers almost always ask this; a good answer signals maturity. Yours (from the real repos):
| Project | What you'd improve (say this) |
|---|---|
| REST Assured API | "It's on Java 7, some assertions live inside helper methods (which breaks reuse for negative tests), and there's a hardcoded API key. I'd upgrade the JDK, have helpers return the Response and assert in the test, and move secrets to env/vault." |
| Playwright | "The Axios throttle is a single global lock; under high concurrency I'd move to a per-host token bucket so independent hosts aren't serialised." |
| Python LLM-eval | "The three domain repos duplicate ~80% of the code — I'd extract a shared core package. And I'd scrub the committed .env/DB password before any sharing." |
| Java Selenium | "It's on a Selenium 4 alpha and legacy ExtentReports 2.x — I'd upgrade both, replace System.out.println with a logging framework, add a BaseTest, move hardcoded credentials to a vault, and wire it into CI." |
Bonus "quality mindset" story (secrets): "I found committed credentials in older repos, so I moved to env vars / a vault and added a detect-secrets pre-commit hook — which I already use in the newer repo."
How to handle the framing (whichever way they ask)¶
- "For project X…" → jump to that section, give Framework → Libraries → Tools in that order.
- "For API automation…" → REST Assured (Java, §1) or Playwright API (§2) — ask "the Java REST Assured one or the Playwright one?" if unclear, then answer.
- "For UI automation…" → Selenium (§4) or Playwright (§2).
- "In Python…" → §3. "In Java…" → §1 or §4.
- Always answer in 3 buckets — Framework, Libraries, Tools — even if they only say "what did you use?". It sounds organized and complete.
Don't over-claim (from file 12): metrics are custom, not RAGAS; RRF only in FMCG; Morrie CI is GitHub Actions (you have Jenkins elsewhere); versions differ per repo (Java 7 vs 8, REST Assured 4.4 vs 5.1).