What's the best way to plan and execute software testing for a complex project?

When building React apps, the best is to practice TDD (Test-driven Development). But here's how to approach testing an already existing React project without tests: 1. Figure out one task the user does within your app (e.g., create a todo item) 2. Write an E2E or an integration test capturing how the user interacts with the app by doing the task (e.g., render a page, simulate user clicks/typing, assert the outcome). 3. Include this automation test into the CI pipeline (e.g., run the test on every pull request). 4. Repeat from 1) with the next task. This way, you protect the development of the next feature by not breaking existing software behavior (e.g., your test will fail when a pull request breaks expected software behavior).

Test Plan Understand Complexity: Analyze requirements and risks. Detailed Test Plan: Outline scope, objectives, and strategies. Risk Assessment: Prioritize potential risks. Test Environment: Match production as closely as possible. Test Case Design: Craft thorough test cases. Test Automation: Automate repetitive and regression tests. Continuous Integration: Integrate testing into development. Collaboration: Communicate with developers effectively. Test Execution: Track results and report issues. Regression Testing: Ensure code changes don't break existing functionality. User Acceptance Testing: Involve end-users or stakeholders. Documentation: Keep all test documents up to date. Continuous Improvement: Adapt and learn from each cycle.

1. First things first: Must test to confirm whether the objective of the application/ feature is achieved with respect to the requirement, programmatic logic underlying use cases. 2. Now you can proceed with integration testing, on success you are good to go further. 3. Plan your in-depth testing strategy which covers responsiveness, security, performance, scalability, automation, defining metrics analysis and so on.

I agree these are a very idealistic points to follow if we have a very well structured planning and process put in place and there is clearly defined hierarchy for review and approval process however in many projects its quite challenging to follow them due to lack of interaction between testers and real users, many a times testers plan and approach needs to be tweaked to meet the project delivers thus compromising the quality process and parameters.

For UAT I like to have my users create high level scenarios. We then run 45 mins to one hour time boxed sessions with the goal of completing the scenario. I then link their scenarios to the user story or requirements. Means I can test multiple elements from one UAT scenario.

Few more details for test data creation: 1. Create a standard template for test data. Template should keep in mind all the constraints that system is supposed to follow for positive scenarios. 2. Prepare template for invalid scenarios as well which system should not accept and throw the errors accordingly. 3. If there are any external/existing system level dependencies on data related to system, user level attributes or configs, then that data should be part of a seed data setup which takes place during env creation. 4. Adding capabilities to migrate production data to lower environments while masking PII helps bring realistic test data. 5. Use automated test data creation tools such as Faker or Mockaroo to generate mock data.

We use a test environment and release managed service. They look after and control all the tests environments who uses them? What's in them? Etc. This is all done through a tool called Plutora.

-One thing I found useful in my testing experience is constantly collecting & reviewing retrospective inputs on what went well and what could have been done better and actionizing the improvement points and turning them to accomplishments in the subsequent retro meets helps a lot in adding value to our deliverables.

Understanding the Project/AUT: Before embarking on testing, it's essential to have a thorough understanding of the project's complexity, objectives, and user requirements. Collaborate with developers, product managers, and stakeholders to gain insights into the software's intricacies.