chore: remove redundant snapshot version check for old FC versions

The snapshot version check was iterating over last several FC versions
pulled from S3, but it was unnecessary since there were no cross FC
checks. Remove checks of old FC versions and only test the current
version.

Signed-off-by: Egor Lazarchuk <yegorlz@amazon.co.uk>

Author: ShadowCurse

tests/framework/artifacts.py

@@ -4,16 +4,12 @@
 """Define classes for interacting with CI artifacts"""
 
 import re
-from dataclasses import dataclass
 from pathlib import Path
 from typing import Iterator
 
 import pytest
 
 from framework.defs import ARTIFACT_DIR
-from framework.utils import check_output, get_firecracker_version_from_toml
-from framework.with_filelock import with_filelock
-from host_tools.cargo_build import get_binary
 
 
 def select_supported_kernels():
@@ -55,101 +51,3 @@ def kernel_params(
     """Return supported kernels"""
     for kernel in select(glob, artifact_dir):
         yield pytest.param(kernel, id=kernel.name)
-
-
-@dataclass(frozen=True, repr=True)
-class FirecrackerArtifact:
-    """Utility class for Firecracker binary artifacts."""
-
-    path: Path
-
-    @property
-    def name(self):
-        """Get the Firecracker name."""
-        return self.path.name
-
-    @property
-    def jailer(self):
-        """Get the jailer with the same version."""
-        return self.path.with_name(f"jailer-v{self.version}")
-
-    @property
-    def version(self):
-        """Return Firecracker's version: `X.Y.Z-prerelase`."""
-        # Get the filename, split on the first '-' and trim the leading 'v'.
-        # sample: firecracker-v1.2.0-alpha
-        return self.path.name.split("-", 1)[1][1:]
-
-    @property
-    def version_tuple(self):
-        """Return the artifact's version as a tuple `(X, Y, Z)`."""
-        return tuple(int(x) for x in self.version.split("."))
-
-    @property
-    def snapshot_version_tuple(self):
-        """Return the artifact's snapshot version as a tuple: `X.Y.0`."""
-
-        # Starting from Firecracker v1.7.0, snapshots have their own version that is
-        # independent of Firecracker versions. For these Firecracker versions, use
-        # the --snapshot-version Firecracker flag, to figure out which snapshot version
-        # it supports.
-
-        return (
-            check_output([self.path, "--snapshot-version"])
-            .stdout.strip()
-            .split("\n")[0]
-            .split(".")
-        )
-
-    @property
-    def snapshot_version(self):
-        """Return the artifact's snapshot version: `X.Y.0`.
-
-        Due to how Firecracker maps release versions to snapshot versions, we
-        have to request the minor version instead of the actual version.
-        """
-        return ".".join(str(x) for x in self.snapshot_version_tuple)
-
-
-@with_filelock
-def current_release(version):
-    """Massage this working copy Firecracker binary to look like a normal
-    release, so it can run the same tests.
-    """
-    binaries = []
-    for binary in ["firecracker", "jailer"]:
-        bin_path1 = get_binary(binary)
-        bin_path2 = bin_path1.with_name(f"{binary}-v{version}")
-        if not bin_path2.exists():
-            bin_path2.unlink(missing_ok=True)
-            bin_path2.hardlink_to(bin_path1)
-        binaries.append(bin_path2)
-    return binaries
-
-
-def working_version_as_artifact():
-    """
-    Return working copy of Firecracker as a release artifact
-    """
-    cargo_version = get_firecracker_version_from_toml()
-    return FirecrackerArtifact(current_release(str(cargo_version))[0])
-
-
-def firecracker_artifacts():
-    """Return all supported firecracker binaries."""
-    cargo_version = get_firecracker_version_from_toml()
-    # until the next minor version (but *not* including)
-    max_version = (cargo_version.major, cargo_version.minor + 1, 0)
-    prefix = "firecracker/firecracker-*"
-    for firecracker in sorted(ARTIFACT_DIR.glob(prefix)):
-        match = re.match(r"firecracker-v(\d+)\.(\d+)\.(\d+)", firecracker.name)
-        if not match:
-            continue
-        fc = FirecrackerArtifact(firecracker)
-        version = fc.version_tuple
-        if version >= max_version:
-            continue
-        yield pytest.param(fc, id=fc.name)
-
-    fc = working_version_as_artifact()
-    yield pytest.param(fc, id=fc.name)

tests/integration_tests/functional/conftest.py

@@ -11,39 +11,30 @@
 from host_tools.fcmetrics import validate_fc_metrics
 
 
-def test_describe_snapshot_all_versions(
-    microvm_factory, guest_kernel, rootfs, firecracker_release
-):
+def test_describe_snapshot(uvm_plain):
     """
     Test `--describe-snapshot` correctness for all snapshot versions.
 
     For each release create a snapshot and verify the data version of the
     snapshot state file.
     """
 
-    target_version = firecracker_release.snapshot_version
-    vm = microvm_factory.build(
-        guest_kernel,
-        rootfs,
-        fc_binary_path=firecracker_release.path,
-        jailer_binary_path=firecracker_release.jailer,
-    )
-    # FIXME: Once only FC versions >= 1.12 are supported, drop log_level="warn"
-    vm.spawn(log_level="warn", serial_out_path=None)
+    vm = uvm_plain
+    fc_binary = vm.fc_binary_path
+
+    cmd = [fc_binary, "--snapshot-version"]
+    snap_version_tuple = check_output(cmd).stdout.strip().split("\n")[0].split(".")
+    snap_version = ".".join(str(x) for x in snap_version_tuple)
+
     vm.basic_config(track_dirty_pages=True)
     vm.start()
     snapshot = vm.snapshot_diff()
-    print("========== Firecracker create snapshot log ==========")
-    print(vm.log_data)
     vm.kill()
 
-    # Fetch Firecracker binary
-    fc_binary = microvm_factory.fc_binary_path
-    # Verify the output of `--describe-snapshot` command line parameter
-    cmd = [fc_binary] + ["--describe-snapshot", snapshot.vmstate]
+    cmd = [fc_binary, "--describe-snapshot", snapshot.vmstate]
     _, stdout, stderr = check_output(cmd)
     assert stderr == ""
-    assert target_version in stdout
+    assert snap_version in stdout
 
 
 def test_cli_metrics_path(uvm_plain):