bbot 2.3.0.5370rc0__py3-none-any.whl → 2.3.0.5382rc0__py3-none-any.whl

bbot/scripts/docs.py

@@ -124,7 +124,7 @@ def find_replace_file(file, keyword, replace):
         content = f.read()
         new_content = find_replace_markdown(content, keyword, replace)
     if new_content != content:
-        if not "BBOT_TESTING" in os.environ:
+        if "BBOT_TESTING" not in os.environ:
             with open(file, "w") as f:
                 f.write(new_content)
 

bbot/test/bbot_fixtures.py

@@ -19,7 +19,7 @@ from bbot.core.helpers.async_helpers import get_event_loop
 from bbot.core.helpers.misc import mkdir, rand_string, get_python_constraints
 
 
-log = logging.getLogger(f"bbot.test.fixtures")
+log = logging.getLogger("bbot.test.fixtures")
 
 
 bbot_test_dir = Path("/tmp/.bbot_test")

bbot/test/conftest.py

@@ -95,7 +95,7 @@ def bbot_httpserver_ssl():
 
 
 def should_mock(request):
-    return not request.url.host in ["127.0.0.1", "localhost", "raw.githubusercontent.com"] + interactsh_servers
+    return request.url.host not in ["127.0.0.1", "localhost", "raw.githubusercontent.com"] + interactsh_servers
 
 
 def pytest_collection_modifyitems(config, items):

bbot/test/run_tests.sh

@@ -3,14 +3,14 @@
 bbot_dir="$( realpath "$(dirname "$(dirname "${BASH_SOURCE[0]}")")")"
 echo -e "[+] BBOT dir: $bbot_dir\n"
 
-echo "[+] Checking code formatting with black"
+echo "[+] Checking code formatting with ruff"
 echo "======================================="
-black --check "$bbot_dir" || exit 1
+ruff format "$bbot_dir" || exit 1
 echo
 
-echo "[+] Linting with flake8"
+echo "[+] Linting with ruff"
 echo "======================="
-flake8 "$bbot_dir" || exit 1
+ruff check "$bbot_dir" || exit 1
 echo
 
 if [ "${1}x" != "x" ] ; then

bbot/test/test_step_1/test_bbot_fastapi.py

@@ -28,7 +28,7 @@ def test_bbot_multiprocess(bbot_httpserver):
     assert len(events) >= 3
     scan_events = [e for e in events if e["type"] == "SCAN"]
     assert len(scan_events) == 2
-    assert any([e["data"] == "test@blacklanternsecurity.com" for e in events])
+    assert any(e["data"] == "test@blacklanternsecurity.com" for e in events)
 
 
 def test_bbot_fastapi(bbot_httpserver):
@@ -61,7 +61,7 @@ def test_bbot_fastapi(bbot_httpserver):
         assert len(events) >= 3
         scan_events = [e for e in events if e["type"] == "SCAN"]
         assert len(scan_events) == 2
-        assert any([e["data"] == "test@blacklanternsecurity.com" for e in events])
+        assert any(e["data"] == "test@blacklanternsecurity.com" for e in events)
 
     finally:
         with suppress(Exception):

bbot/test/test_step_1/test_cli.py

@@ -17,11 +17,11 @@ async def test_cli_scope(monkeypatch, capsys):
     )
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == True
+    assert result is True
     lines = [json.loads(l) for l in out.splitlines()]
     dns_events = [l for l in lines if l["type"] == "DNS_NAME" and l["data"] == "one.one.one.one"]
     assert dns_events
