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

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()

bbot/test/test_step_1/test_events.py

@@ -81,8 +81,8 @@ async def test_events(events, helpers):
     assert "fsocie.ty" not in events.subdomain
     assert events.subdomain in events.domain
     assert events.domain not in events.subdomain
-    assert not events.ipv4 in events.domain
-    assert not events.netv6 in events.domain
+    assert events.ipv4 not in events.domain
+    assert events.netv6 not in events.domain
     assert events.emoji not in events.domain
     assert events.domain not in events.emoji
     open_port_event = scan.make_event(" eViLcorp.COM.:88", "DNS_NAME", dummy=True)
@@ -207,7 +207,7 @@ async def test_events(events, helpers):
 
     # scope distance
     event1 = scan.make_event("1.2.3.4", dummy=True)
-    assert event1._scope_distance == None
+    assert event1._scope_distance is None
     event1.scope_distance = 0
     assert event1._scope_distance == 0
     event2 = scan.make_event("2.3.4.5", parent=event1)
@@ -228,7 +228,7 @@ async def test_events(events, helpers):
 
     org_stub_1 = scan.make_event("STUB1", "ORG_STUB", parent=scan.root_event)
     org_stub_1.scope_distance == 1
-    assert org_stub_1.netloc == None
+    assert org_stub_1.netloc is None
     assert "netloc" not in org_stub_1.json()
     org_stub_2 = scan.make_event("STUB2", "ORG_STUB", parent=org_stub_1)
     org_stub_2.scope_distance == 2
@@ -237,7 +237,7 @@ async def test_events(events, helpers):
     root_event = scan.make_event("0.0.0.0", dummy=True)
     root_event.scope_distance = 0
     internal_event1 = scan.make_event("1.2.3.4", parent=root_event, internal=True)
-    assert internal_event1._internal == True
+    assert internal_event1._internal is True
     assert "internal" in internal_event1.tags
 
     # tag inheritance
@@ -269,8 +269,8 @@ async def test_events(events, helpers):
     # updating module
     event3 = scan.make_event("127.0.0.1", parent=scan.root_event)
     updated_event = scan.make_event(event3, internal=True)
-    assert event3.internal == False
-    assert updated_event.internal == True
+    assert event3.internal is False
+    assert updated_event.internal is True
 
     # event sorting
     parent1 = scan.make_event("127.0.0.1", parent=scan.root_event)
@@ -490,7 +490,7 @@ async def test_events(events, helpers):
     assert db_event.discovery_context == "test context"
     assert db_event.discovery_path == ["test context"]
     assert len(db_event.parent_chain) == 1
-    assert all([event_uuid_regex.match(u) for u in db_event.parent_chain])
+    assert all(event_uuid_regex.match(u) for u in db_event.parent_chain)
     assert db_event.parent_chain[0] == str(db_event.uuid)
     assert db_event.parent.uuid == scan.root_event.uuid
     assert db_event.parent_uuid == scan.root_event.uuid
@@ -527,7 +527,7 @@ async def test_events(events, helpers):
     hostless_event_json = hostless_event.json()
     assert hostless_event_json["type"] == "ASDF"
     assert hostless_event_json["data"] == "asdf"
-    assert not "host" in hostless_event_json
+    assert "host" not in hostless_event_json
 
     # SIEM-friendly serialize/deserialize
     json_event_siemfriendly = db_event.json(siem_friendly=True)
@@ -805,7 +805,7 @@ async def test_event_web_spider_distance(bbot_scanner):
     )
     assert url_event_3.web_spider_distance == 1
     assert "spider-danger" in url_event_3.tags
-    assert not "spider-max" in url_event_3.tags
+    assert "spider-max" not in url_event_3.tags
     social_event = scan.make_event(
         {"platform": "github", "url": "http://www.evilcorp.com/test4"}, "SOCIAL", parent=url_event_3
     )
@@ -828,42 +828,42 @@ async def test_event_web_spider_distance(bbot_scanner):
 
     url_event = scan.make_event("http://www.evilcorp.com", "URL_UNVERIFIED", parent=scan.root_event)
     assert url_event.web_spider_distance == 0
-    assert not "spider-danger" in url_event.tags
-    assert not "spider-max" in url_event.tags
+    assert "spider-danger" not in url_event.tags
+    assert "spider-max" not in url_event.tags
     url_event_2 = scan.make_event(
         "http://www.evilcorp.com", "URL_UNVERIFIED", parent=scan.root_event, tags="spider-danger"
     )
     # spider distance shouldn't increment because it's not the same host
     assert url_event_2.web_spider_distance == 0
     assert "spider-danger" in url_event_2.tags
-    assert not "spider-max" in url_event_2.tags
+    assert "spider-max" not in url_event_2.tags
     url_event_3 = scan.make_event(
         "http://www.evilcorp.com/3", "URL_UNVERIFIED", parent=url_event_2, tags="spider-danger"
     )
     assert url_event_3.web_spider_distance == 1
     assert "spider-danger" in url_event_3.tags
-    assert not "spider-max" in url_event_3.tags
+    assert "spider-max" not in url_event_3.tags
     url_event_4 = scan.make_event("http://evilcorp.com", "URL_UNVERIFIED", parent=url_event_3)
     assert url_event_4.web_spider_distance == 0
-    assert not "spider-danger" in url_event_4.tags
-    assert not "spider-max" in url_event_4.tags
+    assert "spider-danger" not in url_event_4.tags
+    assert "spider-max" not in url_event_4.tags
     url_event_4.add_tag("spider-danger")
     assert url_event_4.web_spider_distance == 0
     assert "spider-danger" in url_event_4.tags
-    assert not "spider-max" in url_event_4.tags
+    assert "spider-max" not in url_event_4.tags
     url_event_4.remove_tag("spider-danger")
     assert url_event_4.web_spider_distance == 0
-    assert not "spider-danger" in url_event_4.tags
-    assert not "spider-max" in url_event_4.tags
+    assert "spider-danger" not in url_event_4.tags
+    assert "spider-max" not in url_event_4.tags
     url_event_5 = scan.make_event("http://evilcorp.com/5", "URL_UNVERIFIED", parent=url_event_4)
     assert url_event_5.web_spider_distance == 0
-    assert not "spider-danger" in url_event_5.tags
-    assert not "spider-max" in url_event_5.tags
+    assert "spider-danger" not in url_event_5.tags
+    assert "spider-max" not in url_event_5.tags
     url_event_5.add_tag("spider-danger")
     # if host is the same as parent, web spider distance should auto-increment after adding spider-danger tag
     assert url_event_5.web_spider_distance == 1
     assert "spider-danger" in url_event_5.tags
-    assert not "spider-max" in url_event_5.tags
+    assert "spider-max" not in url_event_5.tags
 
 
 def test_event_confidence():