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

bbot/test/test_step_1/test_modules_basic.py

@@ -23,27 +23,27 @@ async def test_modules_basic_checks(events, httpx_mock):
     localhost = scan.make_event("127.0.0.1", parent=scan.root_event)
     # ip addresses should be accepted
     result, reason = base_output_module_1._event_precheck(localhost)
-    assert result == True
+    assert result is True
     assert reason == "precheck succeeded"
     # internal events should be rejected
     localhost._internal = True
     result, reason = base_output_module_1._event_precheck(localhost)
-    assert result == False
+    assert result is False
     assert reason == "_internal is True"
     localhost._internal = False
     result, reason = base_output_module_1._event_precheck(localhost)
-    assert result == True
+    assert result is True
     assert reason == "precheck succeeded"
     # unwatched events should be rejected
     dns_name = scan.make_event("evilcorp.com", parent=scan.root_event)
     result, reason = base_output_module_1._event_precheck(dns_name)
-    assert result == False
+    assert result is False
     assert reason == "its type is not in watched_events"
     # omitted events matching watched types should be accepted
     url_unverified = scan.make_event("http://127.0.0.1", "URL_UNVERIFIED", parent=scan.root_event)
     url_unverified._omit = True
     result, reason = base_output_module_1._event_precheck(url_unverified)
-    assert result == True
+    assert result is True
     assert reason == "its type is explicitly in watched_events"
 
     base_output_module_2 = BaseOutputModule(scan)
@@ -51,42 +51,42 @@ async def test_modules_basic_checks(events, httpx_mock):
     # normal events should be accepted
     localhost = scan.make_event("127.0.0.1", parent=scan.root_event)
     result, reason = base_output_module_2._event_precheck(localhost)
-    assert result == True
+    assert result is True
     assert reason == "precheck succeeded"
     # internal events should be rejected
     localhost._internal = True
     result, reason = base_output_module_2._event_precheck(localhost)
-    assert result == False
+    assert result is False
     assert reason == "_internal is True"
     localhost._internal = False
     result, reason = base_output_module_2._event_precheck(localhost)
-    assert result == True
+    assert result is True
     assert reason == "precheck succeeded"
     # omitted events should be rejected
     localhost._omit = True
     result, reason = base_output_module_2._event_precheck(localhost)
-    assert result == False
+    assert result is False
     assert reason == "_omit is True"
     # normal event should be accepted
     url_unverified = scan.make_event("http://127.0.0.1", "URL_UNVERIFIED", parent=scan.root_event)
     result, reason = base_output_module_2._event_precheck(url_unverified)
-    assert result == True
+    assert result is True
     assert reason == "precheck succeeded"
     # omitted event types should be marked during scan egress
     await scan.egress_module.handle_event(url_unverified)
     result, reason = base_output_module_2._event_precheck(url_unverified)
-    assert result == False
+    assert result is False
     assert reason == "_omit is True"
     # omitted events that are targets should be accepted
     dns_name = scan.make_event("evilcorp.com", "DNS_NAME", parent=scan.root_event)
     dns_name._omit = True
     result, reason = base_output_module_2._event_precheck(dns_name)
-    assert result == False
+    assert result is False
     assert reason == "_omit is True"
     # omitted results that are targets should be accepted
     dns_name.add_tag("target")
     result, reason = base_output_module_2._event_precheck(dns_name)
-    assert result == True
+    assert result is True
     assert reason == "it's a target"
 
     # common event filtering tests
@@ -97,18 +97,18 @@ async def test_modules_basic_checks(events, httpx_mock):
         # base cases
         base_module._watched_events = None
         base_module.watched_events = ["*"]
-        assert base_module._event_precheck(events.emoji)[0] == True
+        assert base_module._event_precheck(events.emoji)[0] is True
         base_module._watched_events = None
         base_module.watched_events = ["IP_ADDRESS"]
-        assert base_module._event_precheck(events.ipv4)[0] == True
-        assert base_module._event_precheck(events.domain)[0] == False
-        assert base_module._event_precheck(events.localhost)[0] == True
-        assert base_module._event_precheck(localhost2)[0] == True
+        assert base_module._event_precheck(events.ipv4)[0] is True
+        assert base_module._event_precheck(events.domain)[0] is False
+        assert base_module._event_precheck(events.localhost)[0] is True
+        assert base_module._event_precheck(localhost2)[0] is True
         # target only
         base_module.target_only = True