-    assert all([l["scope_distance"] == 0 and "in-scope" in l["tags"] for l in dns_events])
+    assert all(l["scope_distance"] == 0 and "in-scope" in l["tags"] for l in dns_events)
     assert 1 == len(
         [
             l
@@ -34,10 +34,10 @@ async def test_cli_scope(monkeypatch, capsys):
     )
     ip_events = [l for l in lines if l["type"] == "IP_ADDRESS" and l["data"] == "1.1.1.1"]
     assert ip_events
-    assert all([l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in ip_events])
+    assert all(l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in ip_events)
     ip_events = [l for l in lines if l["type"] == "IP_ADDRESS" and l["data"] == "1.0.0.1"]
     assert ip_events
-    assert all([l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in ip_events])
+    assert all(l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in ip_events)
 
     # with whitelist
     monkeypatch.setattr(
@@ -57,14 +57,14 @@ async def test_cli_scope(monkeypatch, capsys):
     )
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == True
+    assert result is True
     lines = [json.loads(l) for l in out.splitlines()]
     lines = [l for l in lines if l["type"] != "SCAN"]
     assert lines
-    assert not any([l["scope_distance"] == 0 for l in lines])
+    assert not any(l["scope_distance"] == 0 for l in lines)
     dns_events = [l for l in lines if l["type"] == "DNS_NAME" and l["data"] == "one.one.one.one"]
     assert dns_events
-    assert all([l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in dns_events])
+    assert all(l["scope_distance"] == 1 and "distance-1" in l["tags"] for l in dns_events)
     assert 1 == len(
         [
             l
@@ -77,10 +77,10 @@ async def test_cli_scope(monkeypatch, capsys):
     )
     ip_events = [l for l in lines if l["type"] == "IP_ADDRESS" and l["data"] == "1.1.1.1"]
     assert ip_events
-    assert all([l["scope_distance"] == 2 and "distance-2" in l["tags"] for l in ip_events])
+    assert all(l["scope_distance"] == 2 and "distance-2" in l["tags"] for l in ip_events)
     ip_events = [l for l in lines if l["type"] == "IP_ADDRESS" and l["data"] == "1.0.0.1"]
     assert ip_events
-    assert all([l["scope_distance"] == 2 and "distance-2" in l["tags"] for l in ip_events])
+    assert all(l["scope_distance"] == 2 and "distance-2" in l["tags"] for l in ip_events)
 
 
 @pytest.mark.asyncio
@@ -97,7 +97,7 @@ async def test_cli_scan(monkeypatch):
         ["bbot", "-y", "-t", "127.0.0.1", "www.example.com", "-n", "test_cli_scan", "-c", "dns.disable=true"],
     )
     result = await cli._main()
-    assert result == True
+    assert result is True
 
     scan_home = scans_home / "test_cli_scan"
     assert (scan_home / "preset.yml").is_file(), "preset.yml not found"
@@ -139,14 +139,14 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     monkeypatch.setattr("sys.argv", ["bbot", "--version"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert len(out.splitlines()) == 1
     assert out.count(".") > 1
 
     # list modules
     monkeypatch.setattr("sys.argv", ["bbot", "--list-modules"])
     result = await cli._main()
-    assert result == None
+    assert result is None
     out, err = capsys.readouterr()
     # internal modules
     assert "| excavate " in out
@@ -162,7 +162,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     assert not output_dir.exists()
     monkeypatch.setattr("sys.argv", ["bbot", "-o", str(output_dir), "-n", scan_name, "-y"])
     result = await cli._main()
-    assert result == True
+    assert result is True
     assert output_dir.is_dir()
     assert scan_dir.is_dir()
     assert "[SCAN]" in open(scan_dir / "output.txt").read()
@@ -173,7 +173,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     monkeypatch.setattr("sys.argv", ["bbot", "--list-module-options"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| modules.wayback.urls" in out
     assert "| bool" in out
     assert "| emit URLs in addition to DNS_NAMEs" in out
@@ -185,36 +185,36 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "subdomain-enum", "--list-module-options"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| modules.wayback.urls" in out
     assert "| bool" in out
     assert "| emit URLs in addition to DNS_NAMEs" in out
     assert "| False" in out
     assert "| modules.dnsbrute.wordlist" in out
-    assert not "| modules.robots.include_allow" in out
+    assert "| modules.robots.include_allow" not in out
 
     # list module options by module
     monkeypatch.setattr("sys.argv", ["bbot", "-m", "dnsbrute", "-lmo"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert out.count("modules.") == out.count("modules.dnsbrute.")
-    assert not "| modules.wayback.urls" in out
+    assert "| modules.wayback.urls" not in out
     assert "| modules.dnsbrute.wordlist" in out
-    assert not "| modules.robots.include_allow" in out
+    assert "| modules.robots.include_allow" not in out
 
     # list output module options by module
     monkeypatch.setattr("sys.argv", ["bbot", "-om", "stdout", "-lmo"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert out.count("modules.") == out.count("modules.stdout.")
 
     # list flags
     monkeypatch.setattr("sys.argv", ["bbot", "--list-flags"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| safe " in out
     assert "| Non-intrusive, safe to run " in out
     assert "| active " in out
@@ -224,32 +224,32 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "active", "--list-flags"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
-    assert not "| safe " in out
+    assert result is None
+    assert "| safe " not in out
     assert "| active " in out
-    assert not "| passive " in out
+    assert "| passive " not in out
 
     # list multiple flags
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "active", "safe", "--list-flags"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| safe " in out
     assert "| active " in out
-    assert not "| passive " in out
+    assert "| passive " not in out
 
     # no args
     monkeypatch.setattr("sys.argv", ["bbot"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "Target:\n  -t TARGET [TARGET ...]" in out
 
     # list modules
     monkeypatch.setattr("sys.argv", ["bbot", "-l"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| dnsbrute " in out
     assert "| httpx " in out
     assert "| robots " in out
@@ -258,33 +258,33 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "subdomain-enum", "-l"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| dnsbrute " in out
     assert "| httpx " in out
-    assert not "| robots " in out
+    assert "| robots " not in out
 
     # list modules by flag + required flag
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "subdomain-enum", "-rf", "passive", "-l"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| chaos " in out
-    assert not "| httpx " in out
+    assert "| httpx " not in out
 
     # list modules by flag + excluded flag
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "subdomain-enum", "-ef", "active", "-l"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
+    assert result is None
     assert "| chaos " in out
-    assert not "| httpx " in out
+    assert "| httpx " not in out
 
     # list modules by flag + excluded module
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "subdomain-enum", "-em", "dnsbrute", "-l"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == None
-    assert not "| dnsbrute " in out
+    assert result is None
+    assert "| dnsbrute " not in out
     assert "| httpx " in out
 
     # output modules override
@@ -292,12 +292,12 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-om", "csv,json", "-y"])
     result = await cli._main()
-    assert result == True
+    assert result is True
     assert "Loaded 2/2 output modules, (csv,json)" in caplog.text
     caplog.clear()
     monkeypatch.setattr("sys.argv", ["bbot", "-em", "csv,json", "-y"])
     result = await cli._main()
-    assert result == True
+    assert result is True
     assert "Loaded 3/3 output modules, (python,stdout,txt)" in caplog.text
 
     # output modules override
@@ -305,7 +305,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-om", "subdomains", "-y"])
     result = await cli._main()
-    assert result == True
+    assert result is True
     assert "Loaded 6/6 output modules, (csv,json,python,stdout,subdomains,txt)" in caplog.text
 
     # internal modules override
@@ -313,17 +313,17 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-y"])
     result = await cli._main()
-    assert result == True
+    assert result is True
     assert "Loaded 5/5 internal modules (aggregate,cloudcheck,dnsresolve,excavate,speculate)" in caplog.text
     caplog.clear()
     monkeypatch.setattr("sys.argv", ["bbot", "-em", "excavate", "speculate", "-y"])
     result = await cli._main()
-    assert result == True
+    assert result is True
     assert "Loaded 3/3 internal modules (aggregate,cloudcheck,dnsresolve)" in caplog.text
     caplog.clear()
     monkeypatch.setattr("sys.argv", ["bbot", "-c", "speculate=false", "-y"])
     result = await cli._main()
-    assert result == True
+    assert result is True
     assert "Loaded 4/4 internal modules (aggregate,cloudcheck,dnsresolve,excavate)" in caplog.text
 
     # custom target type
@@ -331,7 +331,7 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     monkeypatch.setattr("sys.argv", ["bbot", "-t", "ORG:evilcorp", "-y"])
     result = await cli._main()
     out, err = capsys.readouterr()
-    assert result == True
+    assert result is True
     assert "[ORG_STUB]          	evilcorp	TARGET" in out
 
     # activate modules by flag
@@ -339,50 +339,50 @@ async def test_cli_args(monkeypatch, caplog, capsys, clean_default_config):
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "passive"])
     result = await cli._main()
-    assert result == True
+    assert result is True
 
     # unconsoleable output module
     monkeypatch.setattr("sys.argv", ["bbot", "-om", "web_report"])
     result = await cli._main()
-    assert result == True
+    assert result is True
 
     # unresolved dependency
     monkeypatch.setattr("sys.argv", ["bbot", "-m", "wappalyzer"])
     result = await cli._main()
-    assert result == True
+    assert result is True
 
     # require flags
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "active", "-rf", "passive"])
     result = await cli._main()
-    assert result == True
+    assert result is True
 
     # excluded flags
     monkeypatch.setattr("sys.argv", ["bbot", "-f", "active", "-ef", "active"])
     result = await cli._main()
-    assert result == True
+    assert result is True
 
     # slow modules
     monkeypatch.setattr("sys.argv", ["bbot", "-m", "bucket_digitalocean"])
     result = await cli._main()
-    assert result == True
+    assert result is True
 
     # deadly modules
     caplog.clear()
     assert not caplog.text
     monkeypatch.setattr("sys.argv", ["bbot", "-m", "nuclei"])
     result = await cli._main()
-    assert result == False, "-m nuclei ran without --allow-deadly"
+    assert result is False, "-m nuclei ran without --allow-deadly"
     assert "Please specify --allow-deadly to continue" in caplog.text
 
     # --allow-deadly
     monkeypatch.setattr("sys.argv", ["bbot", "-m", "nuclei", "--allow-deadly"])
     result = await cli._main()
-    assert result == True, "-m nuclei failed to run with --allow-deadly"
+    assert result is True, "-m nuclei failed to run with --allow-deadly"
 
     # install all deps
     monkeypatch.setattr("sys.argv", ["bbot", "--install-all-deps"])
     success = await cli._main()
-    assert success == True, "--install-all-deps failed for at least one module"
+    assert success is True, "--install-all-deps failed for at least one module"
 
 
 @pytest.mark.asyncio
@@ -396,7 +396,7 @@ async def test_cli_customheaders(monkeypatch, caplog, capsys):
         "sys.argv", ["bbot", "--custom-headers", "foo=bar", "foo2=bar2", "foo3=bar=3", "--current-preset"]
     )
     success = await cli._main()
-    assert success == None, "setting custom headers on command line failed"
+    assert success is None, "setting custom headers on command line failed"
     captured = capsys.readouterr()
     stdout_preset = yaml.safe_load(captured.out)
     assert stdout_preset["config"]["web"]["http_headers"] == {"foo": "bar", "foo2": "bar2", "foo3": "bar=3"}
@@ -404,21 +404,21 @@ async def test_cli_customheaders(monkeypatch, caplog, capsys):
     # test custom headers invalid (no "=")
     monkeypatch.setattr("sys.argv", ["bbot", "--custom-headers", "justastring", "--current-preset"])
     result = await cli._main()
-    assert result == None
+    assert result is None
     assert "Custom headers not formatted correctly (missing '=')" in caplog.text
     caplog.clear()
 
     # test custom headers invalid (missing key)
     monkeypatch.setattr("sys.argv", ["bbot", "--custom-headers", "=nokey", "--current-preset"])
     result = await cli._main()
-    assert result == None
+    assert result is None
     assert "Custom headers not formatted correctly (missing header name or value)" in caplog.text
     caplog.clear()
 
     # test custom headers invalid (missing value)
     monkeypatch.setattr("sys.argv", ["bbot", "--custom-headers", "missingvalue=", "--current-preset"])
     result = await cli._main()
-    assert result == None
+    assert result is None
     assert "Custom headers not formatted correctly (missing header name or value)" in caplog.text
 
 

bbot/test/test_step_1/test_dns.py

@@ -23,7 +23,7 @@ async def test_dns_engine(bbot_scanner):
     )
     result = await scan.helpers.resolve("one.one.one.one")
     assert "1.1.1.1" in result
-    assert not "2606:4700:4700::1111" in result
+    assert "2606:4700:4700::1111" not in result
 
     results = [_ async for _ in scan.helpers.resolve_batch(("one.one.one.one", "1.1.1.1"))]
     pass_1 = False
@@ -85,12 +85,12 @@ async def test_dns_resolution(bbot_scanner):
     for answer in answers:
         responses += list(extract_targets(answer))
     assert ("A", "1.1.1.1") in responses
-    assert not ("AAAA", "2606:4700:4700::1111") in responses
+    assert ("AAAA", "2606:4700:4700::1111") not in responses
     answers, errors = await dnsengine.resolve_raw("one.one.one.one", type="AAAA")
     responses = []
     for answer in answers:
         responses += list(extract_targets(answer))
-    assert not ("A", "1.1.1.1") in responses
+    assert ("A", "1.1.1.1") not in responses
     assert ("AAAA", "2606:4700:4700::1111") in responses
     answers, errors = await dnsengine.resolve_raw("1.1.1.1")
     responses = []
@@ -113,7 +113,7 @@ async def test_dns_resolution(bbot_scanner):
     batch_results = [r async for r in dnsengine.resolve_batch(["1.1.1.1", "one.one.one.one"])]
     assert len(batch_results) == 2
     batch_results = dict(batch_results)
-    assert any([x in batch_results["one.one.one.one"] for x in ("1.1.1.1", "1.0.0.1")])
+    assert any(x in batch_results["one.one.one.one"] for x in ("1.1.1.1", "1.0.0.1"))
     assert "one.one.one.one" in batch_results["1.1.1.1"]
 
     # custom batch resolution
@@ -141,11 +141,11 @@ async def test_dns_resolution(bbot_scanner):
     assert hash(("1.1.1.1", "PTR")) in dnsengine._dns_cache
     await dnsengine.resolve("one.one.one.one", type="A")
     assert hash(("one.one.one.one", "A")) in dnsengine._dns_cache
-    assert not hash(("one.one.one.one", "AAAA")) in dnsengine._dns_cache
+    assert hash(("one.one.one.one", "AAAA")) not in dnsengine._dns_cache
     dnsengine._dns_cache.clear()
     await dnsengine.resolve("one.one.one.one", type="AAAA")
     assert hash(("one.one.one.one", "AAAA")) in dnsengine._dns_cache
-    assert not hash(("one.one.one.one", "A")) in dnsengine._dns_cache
+    assert hash(("one.one.one.one", "A")) not in dnsengine._dns_cache
 
     await dnsengine._shutdown()
 
@@ -165,7 +165,7 @@ async def test_dns_resolution(bbot_scanner):
     assert "A" in resolved_hosts_event1.raw_dns_records
     assert "AAAA" in resolved_hosts_event1.raw_dns_records
     assert "a-record" in resolved_hosts_event1.tags
-    assert not "a-record" in resolved_hosts_event2.tags
+    assert "a-record" not in resolved_hosts_event2.tags
 
     scan2 = bbot_scanner("evilcorp.com", config={"dns": {"minimal": False}})
     await scan2.helpers.dns._mock_dns(
@@ -198,7 +198,7 @@ async def test_wildcards(bbot_scanner):
     assert len(dnsengine._wildcard_cache) == len(all_rdtypes) + (len(all_rdtypes) - 2)
     for rdtype in all_rdtypes:
         assert hash(("github.io", rdtype)) in dnsengine._wildcard_cache
-        if not rdtype in ("A", "AAAA"):
+        if rdtype not in ("A", "AAAA"):
             assert hash(("asdf.github.io", rdtype)) in dnsengine._wildcard_cache
     assert "github.io" in wildcard_domains
     assert "A" in wildcard_domains["github.io"]
@@ -781,16 +781,16 @@ async def test_dns_graph_structure(bbot_scanner):
 
 @pytest.mark.asyncio
 async def test_dns_helpers(bbot_scanner):
-    assert service_record("") == False
-    assert service_record("localhost") == False
-    assert service_record("www.example.com") == False
-    assert service_record("www.example.com", "SRV") == True
-    assert service_record("_custom._service.example.com", "SRV") == True
-    assert service_record("_custom._service.example.com", "A") == False
+    assert service_record("") is False
+    assert service_record("localhost") is False
+    assert service_record("www.example.com") is False
+    assert service_record("www.example.com", "SRV") is True
+    assert service_record("_custom._service.example.com", "SRV") is True
+    assert service_record("_custom._service.example.com", "A") is False
     # top 100 most common SRV records
     for srv_record in common_srvs[:100]:
         hostname = f"{srv_record}.example.com"
-        assert service_record(hostname) == True
+        assert service_record(hostname) is True
 
     # make sure system nameservers are excluded from use by DNS brute force
     brute_nameservers = tempwordlist(["1.2.3.4", "8.8.4.4", "4.3.2.1", "8.8.8.8"])

bbot/test/test_step_1/test_engine.py

@@ -72,7 +72,7 @@ async def test_engine():
 
     # test async generator
     assert counter == 0
-    assert yield_cancelled == False
+    assert yield_cancelled is False
     yield_res = [r async for r in test_engine.yield_stuff(13)]
     assert yield_res == [f"thing{i}" for i in range(13)]
     assert len(yield_res) == 13
@@ -88,8 +88,8 @@ async def test_engine():
             await agen.aclose()
             break
     await asyncio.sleep(5)
-    assert yield_cancelled == True
-    assert yield_errored == False
+    assert yield_cancelled is True
+    assert yield_errored is False
     assert counter < 15
 
     # test async generator with error
@@ -99,8 +99,8 @@ async def test_engine():
     with pytest.raises(BBOTEngineError):
         async for _ in agen:
             pass
-    assert yield_cancelled == False
-    assert yield_errored == True
+    assert yield_cancelled is False
+    assert yield_errored is True
 
     # test return with cancellation
     return_started = False
@@ -113,10 +113,10 @@ async def test_engine():
     with pytest.raises(asyncio.CancelledError):
         await task
     await asyncio.sleep(0.1)
-    assert return_started == True
-    assert return_finished == False
-    assert return_cancelled == True
-    assert return_errored == False
+    assert return_started is True
+    assert return_finished is False
+    assert return_cancelled is True
+    assert return_errored is False
 
     # test return with late cancellation
     return_started = False
@@ -128,10 +128,10 @@ async def test_engine():
     task.cancel()
     result = await task
     assert result == "thing1"
-    assert return_started == True
-    assert return_finished == True
-    assert return_cancelled == False
-    assert return_errored == False
+    assert return_started is True
+    assert return_finished is True
+    assert return_cancelled is False
+    assert return_errored is False
 
     # test return with error
     return_started = False
@@ -140,9 +140,9 @@ async def test_engine():
     return_errored = False
     with pytest.raises(BBOTEngineError):
         result = await test_engine.return_thing(None)
-    assert return_started == True
-    assert return_finished == False
-    assert return_cancelled == False
-    assert return_errored == True
+    assert return_started is True
+    assert return_finished is False
+    assert return_cancelled is False
+    assert return_errored is True
 
     await test_engine.shutdown()