AI Prompts for Reducing Over-Mocking in Tests

Please identify all the dependencies that are mocked in the test file [FILE_NAME]. For each mocked dependency, provide a brief summary explaining its purpose within the context of the tests. Include details on how each mock contributes to the overall functionality being tested and any specific behaviors or interactions that are simulated. Organize the information in a clear format, listing the dependencies and their corresponding summaries.

For the test file [FILE_NAME], provide a detailed analysis of how each mock is utilized within the tests. Explain the purpose of each mock and its impact on the overall test outcomes. Identify any mocks that are not contributing to the effectiveness of the tests, and suggest potential improvements or removals. Additionally, summarize the overall mock usage in the test file and provide recommendations for optimizing the testing strategy.

Please analyze the test coverage for the file named [FILE_NAME]. Identify and highlight any areas where real behavior is not being adequately tested, particularly due to excessive use of mocking. Provide a detailed report that includes specific lines or sections of code that are affected, an explanation of why these areas are important to test, and recommendations for improving the test coverage to ensure more realistic behavior is assessed. Format the findings in a clear manner, making it easy to understand the impact of the current testing approach.

Please review the assertions in the test file named [FILE_NAME]. Your task is to evaluate whether each assertion is effectively verifying actual behavior of the code or if it is merely checking interactions with mock objects. Provide a detailed analysis for each assertion, including examples of how they could be improved to ensure they are testing real functionality. Summarize your findings in a report format, highlighting any assertions that need to be revised or removed for better test coverage.

For each mock in [FILE_NAME], provide a detailed assessment of its necessity within the tests. Explain the specific role each mock plays in the testing process and discuss whether the test could be effectively rewritten to eliminate the need for this mock. If possible, suggest alternative approaches or strategies that could be employed to achieve the same testing objectives without relying on mocks. Your response should include examples of how the tests could be structured differently and the potential benefits of those changes.

Please analyze the test code in [FILE_NAME] and identify any mocks that are unnecessary and do not impact the outcomes of the tests. For each mock you find, explain why it is deemed unnecessary and provide the revised version of the test code after removing those mocks. Ensure that the revised code maintains its functionality and clarity, and format the output to clearly distinguish between the original and modified sections.

Please refactor the tests in [FILE_NAME] to utilize real dependencies instead of mocks wherever possible. Ensure that the updated test code maintains the same functionality and coverage as the original tests. Include comments explaining the changes made and the rationale behind using real dependencies. Additionally, provide a brief summary of how these changes improve the test reliability and maintainability.

Please simplify the logic in the test file named [FILE_NAME] to emphasize real behavior instead of mocked interactions. Analyze the current code and identify areas where the logic can be streamlined while maintaining the integrity of the tests. Provide the revised code with clear comments explaining the changes made and the reasoning behind them. Ensure that the simplified version is easy to understand and follows best practices for test writing.

Please optimize the mock configuration in the file [FILE_NAME]. Focus on identifying and retaining only the essential mocks that are necessary for the tests to run effectively. Provide the revised configuration in a clear format, highlighting which mocks were removed and explaining why they were deemed non-essential. Additionally, include any potential impacts this optimization may have on the overall testing process.

Please enhance the test assertions in the file [FILE_NAME] to ensure they verify actual outcomes instead of relying on mock interactions. Focus on identifying key areas where the assertions can be strengthened, and provide detailed examples of the improved assertions. Ensure that the new assertions cover all critical aspects of the functionality being tested and include explanations for why these enhancements are necessary. Format the output clearly, showing both the original assertions and the revised versions for easy comparison.

Please execute the tests contained in [FILE_NAME] and verify that all tests pass successfully. Ensure that there are no unnecessary mocks used in the tests. After running the tests, provide a detailed summary of the test results, including any failures or errors encountered, along with suggestions for resolving any issues. Format the results in a clear and organized manner for easy review.

Please conduct a coverage analysis on the file [FILE_NAME] to verify that all real behaviors are adequately tested. Generate a detailed coverage report that includes the percentage of code covered, any uncovered lines, and a breakdown of which tests are associated with each part of the code. Additionally, provide insights on areas that may require more testing to ensure comprehensive coverage. Format the report clearly, highlighting key findings and recommendations for improvement.

Review the updated assertions in [FILE_NAME] to ensure they accurately verify the expected outcomes of the tests. Please provide a detailed summary of your validation process, including any discrepancies found between the expected and actual results. Additionally, outline any recommendations for improving the assertions or the tests themselves to enhance accuracy and reliability. Format your response as a structured report with clear sections for findings, recommendations, and conclusions.

Please analyze the dependencies used in [FILE_NAME] and determine whether each one is necessary for the tests. For each dependency, provide a brief justification explaining its role and importance in the testing process. Additionally, if any dependencies are found to be unnecessary, please recommend alternatives or suggest ways to refactor the tests to eliminate them. Format your response as a detailed report with clear sections for each dependency, including its name, justification, and any recommendations.

Analyze the test outcomes in [FILE_NAME] to ensure they accurately reflect the real behavior of the application. Please summarize the key findings, highlighting any discrepancies between expected and actual results. Additionally, identify any patterns or trends observed in the outcomes, and suggest potential areas for further investigation or improvement. Format the summary in a clear and concise manner, using bullet points for easy readability.

Draft a new rule for CLAUDE.md that addresses the limitations on mocking in tests. The rule should clearly outline the reasons for limiting mocking, the potential issues it can cause in test reliability, and the preferred alternatives to mocking. Include specific examples of scenarios where mocking should be avoided and suggest best practices for writing tests without relying on mocks. Format the rule in a clear and concise manner, suitable for inclusion in the CLAUDE.md documentation.

Create a detailed checklist for writing tests that minimize the use of mocking. Include specific items that focus on best practices, such as ensuring tests are isolated, using real objects when possible, and verifying interactions without mocks. The checklist should also cover aspects like maintaining test readability, ensuring tests are maintainable, and providing examples of scenarios where mocking should be avoided. Format the checklist in bullet points for easy reference.

Draft comprehensive guidelines for commenting on the usage of mocks in tests. The guidelines should cover the purpose of using mocks, best practices for when and how to comment on mock setups, and examples of effective comments. Include sections on clarity, consistency, and the importance of explaining the rationale behind each mock. Aim for a detailed document that can serve as a reference for developers to ensure their test comments enhance understanding and maintainability.

Propose a set of clear and consistent naming conventions for mock objects used in testing. The conventions should include guidelines on how to name mocks based on their purpose, such as the type of object they are mocking and the specific behavior they are simulating. Additionally, outline examples of naming patterns that can be followed, ensuring that the names are descriptive and easily understandable for anyone reviewing the tests. Aim for a format that can be documented and shared with the development team to promote best practices in test writing.

Help me define specific guardrails for my project to prevent over-mocking in tests. The guardrails should include guidelines on when to use mocks versus real implementations, criteria for determining the appropriateness of mocking, and examples of common scenarios where over-mocking might occur. Additionally, outline the potential risks of over-mocking and how to mitigate them. Format this information as a clear and structured document that I can reference throughout the project.