Exempt unittest context methods for SIM115 rule

Author: adamchainz

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM115.py

@@ -3,6 +3,7 @@
 import pathlib as pl
 from pathlib import Path
 from pathlib import Path as P
+from unittest import IsolatedAsyncioTestCase, TestCase
 
 # SIM115
 f = open("foo.txt")
@@ -59,6 +60,25 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         self.file.close()
 
 
+# OK
+class ExampleClassTests(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.enterClassContext(open("filename"))
+
+
+# OK
+class ExampleAsyncTests(IsolatedAsyncioTestCase):
+    async def test_something(self):
+        await self.enterAsyncContext(open("filename"))
+
+
+# OK
+class ExampleTests(TestCase):
+    def setUp(self):
+        self.enterContext(open("filename"))
+
+
 import tempfile
 import tarfile
 from tarfile import TarFile

crates/ruff_linter/src/rules/flake8_simplify/rules/open_file_with_context_handler.rs

@@ -114,6 +114,30 @@ fn match_exit_stack(semantic: &SemanticModel) -> bool {
     false
 }
 
+/// Return `true` if the current expression is nested in a call to one of the
+/// unittest context manager methods: `cls.enterClassContext()`,
+/// `self.enterContext()`, or `self.enterAsyncContext()`.
+fn match_unittest_context_methods(semantic: &SemanticModel) -> bool {
+    let Some(expr) = semantic.current_expression_parent() else {
+        return false;
+    };
+    let Expr::Call(ast::ExprCall { func, .. }) = expr else {
+        return false;
+    };
+    let Expr::Attribute(ast::ExprAttribute { attr, value, .. }) = func.as_ref() else {
+        return false;
+    };
+    if attr != "enterClassContext" && attr != "enterContext" && attr != "enterAsyncContext" {
+        return false;
+    }
+    let Expr::Name(ast::ExprName { id, .. }) = value.as_ref() else {
+        return false;
+    };
+    id == "cls" && attr == "enterClassContext"
+        || id == "self" && attr == "enterContext"
+        || id == "self" && attr == "enterAsyncContext"
+}
+
 /// Return `true` if the expression is a call to `open()`,
 /// or a call to some other standard-library function that opens a file.
 fn is_open_call(semantic: &SemanticModel, call: &ast::ExprCall) -> bool {
@@ -229,6 +253,11 @@ pub(crate) fn open_file_with_context_handler(checker: &Checker, call: &ast::Expr
         return;
     }
 
+    // Ex) `self.enterContext(open("foo.txt"))`
+    if match_unittest_context_methods(semantic) {
+        return;
+    }
+
     // Ex) `def __enter__(self): ...`
     if let ScopeKind::Function(ast::StmtFunctionDef { name, .. }) =
         &checker.semantic().current_scope().kind