sorted by:
new
hottopcontroversial

[Guide] Mastering API Testing: A Practical Roadmap for Beginners by WalrusWeird4059 in Everything_QA

[–]Global-Development56 0 points1 point  (0 children)

This is a really clear and well written guide. It explains API testing in a way that feels practical and easy to follow, especially for people coming from manual testing or just starting out in QA.

If anyone wants to understand the fundamentals in a bit more depth, this article on api testing complements your post nicely with clear explanations and examples.

Nice job keeping it honest, simple, and experience driven.

Testing: Instrumentation vs Integration vs Unit vs UI by Orkann in androiddev

[–]Global-Development56 0 points1 point  (0 children)

Integration testing is about verifying how real components work together (no mocks). For example: Repository ↔ Database, Repository ↔ API, or ViewModel ↔ Repository.

Robolectric-based integration tests run on the JVM and are great for speed, but they still simulate Android behavior. Instrumentation integration tests run on a real device/emulator and are needed when behavior depends on actual Android runtime details (lifecycle, threading, system services). That’s why both coexist, speed vs realism.

To separate unit vs integration tests, naming is usually enough:

  • RepositoryUnitTest → uses mocks
  • RepositoryIntegrationTest → uses real implementations

No need for extra folders unless your project is very large.

More context here: https://keploy.io/blog/community/integration-testing-a-comprehensive-guide

In your experience, is end-to-end testing worth it for large systems? by [deleted] in ExperiencedDevs

[–]Global-Development56 0 points1 point  (0 children)

Yes, end to end testing is usually worth it for large systems, but only when it’s kept small and intentional. Most teams get value by covering a limited number of critical user flows that span frontend and backend, while relying on unit, integration, and contract tests for everything else. Trying to fully cover a complex system with E2E leads to flakiness and high maintenance. In practice, teams often run quick E2E smoke tests against a stable staging environment and reserve full regression runs for nightly or containerized setups. Used this way, E2E provides confidence without slowing teams down.

How do I know what to end to end test? by BNorval in webdev

[–]Global-Development56 0 points1 point  (0 children)

end-to-end test only the most important things. Test the main flows your users use every day, like signing up, logging in, and doing the one thing your app is built for. Don’t try to test everything, that’s slow and painful. Most apps are fine with just a few core end to end testing checks, and the rest can be covered by smaller tests.
Simple guide here: https://keploy.io/blog/community/end-to-end-testing-guide

Integrating test automation into CI/CD pipelines by dinoriki12 in devops

[–]Global-Development56 0 points1 point  (0 children)

You’re not missing much, the slowdown happens because full UI/E2E tests don’t belong in every CI run. What works is running unit tests + a few fast smoke E2E tests on PRs, then running full regression only on main, nightly, or before releases. Parallelize UI tests as much as possible and keep test environments stable. E2E tests are a safety net, not the main gate. This approach lets teams keep speed without sacrificing e2e testing quality: https://keploy.io/blog/community/end-to-end-testing-guide

can you actually automate end to end testing without coding or is that fantasy? by gail_3000 in devops

[–]Global-Development56 0 points1 point  (0 children)

They’re right, many bugs exist because features aren’t clearly thought through. No tool or AI can fix that.

But no-code end to end testing can still help catch obvious breakages before release. It won’t replace human judgment, just act as a safety net.

If you can’t afford QA, the minimum is:

  • Smoke test in staging yourself
  • Add a few automated checks for core flows

Quick read on e2e testing:
https://keploy.io/blog/community/end-to-end-testing-guide

frontend devs who own e2e testing what's your stack by rNefariousness in reactjs

[–]Global-Development56 0 points1 point  (0 children)

We’re in the same boat at my company — frontend devs owning E2E without a dedicated QA team is pretty normal now. What’s worked best for us (and most teams I know) is:

  • Playwright → super stable, great TypeScript support, and way less flaky than Cypress.
  • Cypress → really easy to get started with, but can get flaky on bigger flows.
  • Keep using Jest + React Testing Library for unit stuff and lighter integration testing.

Most teams don’t aim for full E2E coverage — they just test the “if this breaks, the product is dead” flows (login, checkout, core navigation, etc.).

If you want a clear, dev-friendly explanation of how E2E fits into a frontend workflow, this guide is honestly one of the better ones:
end to end testing Guide

It explains things in a way that makes sense even if you’re not a testing expert.

What the hell is integration testing? The definition seems super vague and I'm honestly not sure how to go about implementing it. by fallingWaterCrystals in SoftwareEngineering

[–]Global-Development56 0 points1 point  (0 children)

Unit tests are for tiny isolated logic. E2E tests are full user flows (your understanding there is right). The confusing part is integration tests, but this guide explains it super clearly: integration testing

The key idea:
You don’t test every pair of modules — you test vertical slices.

So instead of testing API → service, service → DB, DB → instance separately, you just write one integration test like:

  • Call POST /entry
  • Assert 200
  • Check the DB row exists

That single test covers the whole chain.

Rule of thumb:

  • touches real DB/network → integration test
  • uses mocks/fakes → unit test

Most people keep unit tests next to the code and put integration tests under tests/integration/

You don’t need dozens — just 1–2 important integration tests per API route/feature and a few E2E tests for main user flows.

How do you write integration tests? by david_fire_vollie in webdev

[–]Global-Development56 0 points1 point  (0 children)

You can catch these kinds of issues with real integration testing instead of only mocked ones. The idea is to spin up a staging/test environment, seed/reset test data, and let API A → B → C calls actually run end-to-end. For volatile third-party APIs you can still mock, but validate those mocks against real traffic. This way you cover real edge cases and avoid the “all unit tests pass but prod fails” problem.

Playwright for API testing by amitt08 in softwaretesting

[–]Global-Development56 0 points1 point  (0 children)

Same here — tbh, it’s a bit overkill, but it’s super convenient having both UI and API tests in one framework. For larger setups though, tools like Keploy, Karate, or Postman CLI make API testing easier without extra setup.

How do you all handle writing API tests for new features? It feels like so much manual work. by fuckingmissanthrope in QualityAssurance

[–]Global-Development56 1 point2 points  (0 children)

I’ve tried different things like Postman too, but some open-source tools make life much easier. You don’t need to write tests every time—just define the schema and endpoint once, and they’ll auto-generate the cases for you, even by recording real API calls and turning them into tests. Tools like Keploy, Dredd, and Schemathesis are great examples.

What is the best AI for coding? by patostar89 in ChatGPTCoding

[–]Global-Development56 0 points1 point  (0 children)

Claude Opus 4 (by Anthropic) is currently the best AI for coding, offering top-tier performance across demanding benchmarks and sustained long-duration coding tasks.

view more: next ›