runner: use same require checks in filters as main test

Re-use the requirements checking code from the test case in the
per-test filters.  This means all requirements like lt-version,
etc are available at the filter level.

diff --git a/run.py b/run.py
index 10c5171b496bb57e3463107e945d21fee5e70d4c..7944e3d03fe934f95a02930bf458e5876d5ff31f 100755 (executable)
--- a/run.py
+++ b/run.py
@@ -257,6 +257,57 @@ class SuricataConfig:
     def has_feature(self, feature):
         return feature in self.features
 
+
+def check_requires(requires, suricata_config: SuricataConfig):
+    suri_version = suricata_config.version
+    for key in requires:
+        if key == "min-version":
+            min_version = requires["min-version"]
+            if not is_version_compatible(version=min_version,
+                    suri_version=suri_version, expr="gte"):
+                raise UnsatisfiedRequirementError(
+                        "requires at least version {}".format(min_version))
+        elif key == "lt-version":
+            lt_version = requires["lt-version"]
+            if not is_version_compatible(version=lt_version,
+                    suri_version=suri_version, expr="lt"):
+                raise UnsatisfiedRequirementError(
+                        "for version less than {}".format(lt_version))
+        elif key == "version":
+            req_version = requires["version"]
+            if not is_version_compatible(version=req_version,
+                    suri_version=suri_version, expr="equal"):
+                raise UnsatisfiedRequirementError(
+                        "only for version {}".format(req_version))
+        elif key == "features":
+            for feature in requires["features"]:
+                if not suricata_config.has_feature(feature):
+                    raise UnsatisfiedRequirementError(
+                        "requires feature %s" % (feature))
+        elif key == "env":
+            for env in requires["env"]:
+                if not env in os.environ:
+                    raise UnsatisfiedRequirementError(
+                        "requires env var %s" % (env))
+        elif key == "files":
+            for filename in requires["files"]:
+                if not os.path.exists(filename):
+                    raise UnsatisfiedRequirementError(
+                        "requires file %s" % (filename))
+        elif key == "script":
+            for script in requires["script"]:
+                try:
+                    subprocess.check_call("%s" % script, shell=True)
+                except:
+                    raise UnsatisfiedRequirementError(
+                        "requires script returned false")
+        elif key == "pcap":
+            # Handle below...
+            pass
+        else:
+            raise Exception("unknown requires types: %s" % (key))
+
+
 def find_value(name, obj):
     """Find the value in an object for a field specified by name.
 
@@ -371,22 +422,18 @@ class FilterCheck:
         self.suri_version = suricata_config.version
 
     def run(self):
+        requires = self.config.get("requires", {})
         req_version = self.config.get("version")
         min_version = self.config.get("min-version")
-        expr = "equal" if req_version else "gte"
-        if (req_version == None) ^ (min_version == None):
-            version = req_version or min_version
-            if not is_version_compatible(version=version,
-                    suri_version=self.suri_version, expr=expr):
-                raise UnsatisfiedRequirementError(
-                        "Suricata v{} not found".format(version))
-        elif req_version and min_version:
-            raise TestError("Specify either min-version or version")
+        if req_version is not None:
+            requires["version"] = req_version
+        if min_version is not None:
+            requires["min-version"] = min_version
         feature = self.config.get("feature")
-        if feature != None:
-            if not self.suricata_config.has_feature(feature):
-                raise UnsatisfiedRequirementError(
-                                                  "Suricata feature {} not present".format(feature))
+        if feature is not None:
+            requires["features"] = [feature]
+        check_requires(requires, self.suricata_config)
+
         if "filename" in self.config:
             json_filename = self.config["filename"]
         else:
@@ -503,64 +550,8 @@ class TestRunner:
                                         key, need_val))
 
     def check_requires(self):
-        if "requires" in self.config:
-            requires = self.config["requires"]
-            if not requires:
-                return True
-        else:
-            requires = {}
-        suri_version = self.suricata_config.version
-        for key in requires:
-            if key == "min-version":
-                min_version = requires["min-version"]
-                if not is_version_compatible(version=min_version,
-                        suri_version=suri_version, expr="gte"):
-                    raise UnsatisfiedRequirementError(
-                            "requires at least version {}".format(min_version))
-            elif key == "lt-version":
-                lt_version = requires["lt-version"]
-                if not is_version_compatible(version=lt_version,
-                        suri_version=suri_version, expr="lt"):
-                    raise UnsatisfiedRequirementError(
-                            "for version less than {}".format(lt_version))
-            elif key == "version":
-                req_version = requires["version"]
-                if not is_version_compatible(version=req_version,
-                        suri_version=suri_version, expr="equal"):
-                    raise UnsatisfiedRequirementError(
-                            "only for version {}".format(req_version))
-            elif key == "features":
-                for feature in requires["features"]:
-                    if not self.suricata_config.has_feature(feature):
-                        raise UnsatisfiedRequirementError(
-                            "requires feature %s" % (feature))
-
-            elif key == "env":
-                for env in requires["env"]:
-                    if not env in os.environ:
-                        raise UnsatisfiedRequirementError(
-                            "requires env var %s" % (env))
-
-            elif key == "files":
-                for filename in requires["files"]:
-                    if not os.path.exists(filename):
-                        raise UnsatisfiedRequirementError(
-                            "requires file %s" % (filename))
-
-            elif key == "script":
-                for script in requires["script"]:
-                    try:
-                        subprocess.check_call("%s" % script, shell=True)
-                    except:
-                        raise UnsatisfiedRequirementError(
-                            "requires script returned false")
-
-            elif key == "pcap":
-                # Handle below...
-                pass
-
-            else:
-                raise Exception("unknown requires types: %s" % (key))
+        requires = self.config.get("requires", {})
+        check_requires(requires, self.suricata_config)
 
         # Check if a pcap is required or not. By default a pcap is
         # required unless a "command" has been provided.