-        assert base_module._event_precheck(localhost2)[0] == False
+        assert base_module._event_precheck(localhost2)[0] is False
         localhost2.add_tag("target")
-        assert base_module._event_precheck(localhost2)[0] == True
+        assert base_module._event_precheck(localhost2)[0] is True
         base_module.target_only = False
 
         # in scope only
@@ -147,11 +147,11 @@ async def test_modules_basic_checks(events, httpx_mock):
         for flag in flags:
             all_flags.add(flag)
         if preloaded["type"] == "scan":
-            assert ("active" in flags and not "passive" in flags) or (
-                not "active" in flags and "passive" in flags
+            assert ("active" in flags and "passive" not in flags) or (
+                "active" not in flags and "passive" in flags
             ), f'module "{module_name}" must have either "active" or "passive" flag'
-            assert ("safe" in flags and not "aggressive" in flags) or (
-                not "safe" in flags and "aggressive" in flags
+            assert ("safe" in flags and "aggressive" not in flags) or (
+                "safe" not in flags and "aggressive" in flags
             ), f'module "{module_name}" must have either "safe" or "aggressive" flag'
             assert not (
                 "web-basic" in flags and "web-thorough" in flags
@@ -174,15 +174,15 @@ async def test_modules_basic_checks(events, httpx_mock):
 
         assert type(watched_events) == list
         assert type(produced_events) == list
-        if not preloaded.get("type", "") in ("internal",):
+        if preloaded.get("type", "") not in ("internal",):
             assert watched_events, f"{module_name}.watched_events must not be empty"
         assert type(watched_events) == list, f"{module_name}.watched_events must be of type list"
         assert type(produced_events) == list, f"{module_name}.produced_events must be of type list"
         assert all(
-            [type(t) == str for t in watched_events]
+            type(t) == str for t in watched_events
         ), f"{module_name}.watched_events entries must be of type string"
         assert all(
-            [type(t) == str for t in produced_events]
+            type(t) == str for t in produced_events
         ), f"{module_name}.produced_events entries must be of type string"
 
         assert type(preloaded.get("deps_pip", [])) == list, f"{module_name}.deps_pip must be of type list"
@@ -268,35 +268,35 @@ async def test_modules_basic_perhostonly(bbot_scanner):
         valid_5, reason_5 = await module._event_postcheck(url_5)
 
         if mod_name == "mod_normal":
-            assert valid_1 == True
-            assert valid_2 == True
-            assert valid_3 == True
-            assert valid_4 == True
-            assert valid_5 == True
+            assert valid_1 is True
+            assert valid_2 is True
+            assert valid_3 is True
+            assert valid_4 is True
+            assert valid_5 is True
         elif mod_name == "mod_host_only":
-            assert valid_1 == True
-            assert valid_2 == False
+            assert valid_1 is True
+            assert valid_2 is False
             assert "per_host_only=True" in reason_2
-            assert valid_3 == False
+            assert valid_3 is False
             assert "per_host_only=True" in reason_3
-            assert valid_4 == True
-            assert valid_5 == True
+            assert valid_4 is True
+            assert valid_5 is True
         elif mod_name == "mod_hostport_only":
-            assert valid_1 == True
-            assert valid_2 == False
+            assert valid_1 is True
+            assert valid_2 is False
             assert "per_hostport_only=True" in reason_2
-            assert valid_3 == True
-            assert valid_4 == True
-            assert valid_5 == True
+            assert valid_3 is True
+            assert valid_4 is True
+            assert valid_5 is True
         elif mod_name == "mod_domain_only":
-            assert valid_1 == True
-            assert valid_2 == False
+            assert valid_1 is True
+            assert valid_2 is False
             assert "per_domain_only=True" in reason_2
-            assert valid_3 == False
+            assert valid_3 is False
             assert "per_domain_only=True" in reason_3
-            assert valid_4 == False
+            assert valid_4 is False
             assert "per_domain_only=True" in reason_4
-            assert valid_5 == True
+            assert valid_5 is True
 
     await scan._cleanup()
 
@@ -331,15 +331,15 @@ async def test_modules_basic_perdomainonly(bbot_scanner, monkeypatch):
             valid_1, reason_1 = await module._event_postcheck(url_1)
             valid_2, reason_2 = await module._event_postcheck(url_2)
 
-            if module.per_domain_only == True:
-                assert valid_1 == True
-                assert valid_2 == False
+            if module.per_domain_only is True:
+                assert valid_1 is True
+                assert valid_2 is False
                 assert hash("evilcorp.com") in module._per_host_tracker
                 assert reason_2 == "per_domain_only enabled and already seen domain"
 
             else:
-                assert valid_1 == True
-                assert valid_2 == True
+                assert valid_1 is True
+                assert valid_2 is True
 
     await per_domain_scan._cleanup()
 
@@ -397,7 +397,6 @@ async def test_modules_basic_stats(helpers, events, bbot_scanner, httpx_mock, mo
         "ORG_STUB": 1,
         "URL_UNVERIFIED": 1,
         "FINDING": 1,
-        "ORG_STUB": 1,
     }
 
     assert set(scan.stats.module_stats) == {"speculate", "host", "TARGET", "python", "dummy", "dnsresolve"}

bbot/test/test_step_1/test_presets.py

@@ -16,7 +16,7 @@ from bbot.scanner import Scanner, Preset
 def test_preset_descriptions():
     # ensure very preset has a description
     preset = Preset()
-    for yaml_file, (loaded_preset, category, preset_path, original_filename) in preset.all_presets.items():
+    for (loaded_preset, category, preset_path, original_filename) in preset.all_presets.values():
         assert (
             loaded_preset.description
         ), f'Preset "{loaded_preset.name}" at {original_filename} does not have a description.'
@@ -174,15 +174,15 @@ def test_preset_scope():
 
     # test target merging
     scan = Scanner("1.2.3.4", preset=Preset.from_dict({"target": ["evilcorp.com"]}))
-    assert set([str(h) for h in scan.preset.target.seeds.hosts]) == {"1.2.3.4/32", "evilcorp.com"}
-    assert set([e.data for e in scan.target.seeds]) == {"1.2.3.4", "evilcorp.com"}
-    assert set([e.data for e in scan.target.whitelist]) == {"1.2.3.4", "evilcorp.com"}
+    assert {str(h) for h in scan.preset.target.seeds.hosts} == {"1.2.3.4/32", "evilcorp.com"}
+    assert {e.data for e in scan.target.seeds} == {"1.2.3.4", "evilcorp.com"}
+    assert {e.data for e in scan.target.whitelist} == {"1.2.3.4", "evilcorp.com"}
 
     blank_preset = Preset()
     blank_preset = blank_preset.bake()
     assert not blank_preset.target.seeds
     assert not blank_preset.target.whitelist
-    assert blank_preset.strict_scope == False
+    assert blank_preset.strict_scope is False
 
     preset1 = Preset(
         "evilcorp.com",
@@ -194,13 +194,13 @@ def test_preset_scope():
 
     # make sure target logic works as expected
     assert "evilcorp.com" in preset1_baked.target.seeds
-    assert not "evilcorp.com" in preset1_baked.target.whitelist
+    assert "evilcorp.com" not in preset1_baked.target.whitelist
     assert "asdf.evilcorp.com" in preset1_baked.target.seeds
-    assert not "asdf.evilcorp.com" in preset1_baked.target.whitelist
+    assert "asdf.evilcorp.com" not in preset1_baked.target.whitelist
     assert "asdf.evilcorp.ce" in preset1_baked.whitelist
     assert "evilcorp.ce" in preset1_baked.whitelist
     assert "test.www.evilcorp.ce" in preset1_baked.blacklist
-    assert not "evilcorp.ce" in preset1_baked.blacklist
+    assert "evilcorp.ce" not in preset1_baked.blacklist
     assert preset1_baked.in_scope("www.evilcorp.ce")
     assert not preset1_baked.in_scope("evilcorp.com")
     assert not preset1_baked.in_scope("asdf.test.www.evilcorp.ce")
@@ -228,20 +228,20 @@ def test_preset_scope():
     assert "www.evilcorp.ce" in preset1_baked.target.seeds
     assert "evilcorp.org" in preset1_baked.target.seeds
     # strict scope is enabled
-    assert not "asdf.www.evilcorp.ce" in preset1_baked.target.seeds
-    assert not "asdf.evilcorp.org" in preset1_baked.target.seeds
-    assert not "asdf.evilcorp.com" in preset1_baked.target.seeds
-    assert not "asdf.www.evilcorp.ce" in preset1_baked.target.seeds
+    assert "asdf.www.evilcorp.ce" not in preset1_baked.target.seeds
+    assert "asdf.evilcorp.org" not in preset1_baked.target.seeds
+    assert "asdf.evilcorp.com" not in preset1_baked.target.seeds
+    assert "asdf.www.evilcorp.ce" not in preset1_baked.target.seeds
     assert "evilcorp.ce" in preset1_baked.whitelist
     assert "evilcorp.de" in preset1_baked.whitelist
-    assert not "asdf.evilcorp.de" in preset1_baked.whitelist
-    assert not "asdf.evilcorp.ce" in preset1_baked.whitelist
+    assert "asdf.evilcorp.de" not in preset1_baked.whitelist
+    assert "asdf.evilcorp.ce" not in preset1_baked.whitelist
     # blacklist should be merged, strict scope does not apply
     assert "test.www.evilcorp.ce" in preset1_baked.blacklist
     assert "test.www.evilcorp.de" in preset1_baked.blacklist
     assert "asdf.test.www.evilcorp.ce" in preset1_baked.blacklist
     assert "asdf.test.www.evilcorp.de" in preset1_baked.blacklist
-    assert not "asdf.test.www.evilcorp.org" in preset1_baked.blacklist
+    assert "asdf.test.www.evilcorp.org" not in preset1_baked.blacklist
     # only the base domain of evilcorp.de should be in scope
     assert not preset1_baked.in_scope("evilcorp.com")
     assert not preset1_baked.in_scope("evilcorp.org")
@@ -290,7 +290,7 @@ def test_preset_scope():
     assert not preset_nowhitelist_baked.in_scope("1.2.3.4/24")
 
     assert "www.evilcorp.org" in preset_whitelist_baked.target.seeds
-    assert not "www.evilcorp.org" in preset_whitelist_baked.target.whitelist
+    assert "www.evilcorp.org" not in preset_whitelist_baked.target.whitelist
     assert "1.2.3.4" in preset_whitelist_baked.whitelist
     assert not preset_whitelist_baked.in_scope("www.evilcorp.org")
     assert not preset_whitelist_baked.in_scope("www.evilcorp.de")
@@ -303,15 +303,15 @@ def test_preset_scope():
     assert preset_whitelist_baked.whitelisted("1.2.3.4/28")
     assert preset_whitelist_baked.whitelisted("1.2.3.4/24")
 
-    assert set([e.data for e in preset_nowhitelist_baked.seeds]) == {"evilcorp.com"}
-    assert set([e.data for e in preset_nowhitelist_baked.whitelist]) == {"evilcorp.com"}
-    assert set([e.data for e in preset_whitelist_baked.seeds]) == {"evilcorp.org"}
-    assert set([e.data for e in preset_whitelist_baked.whitelist]) == {"1.2.3.0/24", "http://evilcorp.net/"}
+    assert {e.data for e in preset_nowhitelist_baked.seeds} == {"evilcorp.com"}
+    assert {e.data for e in preset_nowhitelist_baked.whitelist} == {"evilcorp.com"}
+    assert {e.data for e in preset_whitelist_baked.seeds} == {"evilcorp.org"}
+    assert {e.data for e in preset_whitelist_baked.whitelist} == {"1.2.3.0/24", "http://evilcorp.net/"}
 
     preset_nowhitelist.merge(preset_whitelist)
     preset_nowhitelist_baked = preset_nowhitelist.bake()
-    assert set([e.data for e in preset_nowhitelist_baked.seeds]) == {"evilcorp.com", "evilcorp.org"}
-    assert set([e.data for e in preset_nowhitelist_baked.whitelist]) == {"1.2.3.0/24", "http://evilcorp.net/"}
+    assert {e.data for e in preset_nowhitelist_baked.seeds} == {"evilcorp.com", "evilcorp.org"}
+    assert {e.data for e in preset_nowhitelist_baked.whitelist} == {"1.2.3.0/24", "http://evilcorp.net/"}
     assert "www.evilcorp.org" in preset_nowhitelist_baked.seeds
     assert "www.evilcorp.com" in preset_nowhitelist_baked.seeds
     assert "1.2.3.4" in preset_nowhitelist_baked.whitelist
@@ -325,12 +325,12 @@ def test_preset_scope():
     preset_whitelist = Preset("evilcorp.org", whitelist=["1.2.3.4/24"])
     preset_whitelist.merge(preset_nowhitelist)
     preset_whitelist_baked = preset_whitelist.bake()
-    assert set([e.data for e in preset_whitelist_baked.seeds]) == {"evilcorp.com", "evilcorp.org"}
-    assert set([e.data for e in preset_whitelist_baked.whitelist]) == {"1.2.3.0/24"}
+    assert {e.data for e in preset_whitelist_baked.seeds} == {"evilcorp.com", "evilcorp.org"}
+    assert {e.data for e in preset_whitelist_baked.whitelist} == {"1.2.3.0/24"}
     assert "www.evilcorp.org" in preset_whitelist_baked.seeds
     assert "www.evilcorp.com" in preset_whitelist_baked.seeds
-    assert not "www.evilcorp.org" in preset_whitelist_baked.target.whitelist
-    assert not "www.evilcorp.com" in preset_whitelist_baked.target.whitelist
+    assert "www.evilcorp.org" not in preset_whitelist_baked.target.whitelist
+    assert "www.evilcorp.com" not in preset_whitelist_baked.target.whitelist
     assert "1.2.3.4" in preset_whitelist_baked.whitelist
     assert not preset_whitelist_baked.in_scope("www.evilcorp.org")
     assert not preset_whitelist_baked.in_scope("www.evilcorp.com")
@@ -342,16 +342,16 @@ def test_preset_scope():
     preset_nowhitelist2 = Preset("evilcorp.de")
     preset_nowhitelist1_baked = preset_nowhitelist1.bake()
     preset_nowhitelist2_baked = preset_nowhitelist2.bake()
-    assert set([e.data for e in preset_nowhitelist1_baked.seeds]) == {"evilcorp.com"}
-    assert set([e.data for e in preset_nowhitelist2_baked.seeds]) == {"evilcorp.de"}
-    assert set([e.data for e in preset_nowhitelist1_baked.whitelist]) == {"evilcorp.com"}
-    assert set([e.data for e in preset_nowhitelist2_baked.whitelist]) == {"evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist1_baked.seeds} == {"evilcorp.com"}
+    assert {e.data for e in preset_nowhitelist2_baked.seeds} == {"evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist1_baked.whitelist} == {"evilcorp.com"}
+    assert {e.data for e in preset_nowhitelist2_baked.whitelist} == {"evilcorp.de"}
     preset_nowhitelist1.merge(preset_nowhitelist2)
     preset_nowhitelist1_baked = preset_nowhitelist1.bake()
-    assert set([e.data for e in preset_nowhitelist1_baked.seeds]) == {"evilcorp.com", "evilcorp.de"}
-    assert set([e.data for e in preset_nowhitelist2_baked.seeds]) == {"evilcorp.de"}
-    assert set([e.data for e in preset_nowhitelist1_baked.whitelist]) == {"evilcorp.com", "evilcorp.de"}
-    assert set([e.data for e in preset_nowhitelist2_baked.whitelist]) == {"evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist1_baked.seeds} == {"evilcorp.com", "evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist2_baked.seeds} == {"evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist1_baked.whitelist} == {"evilcorp.com", "evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist2_baked.whitelist} == {"evilcorp.de"}
     assert "www.evilcorp.com" in preset_nowhitelist1_baked.seeds
     assert "www.evilcorp.de" in preset_nowhitelist1_baked.seeds
     assert "www.evilcorp.com" in preset_nowhitelist1_baked.target.seeds
@@ -370,10 +370,10 @@ def test_preset_scope():
     preset_nowhitelist2.merge(preset_nowhitelist1)
     preset_nowhitelist1_baked = preset_nowhitelist1.bake()
     preset_nowhitelist2_baked = preset_nowhitelist2.bake()
-    assert set([e.data for e in preset_nowhitelist1_baked.seeds]) == {"evilcorp.com"}
-    assert set([e.data for e in preset_nowhitelist2_baked.seeds]) == {"evilcorp.com", "evilcorp.de"}
-    assert set([e.data for e in preset_nowhitelist1_baked.whitelist]) == {"evilcorp.com"}
-    assert set([e.data for e in preset_nowhitelist2_baked.whitelist]) == {"evilcorp.com", "evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist1_baked.seeds} == {"evilcorp.com"}
+    assert {e.data for e in preset_nowhitelist2_baked.seeds} == {"evilcorp.com", "evilcorp.de"}
+    assert {e.data for e in preset_nowhitelist1_baked.whitelist} == {"evilcorp.com"}
+    assert {e.data for e in preset_nowhitelist2_baked.whitelist} == {"evilcorp.com", "evilcorp.de"}
 
 
 @pytest.mark.asyncio
@@ -387,30 +387,30 @@ async def test_preset_logging():
 
     try:
         silent_preset = Preset(silent=True)
-        assert silent_preset.silent == True
-        assert silent_preset.debug == False
-        assert silent_preset.verbose == False
+        assert silent_preset.silent is True
+        assert silent_preset.debug is False
+        assert silent_preset.verbose is False
         assert original_log_level == CORE.logger.log_level
         debug_preset = Preset(debug=True)
-        assert debug_preset.silent == False
-        assert debug_preset.debug == True
-        assert debug_preset.verbose == False
+        assert debug_preset.silent is False
+        assert debug_preset.debug is True
+        assert debug_preset.verbose is False
         assert original_log_level == CORE.logger.log_level
         verbose_preset = Preset(verbose=True)
-        assert verbose_preset.silent == False
-        assert verbose_preset.debug == False
-        assert verbose_preset.verbose == True
+        assert verbose_preset.silent is False
+        assert verbose_preset.debug is False
+        assert verbose_preset.verbose is True
         assert original_log_level == CORE.logger.log_level
 
         # test conflicting verbosity levels
         silent_and_verbose = Preset(silent=True, verbose=True)
-        assert silent_and_verbose.silent == True
-        assert silent_and_verbose.debug == False
-        assert silent_and_verbose.verbose == True
+        assert silent_and_verbose.silent is True
+        assert silent_and_verbose.debug is False
+        assert silent_and_verbose.verbose is True
         baked = silent_and_verbose.bake()
-        assert baked.silent == True
-        assert baked.debug == False
-        assert baked.verbose == False
+        assert baked.silent is True
+        assert baked.debug is False
+        assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
         baked = silent_and_verbose.bake(scan=scan)
         assert baked.core.logger.log_level == logging.CRITICAL
@@ -420,13 +420,13 @@ async def test_preset_logging():
         assert CORE.logger.log_level == original_log_level
 
         silent_and_debug = Preset(silent=True, debug=True)
-        assert silent_and_debug.silent == True
-        assert silent_and_debug.debug == True
-        assert silent_and_debug.verbose == False
+        assert silent_and_debug.silent is True
+        assert silent_and_debug.debug is True
+        assert silent_and_debug.verbose is False
         baked = silent_and_debug.bake()
-        assert baked.silent == True
-        assert baked.debug == False
-        assert baked.verbose == False
+        assert baked.silent is True
+        assert baked.debug is False
+        assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
         baked = silent_and_debug.bake(scan=scan)
         assert baked.core.logger.log_level == logging.CRITICAL
@@ -436,13 +436,13 @@ async def test_preset_logging():
         assert CORE.logger.log_level == original_log_level
 
         debug_and_verbose = Preset(verbose=True, debug=True)
-        assert debug_and_verbose.silent == False
-        assert debug_and_verbose.debug == True
-        assert debug_and_verbose.verbose == True
+        assert debug_and_verbose.silent is False
+        assert debug_and_verbose.debug is True
+        assert debug_and_verbose.verbose is True
         baked = debug_and_verbose.bake()
-        assert baked.silent == False
-        assert baked.debug == True
-        assert baked.verbose == False
+        assert baked.silent is False
+        assert baked.debug is True
+        assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
         baked = debug_and_verbose.bake(scan=scan)
         assert baked.core.logger.log_level == logging.DEBUG
@@ -452,13 +452,13 @@ async def test_preset_logging():
         assert CORE.logger.log_level == original_log_level
 
         all_preset = Preset(verbose=True, debug=True, silent=True)
-        assert all_preset.silent == True
-        assert all_preset.debug == True
-        assert all_preset.verbose == True
+        assert all_preset.silent is True
+        assert all_preset.debug is True
+        assert all_preset.verbose is True
         baked = all_preset.bake()
-        assert baked.silent == True
-        assert baked.debug == False
-        assert baked.verbose == False
+        assert baked.silent is True
+        assert baked.debug is False
+        assert baked.verbose is False
         assert baked.core.logger.log_level == original_log_level
         baked = all_preset.bake(scan=scan)
         assert baked.core.logger.log_level == logging.CRITICAL
@@ -688,7 +688,7 @@ class TestModule5(BaseModule):
         )
 
     preset = Preset.from_yaml_string(
-        f"""
+        """
 modules:
   - testmodule5
 """
@@ -896,9 +896,9 @@ def test_preset_require_exclude():
     dnsbrute_flags = preset.preloaded_module("dnsbrute").get("flags", [])
     assert "subdomain-enum" in dnsbrute_flags
     assert "active" in dnsbrute_flags
-    assert not "passive" in dnsbrute_flags
+    assert "passive" not in dnsbrute_flags
     assert "aggressive" in dnsbrute_flags
-    assert not "safe" in dnsbrute_flags
+    assert "safe" not in dnsbrute_flags
     assert "dnsbrute" in [x[0] for x in module_flags]
     assert "certspotter" in [x[0] for x in module_flags]
     assert "c99" in [x[0] for x in module_flags]
@@ -912,7 +912,7 @@ def test_preset_require_exclude():
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
     assert "chaos" in [x[0] for x in module_flags]
-    assert not "httpx" in [x[0] for x in module_flags]
+    assert "httpx" not in [x[0] for x in module_flags]
     assert all("passive" in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)
@@ -923,7 +923,7 @@ def test_preset_require_exclude():
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
     assert "chaos" in [x[0] for x in module_flags]
-    assert not "httpx" in [x[0] for x in module_flags]
+    assert "httpx" not in [x[0] for x in module_flags]
     assert all("passive" in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)
@@ -933,7 +933,7 @@ def test_preset_require_exclude():
     preset = Preset(flags=["subdomain-enum"], exclude_modules=["dnsbrute"]).bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
-    assert not "dnsbrute" in [x[0] for x in module_flags]
+    assert "dnsbrute" not in [x[0] for x in module_flags]
     assert "httpx" in [x[0] for x in module_flags]
     assert any("passive" in flags for module, flags in module_flags)
     assert any("active" in flags for module, flags in module_flags)
@@ -944,7 +944,7 @@ def test_preset_require_exclude():
     preset = Preset(flags=["subdomain-enum"], require_flags=["safe", "passive"]).bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
-    assert not "dnsbrute" in [x[0] for x in module_flags]
+    assert "dnsbrute" not in [x[0] for x in module_flags]
     assert all("passive" in flags and "safe" in flags for module, flags in module_flags)
     assert all("active" not in flags and "aggressive" not in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
@@ -954,7 +954,7 @@ def test_preset_require_exclude():
     preset = Preset(flags=["subdomain-enum"], exclude_flags=["aggressive", "active"]).bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
-    assert not "dnsbrute" in [x[0] for x in module_flags]
+    assert "dnsbrute" not in [x[0] for x in module_flags]
     assert all("passive" in flags and "safe" in flags for module, flags in module_flags)
     assert all("active" not in flags and "aggressive" not in flags for module, flags in module_flags)
     assert not any("active" in flags for module, flags in module_flags)
@@ -964,9 +964,9 @@ def test_preset_require_exclude():
     preset = Preset(flags=["subdomain-enum"], exclude_modules=["dnsbrute", "c99"]).bake()
     assert len(preset.modules) > 25
     module_flags = list(get_module_flags(preset))
-    assert not "dnsbrute" in [x[0] for x in module_flags]
+    assert "dnsbrute" not in [x[0] for x in module_flags]
     assert "certspotter" in [x[0] for x in module_flags]
-    assert not "c99" in [x[0] for x in module_flags]
+    assert "c99" not in [x[0] for x in module_flags]
     assert any("passive" in flags for module, flags in module_flags)
     assert any("active" in flags for module, flags in module_flags)
     assert any("safe" in flags for module, flags in module_flags)

bbot/test/test_step_1/test_regexes.py

@@ -91,7 +91,7 @@ def test_ip_regexes():
                     ip == "2001:db8::1/128" and event_type == "IP_RANGE"
                 ), f"Event type for IP_ADDRESS {ip} was not properly detected"
         else:
-            matches = list(r.match(ip) for r in ip_address_regexes)
+            matches = [r.match(ip) for r in ip_address_regexes]
             assert any(matches), f"Good IP ADDRESS {ip} did not match regexes"
 
 
@@ -138,7 +138,7 @@ def test_ip_range_regexes():
             pytest.fail(f"BAD IP_RANGE: {bad_ip_range} raised unknown error: {e}: {traceback.format_exc()}")
 
     for good_ip_range in good_ip_ranges:
-        matches = list(r.match(good_ip_range) for r in ip_range_regexes)
+        matches = [r.match(good_ip_range) for r in ip_range_regexes]
         assert any(matches), f"Good IP_RANGE {good_ip_range} did not match regexes"
 
 
@@ -191,7 +191,7 @@ def test_dns_name_regexes():
             pytest.fail(f"BAD DNS NAME: {dns} raised unknown error: {e}")
 
     for dns in good_dns:
-        matches = list(r.match(dns) for r in dns_name_regexes)
+        matches = [r.match(dns) for r in dns_name_regexes]
         assert any(matches), f"Good DNS_NAME {dns} did not match regexes"
         event_type, _ = get_event_type(dns)
         if not event_type == "DNS_NAME":
@@ -253,7 +253,7 @@ def test_open_port_regexes():
             pytest.fail(f"BAD OPEN_TCP_PORT: {open_port} raised unknown error: {e}")
 
     for open_port in good_ports:
-        matches = list(r.match(open_port) for r in open_port_regexes)
+        matches = [r.match(open_port) for r in open_port_regexes]
         assert any(matches), f"Good OPEN_TCP_PORT {open_port} did not match regexes"
         event_type, _ = get_event_type(open_port)
         assert event_type == "OPEN_TCP_PORT"
@@ -318,7 +318,7 @@ def test_url_regexes():
             pytest.fail(f"BAD URL: {bad_url} raised unknown error: {e}: {traceback.format_exc()}")
 
     for good_url in good_urls:
-        matches = list(r.match(good_url) for r in url_regexes)
+        matches = [r.match(good_url) for r in url_regexes]
         assert any(matches), f"Good URL {good_url} did not match regexes"
         assert (
             get_event_type(good_url)[0] == "URL_UNVERIFIED"

bbot/test/test_step_1/test_scan.py

@@ -100,13 +100,13 @@ async def test_url_extension_handling(bbot_scanner):
     assert "blacklisted" not in bad_event.tags
     assert "httpx-only" not in httpx_event.tags
     result = await scan.ingress_module.handle_event(good_event)
-    assert result == None
+    assert result is None
     result, reason = await scan.ingress_module.handle_event(bad_event)
-    assert result == False
+    assert result is False
     assert reason == "event is blacklisted"
     assert "blacklisted" in bad_event.tags
     result = await scan.ingress_module.handle_event(httpx_event)
-    assert result == None
+    assert result is None
     assert "httpx-only" in httpx_event.tags
 
     await scan._cleanup()
@@ -144,7 +144,7 @@ async def test_python_output_matches_json(bbot_scanner):
     assert len(events) == 5
     scan_events = [e for e in events if e["type"] == "SCAN"]
     assert len(scan_events) == 2
-    assert all([isinstance(e["data"]["status"], str) for e in scan_events])
+    assert all(isinstance(e["data"]["status"], str) for e in scan_events)
     assert len([e for e in events if e["type"] == "DNS_NAME"]) == 1
     assert len([e for e in events if e["type"] == "ORG_STUB"]) == 1
     assert len([e for e in events if e["type"] == "IP_ADDRESS"]) == 1