Merge ~jslarraz/review-tools:refactor-add-containers into review-tools:master

[Jorge Sancho Larraz]

reviewtools refactor: add containers

While implementing component support for reviewtools, I found that reviewtools does not support very well this case, as only one element can be unpacked at once (either the snap or the component) because of how it works (mainly the use of global variables to define unpacked directories)

To improve this situation we agreed to refactor reviewtools with the purpose to make it easier to understand, more flexible, and easier to develop new test cases. In this line, this PR add three helper classes and the minimal changes to make checks to work using these helpers. Updated documentation about helper classes can be temporary found [https://filedn.eu/lOxBQCyCbXcHUoPLsWyQKUk/reviewtools/containers/](https://filedn.eu/lOxBQCyCbXcHUoPLsWyQKUk/reviewtools/containers/) until it finds its final location

9083b00... by Jorge Sancho Larraz on 2024-05-08

Run black on container files

fffd80e... by Jorge Sancho Larraz on 2024-05-08

Remove Review class instead of commenting to simplify review

9fe6510... by Jorge Sancho Larraz on 2024-05-08

Move constant definitions back to common.py to make pr easier to review

[Jorge Sancho Larraz (jslarraz)]

PR simplified a bit and inline comments added to make the review easier. I think it should be possible to split this PR in several if it help to make it through

Unmerged commits

9fe6510... by Jorge Sancho Larraz on 2024-05-08

Move constant definitions back to common.py to make pr easier to review

	test:0 (build)
	coverage:0 (build)

1 → 2 of 2 results

First • Previous • Next • Last

fffd80e... by Jorge Sancho Larraz on 2024-05-08

Remove Review class instead of commenting to simplify review

9083b00... by Jorge Sancho Larraz on 2024-05-08

Run black on container files

8246e58... by Jorge Sancho Larraz on 2024-03-19

Update review classes to use new containers

2d9987a... by Jorge Sancho Larraz on 2024-03-15

Add BaseContainer SquashfsContainer SnapContainer and relative tests

diff --git a/reviewtools/common.py b/reviewtools/common.py
index f46149b..9ed2fd9 100644
--- a/reviewtools/common.py
+++ b/reviewtools/common.py
@@ -23,7 +23,6 @@ import glob
 import inspect
 import json
 import logging
-import magic
 import os
 from pkg_resources import resource_filename
 import re
@@ -351,163 +350,6 @@ class ReviewBase(object):
         self.review_type = name
 
 
-class Review(ReviewBase):
-    """Common review class"""
-
-    magic_binary_file_descriptions = [
-        "application/x-executable; charset=binary",
-        "application/x-sharedlib; charset=binary",
-        "application/x-object; charset=binary",
-        # 18.04 and higher doesn't show the charset
-        "application/x-executable",
-        "application/x-sharedlib",
-        "application/x-object",
-        "application/x-pie-executable",
-    ]
-
-    def __init__(self, fn, review_type, overrides=None):
-        ReviewBase.__init__(self, review_type, overrides)
-
-        self.pkg_filename = fn
-        self._check_package_exists()
-
-        global MKDTEMP_DIR
-        if (
-            MKDTEMP_DIR is None
-            and "SNAP_USER_COMMON" in os.environ
-            and os.path.exists(os.environ["SNAP_USER_COMMON"])
-        ):
-            MKDTEMP_DIR = os.environ["SNAP_USER_COMMON"]
-
-        global UNPACK_DIR
-        if UNPACK_DIR is None:
-            UNPACK_DIR = unpack_pkg(fn)
-        self.unpack_dir = UNPACK_DIR
-
-        # unpack_pkg() now only supports snap v2, so just hardcode these
-        self.is_snap2 = True
-        self.pkgfmt = {"type": "snap", "version": "16.04"}
-
-        global RAW_UNPACK_DIR
-        if RAW_UNPACK_DIR is None:
-            RAW_UNPACK_DIR = raw_unpack_pkg(fn)
-        self.raw_unpack_dir = RAW_UNPACK_DIR
-
-        # Get a list of all unpacked files
-        self.pkg_files = []
-        # self._list_all_files() sets self.pkg_files so we can mock it
-        self._list_all_files()
-
-        # Setup what is needed to get a list of all unpacked compiled binaries
-        self.pkg_bin_files = []
-        # self._list_all_compiled_binaries() sets self.pkg_files so we can
-        # mock it
-        self._list_all_compiled_binaries()
-
-    def _check_innerpath_executable(self, fn):
-        """Check that the provided path exists and is executable"""
-        return os.access(fn, os.X_OK)
-
-    def _extract_statinfo(self, fn):
-        """Extract statinfo from file"""
-        try:
-            st = os.stat(fn)
-        except Exception:
-            return None
-        return st
-
-    def _extract_file(self, fn):
-        """Extract file"""
-        if not fn.startswith("/"):
-            error("_extract_file() expects absolute path")
-        rel = os.path.relpath(fn, self.unpack_dir)
-
-        if not os.path.isfile(fn):
-            error("Could not find '%s'" % rel)
-        return open_file_read(fn)
-
-    def _path_join(self, dirname, rest):
-        return os.path.join(dirname, rest)
-
-    def _get_sha512sum(self, fn):
-        """Get sha512sum of file"""
-        (rc, out) = cmd(["sha512sum", fn])
-        if rc != 0:
-            return None
-        return out.split()[0]
-
-    def _pkgfmt_type(self):
-        """Return the package format type"""
-        if "type" not in self.pkgfmt:
-            return ""
-        return self.pkgfmt["type"]
-
-    def _pkgfmt_version(self):
-        """Return the package format version"""
-        if "version" not in self.pkgfmt:
-            return ""
-        return self.pkgfmt["version"]
-
-    def _check_package_exists(self):
-        """Check that the provided package exists"""
-        if not os.path.exists(self.pkg_filename):
-            error("Could not find '%s'" % self.pkg_filename)
-
-    def _list_all_files(self):
-        """List all files included in this package."""
-        global PKG_FILES
-        if PKG_FILES is None:
-            PKG_FILES = []
-            for root, dirnames, filenames in os.walk(self.unpack_dir):
-                for f in filenames:
-                    PKG_FILES.append(os.path.join(root, f))
-
-        self.pkg_files = PKG_FILES
-
-    def _check_if_message_catalog(self, fn):
-        """Check if file is a message catalog (.mo file)."""
-        if fn.endswith(".mo"):
-            return True
-        return False
-
-    def _list_all_compiled_binaries(self):
-        """List all compiled binaries in this package."""
-        global PKG_BIN_FILES
-        if PKG_BIN_FILES is None:
-            self.mime = magic.open(magic.MAGIC_MIME)
-            self.mime.load()
-            PKG_BIN_FILES = []
-            for i in self.pkg_files:
-                try:
-                    res = self.mime.file(i)
-                except Exception:  # pragma: nocover
-                    # workaround for zesty python3-magic
-                    debug("could not detemine mime type of '%s'" % i)
-                    continue
-
-                if (
-                    res in self.magic_binary_file_descriptions
-                    and not self._check_if_message_catalog(i)
-                    and i not in PKG_BIN_FILES
-                ):
-                    PKG_BIN_FILES.append(i)
-
-        self.pkg_bin_files = PKG_BIN_FILES
-
-    def _verify_pkgversion(self, v):
-        """Verify package name"""
-        if not isinstance(v, (str, int, float)):
-            return False
-        re_valid_version = re.compile(
-            r"^((\d+):)?"  # epoch
-            "([A-Za-z0-9.+:~-]+?)"  # upstream
-            "(-([A-Za-z0-9+.~]+))?$"
-        )  # debian
-        if re_valid_version.match(str(v)):
-            return True
-        return False
-
-
 #
 # Utility functions
 #
@@ -519,7 +361,7 @@ def error(out, exit_code=1, do_exit=True, output_type=None):
     global RESULT_TYPES
 
     if output_type is not None:
-        Review.set_report_type(None, output_type)
+        ReviewBase.set_report_type(None, output_type)
 
     try:
         if REPORT_OUTPUT == "json":
diff --git a/reviewtools/containers/__init__.py b/reviewtools/containers/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/reviewtools/containers/__init__.py
diff --git a/reviewtools/containers/base_container.py b/reviewtools/containers/base_container.py
new file mode 100644
index 0000000..d3081e2
--- /dev/null
+++ b/reviewtools/containers/base_container.py
@@ -0,0 +1,407 @@
+import os
+import magic
+import shutil
+from typing import Union
+from tempfile import mkdtemp
+from reviewtools.common import MKDTEMP_PREFIX, MKDTEMP_DIR
+
+
+class ContainerException(Exception):
+    """This class represents exceptions"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+
+class BaseContainer:
+    """
+    A container is a file that encapsulates a file system. This BaseContainer
+    class models the basic functionality common to all containers, and it is
+    expected to be extended by subclasses handling functionality specific
+    to the container format, such as Squashfs, tar or deb
+    """
+
+    magic_binary_file_descriptions = [
+        "application/x-executable; charset=binary",
+        "application/x-sharedlib; charset=binary",
+        "application/x-object; charset=binary",
+        # 18.04 and higher doesn't show the charset
+        "application/x-executable",
+        "application/x-sharedlib",
+        "application/x-object",
+        "application/x-pie-executable",
+    ]
+
+    max_packed_size = None
+    min_packed_size = None
+    max_unpacked_size = None
+    min_unpacked_size = None
+    _filename = None
+    _unpack_dir = None
+    _files = None
+    _bin_files = None
+
+    def __init__(self, filename_or_unpackdir):
+        """
+        Note:
+            This object will create a temporary copy of the provided container file
+            or unpacked directory. Thus, creating a new instance of the container
+            will be needed to reflect any changes made externally to the original
+            container file or unpacked directory.
+            Automatically created temporary files will be automatically cleaned up
+            on container object deletion.
+
+        Args:
+            filename_or_unpackdir (str): In the most common way of operation, this
+                parameter is the relative or absolute path to the container file.
+                However, it may also be the relative or absolute path to a directory
+                with the unpacked content of the container file
+
+        Raises:
+            ContainerException: Calling this method will raise an exception
+                if the provided path does not exist or is not accessible.
+        """
+        self.tmp_dir = mkdtemp(prefix=MKDTEMP_PREFIX, dir=MKDTEMP_DIR)
+        if os.path.isfile(filename_or_unpackdir):
+            if os.path.basename(filename_or_unpackdir).count(".") == 0:
+                raise ContainerException("container filename must include an extension")
+            self._filename = "%s/%s" % (
+                self.tmp_dir,
+                os.path.basename(filename_or_unpackdir),
+            )
+            shutil.copyfile(filename_or_unpackdir, self._filename)
+            self.check_container_size(self.min_packed_size, self.max_packed_size)
+        elif os.path.isdir(filename_or_unpackdir):
+            self._unpack_dir = "%s/%s" % (
+                self.tmp_dir,
+                os.path.basename(filename_or_unpackdir),
+            )
+            shutil.copytree(filename_or_unpackdir, self._unpack_dir, dirs_exist_ok=True)
+            self.check_unpacked_size(self.min_unpacked_size, self.max_unpacked_size)
+        else:
+            raise ContainerException(
+                "directory %s does not exists or has incorrect permissions"
+                % filename_or_unpackdir
+            )
+
+    def __del__(self):
+        """
+        Deletes the temporary copy of the files used by this class. This method
+        is automatically called on object deletion
+        """
+        try:
+            shutil.rmtree(self.tmp_dir)
+        except:
+            pass
+
+    @property
+    def filename(self) -> str:
+        """
+        Absolute path to container file temporary location. If it is not defined
+        (i.e. BaseContainer was initialized with an unpacked directory), then pack()
+        will be called and the path of the newly created file will be returned.
+
+        Note:
+            If under any specific condition you need to avoid calling pack() you
+            should use the private _filename attribute instead of this property. It
+            probably will be only needed by BaseContainer internals and its
+            subclasses.
+        """
+        if self._filename is None:
+            self._filename = self.pack()
+        return self._filename
+
+    @property
+    def unpack_dir(self) -> str:
+        """
+        Absolute path to unpack directory temporary location. If it is not defined
+        (i.e. BaseContainer was initialized with a container fle), then unpack()
+        will be called and the path of the newly created directory will be returned.
+
+        Note:
+            If under any specific condition you need to avoid calling unpack() you
+            should use the private _unpack_dir attribute instead of this property. It
+            probably will be only needed by BaseContainer internals and its
+            subclasses.
+        """
+        if self._unpack_dir is None:
+            self._unpack_dir = self.unpack()
+        return self._unpack_dir
+
+    @property
+    def files(self) -> list:
+        """
+        List of files present in the container. List elements will be the absolute
+        path of the file taking unpack_dir as root directory. If it is not defined
+        (i.e. the list has not been populated yet), then get_file_list() will be
+        called and the newly created list will be returned.
+
+        Note:
+            If under any specific condition you need to avoid calling get_files()
+            you should use the private _files attribute instead of this property.
+            It probably will be only needed by BaseContainer internals and its
+            subclasses.
+        """
+        if self._files is None:
+            self._files = self.get_files_list()
+        return self._files
+
+    @property
+    def bin_files(self) -> list:
+        """
+        List of compiled binaries present in the container. List elements will be
+        the absolute path of the file taking unpack_dir as root directory. If it is
+        not defined (i.e. the list has not been populated yet), then
+        get_compiled_binaries_list() will be called and the newly created list will
+        be returned.
+
+        Note:
+            If under any specific condition you need to avoid calling
+            get_compiled_binaries_list() you should use the private _bin_files
+            attribute instead of this property. It probably will be only needed by
+            BaseContainer internals and its subclasses.
+        """
+        if self._bin_files is None:
+            self._bin_files = self.get_compiled_binaries_list()
+        return self._bin_files
+
+    def check_container_format(self):
+        """
+        Checks that the container file has the expected format.
+
+        Raises:
+            NotImplementedError: Calling this method will raise an exception as
+                format is specific to the container type. This method needs to be
+                implemented by the specific subclasses.
+        """
+        raise NotImplementedError("Must be implemented by subclasses")
+
+    def get_container_size(self) -> int:
+        """
+        Uses os.path.getsize() to return the size of the container file. If
+        container file is not defined, it will be created by calling pack().
+
+        Retruns:
+            int: Size in bytes of the container file
+        """
+        return os.path.getsize(self.filename)
+
+    def check_container_size(
+        self, minSize: Union[int, None] = None, maxSize: Union[int, None] = None
+    ):
+        """
+        Checks that the container size is within the specified range. If
+        container file is not defined, it will be created by calling pack().
+
+        Args:
+            minSize (int): Minimum container file size. If it is not specified
+                (i.e. it is None) this check will be skiped.
+            maxSize (int):  Maximum container file size. If it is not specified
+                (i.e. it is None) this check will be skiped.
+
+        Raises:
+            ContainerException: If container size is less than minSize or greater
+                than maxSize, a ContainerException will be raised.
+        """
+        size = self.get_container_size()
+        if minSize and (size < minSize):
+            raise ContainerException(
+                "container file is too small (%dM < %dM)"
+                % (size / 1024 / 1024, minSize / 1024 / 1024)
+            )
+        elif maxSize and (size > maxSize):
+            raise ContainerException(
+                "container file is too large (%dM > %dM)"
+                % (size / 1024 / 1024, maxSize / 1024 / 1024)
+            )
+
+    def get_unpacked_size(self) -> int:
+        """
+        Calculates the total size of the unpack dir by adding individual sizes of
+        files listed by os.walk. If unpack dir is not defined, it will be created
+        by calling unpack().
+
+        Returns:
+            int: Size in bytes of the container file
+        """
+        size = 0
+        for root, dirnames, filenames in os.walk(self.unpack_dir):
+            for f in filenames:
+                if os.path.exists(os.path.join(root, f)):
+                    size += os.path.getsize(os.path.join(root, f))
+        return size
+
+    def check_unpacked_size(
+        self, minSize: Union[int, None] = None, maxSize: Union[int, None] = None
+    ):
+        """
+        Checks that the unpacked size is within the specified range. If
+        unpack die is not defined, it will be created by calling unpack().
+
+        Args:
+            minSize (int): Minimum unpacked size. If it is not specified
+                (i.e. it is None) this check will be skiped.
+            maxSize (int):  Maximum unpacked size. If it is not specified
+                (i.e. it is None) this check will be skiped.
+
+        Raises:
+            ContainerException: If unpacked size is less than minSize or greater
+                than maxSize, a ContainerException will be raised.
+        """
+        size = self.get_unpacked_size()
+        if minSize and (size < minSize):
+            raise ContainerException(
+                "unpacked directory is too small (%dM < %dM)"
+                % (size / 1024 / 1024, minSize / 1024 / 1024)
+            )
+        elif maxSize and (size > maxSize):
+            raise ContainerException(
+                "unpacked directory is too large (%dM > %dM)"
+                % (size / 1024 / 1024, maxSize / 1024 / 1024)
+            )
+
+    def calculate_unpacked_size(self) -> int:
+        """
+        Estimates the space that the unpacked directory will use without unpacking.
+
+        Returns:
+            int: Estimated size in bytes of the unpacked directory
+
+        Raises:
+            NotImplementedError: Calling this method will raise an exception as the
+                estimation method is specific to the container type. This method
+                needs to be implemented by the specific subclasses.
+        """
+        raise NotImplementedError("Must be implemented by subclasses")
+
+    def check_disk_space(self):
+        """
+        Checks that the estimated size of less than the 90% of available space in
+        disk.
+
+        Raises:
+            ContainerException: If estimated unpacked size exceed the 90% of the
+            available space, an exception will be raised.
+        """
+        size = self.calculate_unpacked_size()
+        st = os.statvfs(self.tmp_dir)
+        avail = st.f_bsize * st.f_bavail * 0.9  # 90% of available space
+        if size > avail * 0.9:
+            raise ContainerException(
+                "insufficient available disk space (%dM > %dM)"
+                % (size / 1024 / 1024, avail / 1024 / 1024)
+            )
+
+    def unpack(self) -> str:
+        """
+        Extracts the content of the container file and returns the absolute path to
+        the newly unpacked directory.
+
+        Returns:
+            str: absolute path to the newly created unpack dir
+
+        Raises:
+            NotImplementedError: Calling this method will raise an exception as the
+                estimation method is specific to the container type. This method
+                needs to be implemented by the specific subclasses.
+        """
+        raise NotImplementedError("Must be implemented by subclasses")
+
+    def pack(self) -> str:
+        """
+        Creates a container file from the unpacked directory specified by unpack_dir.
+
+        Returns:
+            str: absolute path to the newly created container file
+
+        Raises:
+            NotImplementedError: Calling this method will raise an exception as the
+                estimation method is specific to the container type. This method
+                needs to be implemented by the specific subclasses.
+        """
+        raise NotImplementedError("Must be implemented by subclasses")
+
+    def get_file(self, fn: str) -> Union[str, None]:
+        """
+        Reads and return the binary content of the specified file.
+
+        Args:
+            fn (str): file relative path to container root (i.e. unpack_dir)
+
+        Returns:
+            str: binary content of the specified file or None if the file is not
+                present in the container. The output will need to be decoded() to
+                use it as a string
+
+        Raises:
+            NotImplementedError: Calling this method will raise an exception as the
+                estimation method is specific to the container type. This method
+                needs to be implemented by the specific subclasses.
+        """
+        if not os.path.exists(os.path.join(self.unpack_dir, fn)):
+            return None
+
+        try:
+            with open(os.path.join(self.unpack_dir, fn), "rb") as fd:
+                return fd.read()
+        except:
+            raise ContainerException(
+                "Somthing went wrong while reading file %s from the container" % fn
+            )
+
+    def get_files_list(self, rel: bool = True) -> list:
+        """
+        Populates the list of files present in the container (self.files) and
+        returns its value. If unpack dir is not defined, it will be created
+        by calling unpack().
+
+        Args:
+            rel (bool): if ``True``, file paths are relative to unpack_dir directory,
+             otherwise absolute paths are used. Defaults to ``False``
+
+        Returns:
+            list(str): list of files present in the container
+        """
+        files = []
+        for root, dirnames, filenames in os.walk(self.unpack_dir):
+            for f in filenames:
+                file = os.path.join(root, f)
+                file = os.path.relpath(file, self.unpack_dir) if rel else file
+                files.append(file)
+        return files
+
+    def get_compiled_binaries_list(self, rel: bool = True) -> list:
+        """
+        Populates the list of compiled binaries present in the container and returns
+        its value. If files list is not defined, it will be populated by calling
+        get_files_list()
+
+        Args:
+            rel (bool): if ``True``, file paths are relative to unpack_dir directory,
+             otherwise absolute paths are used. Defaults to ``False``
+
+        Returns:
+            list(str): list of files present in the container
+        """
+        mime = magic.open(magic.MAGIC_MIME)
+        mime.load()
+        bin_files = []
+        for file in self.get_files_list(rel=False):
+            try:
+                res = mime.file(file)
+            except Exception:  # pragma: nocover
+                # workaround for zesty python3-magic
+                continue
+
+            file = os.path.relpath(file, self.unpack_dir) if rel else file
+            if (
+                res in self.magic_binary_file_descriptions
+                and not file.endswith(".mo")
+                and file not in bin_files
+            ):
+                bin_files.append(file)
+
+        return bin_files
diff --git a/reviewtools/containers/snap_container.py b/reviewtools/containers/snap_container.py
new file mode 100644
index 0000000..8ac271a
--- /dev/null
+++ b/reviewtools/containers/snap_container.py
@@ -0,0 +1,116 @@
+import ruamel.yaml
+from typing import Union
+
+from reviewtools.containers.base_container import ContainerException
+from reviewtools.containers.squashfs_container import SquashfsContainer
+
+
+class SnapContainer(SquashfsContainer):
+    max_unpacked_size = 25 * 1024 * 1024 * 1024
+    max_packed_size = 5 * 1024 * 1024 * 1024
+
+    _snap_yaml = None
+    _manifest_yaml = None
+    _dpkg = None
+
+    @property
+    def snap_yaml(self) -> object:
+        """
+        Content of "/meta/snap.yaml" file loaded as python object If it has not been
+        previously loaded, then get_snap_yaml() will be called and the loaded object
+        will be returned.
+
+        Note:
+            If under any specific condition you need to avoid calling
+            get_snap_yaml(), you should use the private _snap_yaml attribute instead
+            of this property. It probably will be only needed by SnapContainer
+            internals and its subclasses.
+        """
+        if self._snap_yaml is None:
+            self._snap_yaml = self.get_snap_yaml()
+        return self._snap_yaml
+
+    @property
+    def manifest_yaml(self) -> object:
+        """
+        Content of "/snap/manifest.yaml" file loaded as python object If it has not
+        been previously loaded, then get_manifest_yaml() will be called and the
+        loaded object will be returned.
+
+        Note:
+            If under any specific condition you need to avoid calling
+            get_manifest_yaml(), you should use the private _manifest_yaml attribute
+            instead of this property. It probably will be only needed by
+            SnapContainer internals and its subclasses.
+        """
+        if self._manifest_yaml is None:
+            self._manifest_yaml = self.get_manifest_yaml()
+        return self._manifest_yaml
+
+    @property
+    def dpkg_entries(self) -> list:
+        """
+        List packages as lines from "/usr/share/snappy/dpkg.list" or
+        "/snap/dpkg.list" in this precedence order. If it has not been previously
+        loaded, then get_dpkg_entries() will be called and the loaded list will be
+        returned.
+
+        Note:
+            If under any specific condition you need to avoid calling
+            get_dpkg_entries() you should use the private _dpkg_entries attribute
+            instead of this property. It probably will be only needed by
+            SnapContainer internals and its subclasses.
+        """
+        if self._dpkg is None:
+            self._dpkg = self.get_dpkg_entries()
+        return self._dpkg
+
+    def __init__(self, filename_or_unpackdir):
+        super().__init__(filename_or_unpackdir)
+
+        # # Check size limits if they are defined
+        # if self.min_packed_size or self.max_packed_size:
+        #     self.check_container_size(self.min_packed_size, self.max_packed_size)
+        # if self.min_unpacked_size or self.max_unpacked_size:
+        #     self.check_unpacked_size(self.min_unpacked_size, self.max_unpacked_size)
+
+    def get_yaml(self, fn: str) -> Union[str, None]:
+        # Load file
+        file = self.get_file(fn)
+        if file is None:
+            raise ContainerException("file %s not found" % fn)
+
+        # Prevent duplicated keys
+        yaml = ruamel.yaml.YAML(typ="safe")
+        yaml.allow_duplicate_keys = False
+        try:
+            yaml_object = yaml.load(file.decode())
+        except ruamel.yaml.constructor.DuplicateKeyError as e:
+            raise ContainerException(e.problem)
+
+        return yaml_object
+
+    def get_snap_yaml(self):
+        try:
+            self._snap_yaml = self.get_yaml("/meta/snap.yaml")
+        except ContainerException as e:
+            raise ContainerException("could not read /meta/snap.yaml: %s" % e)
+
+        return self.snap_yaml
+
+    def get_manifest_yaml(self):
+        try:
+            self._manifest_yaml = self.get_yaml("/snap/manifest.yaml")
+        except ContainerException as e:
+            raise ContainerException("could not read /snap/manifest.yaml: %s" % e)
+
+        return self._manifest_yaml
+
+    def get_dpkg_entries(self):
+        dpkg_entries = []
+        dpkg = self.get_file("/usr/share/snappy/dpkg.list")
+        if dpkg is None:
+            dpkg = self.get_file("/snap/dpkg.list")
+        if dpkg is not None:
+            dpkg_entries = dpkg.decode().split("\n")
+        return dpkg_entries
diff --git a/reviewtools/containers/squashfs_container.py b/reviewtools/containers/squashfs_container.py
new file mode 100644
index 0000000..b98c1a3
--- /dev/null
+++ b/reviewtools/containers/squashfs_container.py
@@ -0,0 +1,195 @@
+import os
+import shutil
+
+from reviewtools.common import cmd, cmdIgnoreErrorStrings, UNSQUASHFS_IGNORED_ERRORS
+from reviewtools.containers.base_container import BaseContainer, ContainerException
+
+
+class SquashfsContainer(BaseContainer):
+    """
+    A container is a file that encapsulates a file system. This class extends
+    BaseContainer to handle functionality that is specific to Squashfs containers.
+    """
+
+    def __init__(self, filename_or_unpackdir):
+        """
+        If SquashfsContainer is initialized with a container file, it will also
+        verify that the provided file is actually a squashfs, in addition to the
+        checks performed by the BaseContainer.
+
+        Note:
+            This object will create a temporary copy of the provided container file
+            or unpacked directory. Thus, creating a new instance of the container
+            will be needed to reflect any changes made externally to the original
+            container file or unpacked directory.
+            Automatically created temporary files will be automatically cleaned up
+            on container object deletion.
+
+        Args:
+            filename_or_unpackdir (str): In the most common way of operation, this
+                parameter is the relative or absolute path to the container file.
+                However, it may also be the relative or absolute path to a directory
+                with the unpacked content of the container file
+
+        Raises:
+            ContainerException: Calling this method will raise an exception
+                if the provided path does not exist or is not accessible.
+        """
+        super().__init__(filename_or_unpackdir)
+
+        # Check is squash file
+        if self._filename is not None:
+            self.check_container_format()
+
+    def check_container_format(self):
+        """
+        Checks that the container file has the expected format.
+
+        Raises:
+            ContainerException: This method will raise an exception if the
+            container file is not a squashfs container, or if the container file
+            is not defined (i.e. SquashfsContainer was initialized with an unpacked
+            directory) and pack() was not explicitly called by the user.
+        """
+        if self._filename is None:
+            raise ContainerException("container file does not exist")
+
+        with open(self.filename, "rb") as f:
+            header = f.read(10)
+        if not header.startswith(b"hsqs"):
+            raise ContainerException("Unsupported package format (not squashfs)")
+
+    def calculate_unpacked_size(self) -> int:
+        """
+        Estimates the space that the unpacked directory will use by adding the
+        individual files size reported by "unsquashfs -lln" command. It may not
+        be completely accurate, as this command does not consider that each folder
+        requires at least one complete block
+
+        Returns:
+            int: Estimated size in bytes of the unpacked directory
+        """
+        if self._filename is None:
+            raise ContainerException("container file does not exist")
+
+        (rc, out) = cmd(["unsquashfs", "-lln", self.filename])
+        if rc != 0:
+            raise ContainerException(
+                "unsquashfs -lln '%s' failed: %s" % (self.filename, out)
+            )
+
+        size = 0
+        for line in out.splitlines():
+            if not line.startswith("-"):  # skip non-regular files
+                continue
+            try:
+                size += int(line.split()[2])
+            except ValueError:  # skip non-numbers
+                continue
+
+        return size
+
+    def unpack(self, force: bool = False) -> str:
+        """
+        Extracts the content of the container file and returns the absolute path to
+        the newly unpacked directory.
+
+        Args:
+            force (bool, optional): If ``True``, the unpack_dir will be overwritten
+                if it already exists. Defaults to ``False``
+
+        Returns:
+            str: absolute path to the newly created unpack dir
+
+        Raises:
+            ContainerException: This method will raise an ContainerException if the
+                container file is not defined (i.e. SquashfsContainer was
+                initialized with an unpacked directory) and pack() was not
+                explicitly called by the user, or if the unpack_dir already exists
+                and this method was called without the force argument set to True
+          RuntimeError: This method will raise a RuntimeError under the execution
+            of the "unsquashfs" command returns with an error code other than 0.
+        """
+        if self._filename is None:
+            raise ContainerException("container file does not exist")
+
+        if self._unpack_dir is not None and not force:
+            raise ContainerException(
+                "unpack dir already exists and unpack function was called without force"
+            )
+
+        # Check that disk has enough space to extract the container
+        self.check_disk_space()
+
+        # Unpack the container
+        stage_dir = os.path.join(self.tmp_dir, "stage")
+        (rc, out) = cmdIgnoreErrorStrings(
+            [
+                "unsquashfs",
+                "-no-progress",
+                "-ignore-errors",
+                "-quiet",
+                "-f",
+                "-d",
+                stage_dir,
+                self.filename,
+            ],
+            UNSQUASHFS_IGNORED_ERRORS,
+        )
+        if rc != 0:
+            if os.path.isdir(stage_dir):
+                shutil.rmtree(stage_dir)
+            raise RuntimeError("unpacking failed with '%d':\n%s" % (rc, out))
+
+        # Update on success
+        if self._unpack_dir is not None and os.path.exists(self._unpack_dir):
+            shutil.rmtree(self._unpack_dir)
+        self._unpack_dir = ".".join(self.filename.split(".")[:-1])
+        shutil.move(stage_dir, self._unpack_dir)
+        return self._unpack_dir
+
+    def pack(self, force: bool = False, extension: str = "container") -> str:
+        """
+        Creates a container file from the unpacked directory specified by unpack_dir
+
+        Args:
+            force (bool, optional): If ``True``, the container file will be
+                overwritten if it already exists. Defaults to ``False``
+            extension (str, optional): extension used in the newly created container
+                file. Defaults to ``"container"``
+
+        Returns:
+            str: absolute path to the newly created container file
+
+        Raises:
+            ContainerException: This method will raise an ContainerException if the
+                unpack_dir is not defined (i.e. SquashfsContainer was initialized
+                with a container file) and unpack() was not explicitly called by the
+                user, or if the container file already exists and this method was
+                called without the force argument set to True
+          RuntimeError: This method will raise a RuntimeError under the execution
+            of the "mksquashfs" command returns with an error code other than 0.
+        """
+        if self._unpack_dir is None:
+            raise ContainerException("unpack dir does not exist")
+
+        if self._filename is not None and not force:
+            raise ContainerException(
+                "Container file already exists and pack function was called without force"
+            )
+
+        # Pack the directory
+        # TODO: make use of MKSQUASHFS_OPTS before updating sr_security::check_squashfs_resquash to use this method
+        stage_file = os.path.join(self.tmp_dir, "stage")
+        (rc, out) = cmd(["mksquashfs", self.unpack_dir, stage_file])
+        if rc != 0:
+            if os.path.exists:
+                os.unlink(stage_file)
+            raise RuntimeError("packing failed with '%d':\n%s" % (rc, out))
+
+        # Update on success
+        if self._filename is not None and os.path.exists(self._filename):
+            os.unlink(self._filename)
+        self._filename = ".".join([self.unpack_dir, extension])
+        shutil.move(stage_file, self._filename)
+        return self._filename
diff --git a/reviewtools/sr_common.py b/reviewtools/sr_common.py
index 201a0dc..a7c6e4e 100644
--- a/reviewtools/sr_common.py
+++ b/reviewtools/sr_common.py
@@ -21,7 +21,7 @@ import yaml
 
 
 from reviewtools.common import (
-    Review,
+    ReviewBase,
     ReviewException,
     error,
     open_file_read,
@@ -31,6 +31,8 @@ from reviewtools.common import (
     verify_type,
 )
 from reviewtools.overrides import interfaces_attribs_addons
+from reviewtools.containers.snap_container import SnapContainer
+from reviewtools.containers.base_container import ContainerException
 
 
 #
@@ -40,7 +42,7 @@ class SnapReviewException(ReviewException):
     """This class represents SnapReview exceptions"""
 
 
-class SnapReview(Review):
+class SnapReview(ReviewBase):
     """This class represents snap reviews"""
 
     snappy_required = ["name", "version"]
@@ -414,34 +416,43 @@ class SnapReview(Review):
     def __init__(self, fn, review_type, overrides=None):
         if review_type is None:  # for using utility functions
             return
-        Review.__init__(self, fn, review_type, overrides=overrides)
+        ReviewBase.__init__(self, review_type, overrides=overrides)
 
-        # Anything importing this is assumed to be a snap v2 check
-        if not self.is_snap2:
-            return
+        try:
+            self.snap = SnapContainer(fn)
+        except ContainerException as e:
+            error(e.value)
+        self.pkg_filename = self.snap.filename
+        self.unpack_dir = self.snap.unpack_dir
+
+        # unpack_pkg() now only supports snap v2, so just hardcode these
+        self.pkgfmt = {"type": "snap", "version": "16.04"}
+
+        # Get a list of all unpacked files
+        self.pkg_files = self.snap.get_files_list(rel=False)
+
+        # Setup what is needed to get a list of all unpacked compiled binaries
+        self.pkg_bin_files = self.snap.get_compiled_binaries_list(rel=False)
 
-        snap_yaml = self._extract_snap_yaml()
+        snap_yaml = self.snap.get_file("meta/snap.yaml")
         try:
-            self.snap_yaml = yaml.safe_load(snap_yaml)
+            self.snap_yaml = yaml.safe_load(snap_yaml.decode())
         except Exception:  # pragma: nocover
             error("Could not load snap.yaml. Is it properly formatted?")
-        snap_yaml.close()
 
         # read yaml again for duplicated keys check (py-yaml does not
         # do that)
-        snap_yaml = self._extract_snap_yaml()
+        snap_yaml = self.snap.get_file("meta/snap.yaml")
         try:
-            self._verify_no_duplicated_yaml_keys(snap_yaml.read())
+            self._verify_no_duplicated_yaml_keys(snap_yaml.decode())
         except Exception as e:
             error("Found duplicated yaml keys in snap.yaml: %s" % e)
-        snap_yaml.close()
 
         self.snap_manifest_yaml = {}
-        manifest_yaml = self._extract_snap_manifest_yaml()
+        manifest_yaml = self.snap.get_file("snap/manifest.yaml")
         if manifest_yaml is not None:
             try:
-                self.snap_manifest_yaml = yaml.safe_load(manifest_yaml)
-                manifest_yaml.close()
+                self.snap_manifest_yaml = yaml.safe_load(manifest_yaml.decode())
                 if self.snap_manifest_yaml is None:
                     self.snap_manifest_yaml = {}
             except Exception:  # pragma: nocover
diff --git a/reviewtools/sr_functional.py b/reviewtools/sr_functional.py
index bbdc56b..6823b8a 100644
--- a/reviewtools/sr_functional.py
+++ b/reviewtools/sr_functional.py
@@ -36,7 +36,6 @@ class SnapReviewFunctional(SnapReview):
 
     def __init__(self, fn, overrides=None):
         SnapReview.__init__(self, fn, "functional-snap-v2", overrides=overrides)
-        self._list_all_compiled_binaries()
 
         # State files only for base snaps, if have -lln output and
         # --state-output is specified
diff --git a/reviewtools/sr_lint.py b/reviewtools/sr_lint.py
index c94340a..fc0c7ef 100644
--- a/reviewtools/sr_lint.py
+++ b/reviewtools/sr_lint.py
@@ -20,6 +20,7 @@ from reviewtools.common import (
     find_external_symlinks,
     STORE_PKGNAME_SNAPV2_MAXLEN,
     STORE_PKGNAME_SNAPV2_MINLEN,
+    error
 )
 from reviewtools.overrides import (
     redflagged_snap_types_overrides,
@@ -55,8 +56,6 @@ class SnapReviewLint(SnapReview):
         ]
         self.iffy_files = [r"^\..+\.swp$"]  # vim
 
-        self._list_all_compiled_binaries()
-
         self.redflagged_snap_types = ["base", "kernel", "gadget", "os", "snapd"]
 
         self.interface_plug_requires_desktop_file = ["unity7", "x11", "unity8"]
@@ -273,7 +272,7 @@ class SnapReviewLint(SnapReview):
             t = "info"
             n = self._get_check_name("hook_executable", app=hook)
             s = "OK"
-            if not self._check_innerpath_executable(fn):
+            if not os.access(fn, os.X_OK):
                 t = "error"
                 s = "%s is not executable" % rel
             self._add_result(t, n, s)
@@ -349,7 +348,7 @@ class SnapReviewLint(SnapReview):
         t = "info"
         n = self._get_check_name("icon_exists")
         s = "OK"
-        fn = self._path_join(self._get_unpack_dir(), self.snap_yaml["icon"])
+        fn = os.path.join(self._get_unpack_dir(), self.snap_yaml["icon"])
         if fn not in self.pkg_files:
             t = "error"
             s = "icon entry '%s' does not exist" % self.snap_yaml["icon"]
@@ -566,7 +565,7 @@ class SnapReviewLint(SnapReview):
             ):
                 val = val.lstrip("/")
 
-            fn = self._path_join(self._get_unpack_dir(), os.path.normpath(val))
+            fn = os.path.join(self._get_unpack_dir(), os.path.normpath(val))
             if fn not in self.pkg_files:
                 t = "error"
                 s = "%s does not exist" % (self.snap_yaml["apps"][app][key])
@@ -637,7 +636,7 @@ class SnapReviewLint(SnapReview):
             ):
                 val = val.lstrip("/")
 
-            fn = self._path_join(self._get_unpack_dir(), os.path.normpath(val))
+            fn = os.path.join(self._get_unpack_dir(), os.path.normpath(val))
             if fn not in self.pkg_files:
                 nonexistent.append(val)
 
@@ -2022,9 +2021,10 @@ class SnapReviewLint(SnapReview):
             else:
                 appnames.append("%s.%s" % (self.snap_yaml["name"], app))
 
-        fh = self._extract_file(fn)
-        lines = fh.readlines()
-        fh.close()
+        file = self.snap.get_file(fn)
+        if file is None:
+            error("Could not find '%s'" % fn)
+        lines = file.decode().split("\n")
 
         # For now, just check Exec=, Icon= and bools since:
         # - snapd strips out anything it doesn't understand
@@ -2168,7 +2168,7 @@ class SnapReviewLint(SnapReview):
         for f in self.pkg_files:
             fn = os.path.relpath(f, self._get_unpack_dir())
             if fn.startswith("meta/gui/") and fn.endswith(".desktop"):
-                self._verify_desktop_file(f)
+                self._verify_desktop_file(fn)
                 has_desktop_files = True
                 break
 
@@ -3221,7 +3221,7 @@ class SnapReviewLint(SnapReview):
         count = 0
         for fn in icons:
             rel = os.path.relpath(fn, self._get_unpack_dir())
-            if fn != shlex.quote(fn):
+            if rel != shlex.quote(rel):
                 bad_names.append(rel)
                 continue
             elif not os.path.isfile(fn):
diff --git a/reviewtools/sr_tests.py b/reviewtools/sr_tests.py
index b23fbe6..ca43c5b 100644
--- a/reviewtools/sr_tests.py
+++ b/reviewtools/sr_tests.py
@@ -15,7 +15,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import copy
-import io
 import os
 import yaml
 
@@ -42,27 +41,7 @@ def _mock_func(self):
     return
 
 
-def _extract_snap_yaml(self):
-    """Pretend we read the snap.yaml file"""
-    return io.StringIO(TEST_SNAP_YAML)
-
-
-def _extract_snap_manifest_yaml(self):
-    """Pretend we read the snap/manifest.yaml file"""
-    return io.StringIO(TEST_SNAP_MANIFEST_YAML)
-
-
-def _path_join(self, d, fn):
-    """Pretend we have a tempdir"""
-    return os.path.join("/fake", fn)
-
-
-def _pkgfmt_type(self):
-    """Pretend we found the pkgfmt type"""
-    return TEST_PKGFMT_TYPE
-
-
-def __get_unpack_dir(self):
+def _get_unpack_dir(self):
     """Pretend we found the unpack dir"""
     return TEST_UNPACK_DIR
 
@@ -77,53 +56,28 @@ def _cmd_nm(self, args):
     return TEST_CMD_NM
 
 
-def create_patches():
-    # http://docs.python.org/3.4/library/unittest.mock-examples.html
-    # Mock patching. Don't use decorators but instead patch in setUp() of the
-    # child.
-    patches = []
-    patches.append(patch("reviewtools.common.Review._check_package_exists", _mock_func))
-    patches.append(
-        patch("reviewtools.sr_common.SnapReview._extract_snap_yaml", _extract_snap_yaml)
-    )
-    patches.append(
-        patch(
-            "reviewtools.sr_common.SnapReview._extract_snap_manifest_yaml",
-            _extract_snap_manifest_yaml,
-        )
-    )
-    patches.append(patch("reviewtools.sr_common.SnapReview._path_join", _path_join))
-    patches.append(patch("reviewtools.common.unpack_pkg", _mock_func))
-    patches.append(patch("reviewtools.common.raw_unpack_pkg", _mock_func))
-    patches.append(
-        patch("reviewtools.sr_common.SnapReview._list_all_files", _mock_func)
-    )
-    patches.append(
-        patch(
-            "reviewtools.sr_common.SnapReview._list_all_compiled_binaries", _mock_func
-        )
-    )
+class SnapContainer():
+    def __init__(self, fn):
+        self.filename = fn
+        self.unpack_dir = TEST_UNPACK_DIR
+        self.files = []
+        self.bin_files = []
 
-    patches.append(patch("reviewtools.common.Review._list_all_files", _mock_func))
-    patches.append(
-        patch("reviewtools.common.Review._list_all_compiled_binaries", _mock_func)
-    )
+    def unpack(self):
+        return
 
-    # sr_common
-    patches.append(
-        patch("reviewtools.sr_common.SnapReview._get_unpack_dir", __get_unpack_dir)
-    )
-    patches.append(patch("reviewtools.sr_common.SnapReview._pkgfmt_type", _pkgfmt_type))
-    patches.append(
-        patch("reviewtools.sr_common.SnapReview._unsquashfs_lln", _unsquashfs_lln)
-    )
+    def get_files_list(self, rel=True):
+        return []
 
-    # sr_functional
-    patches.append(
-        patch("reviewtools.sr_functional.SnapReviewFunctional._cmd_nm", _cmd_nm)
-    )
+    def get_compiled_binaries_list(self, rel=True):
+        return []
 
-    return patches
+    def get_file(self, fn):
+        if fn == "meta/snap.yaml":
+            return TEST_SNAP_YAML.encode()
+        elif fn == "snap/manifest.yaml":
+            return TEST_SNAP_MANIFEST_YAML.encode()
+        return "".encode()
 
 
 class TestSnapReview(TestCase):
@@ -221,9 +175,33 @@ class TestSnapReview(TestCase):
         global TEST_CMD_NM
         TEST_CMD_NM = (rc, s)
 
+    def create_patches(self):
+        # http://docs.python.org/3.4/library/unittest.mock-examples.html
+        # Mock patching. Don't use decorators but instead patch in setUp() of the
+        # child.
+        patches = []
+        patches.append(patch("reviewtools.sr_common.SnapContainer", SnapContainer))
+        patches.append(patch("reviewtools.common.unpack_pkg", _mock_func))
+
+        # sr_common
+        patches.append(
+            patch("reviewtools.sr_common.SnapReview._get_unpack_dir", _get_unpack_dir)
+        )
+        # patches.append(patch("reviewtools.sr_common.SnapReview._pkgfmt_type", _pkgfmt_type))
+        patches.append(
+            patch("reviewtools.sr_common.SnapReview._unsquashfs_lln", _unsquashfs_lln)
+        )
+
+        # sr_functional
+        patches.append(
+            patch("reviewtools.sr_functional.SnapReviewFunctional._cmd_nm", _cmd_nm)
+        )
+
+        return patches
+
     def setUp(self):
         """Make sure our patches are applied everywhere"""
-        patches = create_patches()
+        patches = self.create_patches()
         for p in patches:
             p.start()
             self.addCleanup(p.stop)
diff --git a/reviewtools/tests/containers/test_base_container.py b/reviewtools/tests/containers/test_base_container.py
new file mode 100644
index 0000000..d7c6a81
--- /dev/null
+++ b/reviewtools/tests/containers/test_base_container.py
@@ -0,0 +1,169 @@
+import os
+import shutil
+import unittest
+from tempfile import mkstemp, mkdtemp
+from reviewtools.containers.base_container import BaseContainer, ContainerException
+
+
+class TestBaseContainer(unittest.TestCase):
+    """Tests for reviewtools.containers.base_container.BaseContainer"""
+
+    test_files = ["meta/snap.yaml", "meta/hooks/install"]
+    test_binaries = ["usr/bin/bash"]
+
+    @classmethod
+    def setUpClass(cls):
+        cls._create_unpackdir(cls)
+        cls._create_container(cls)
+
+    @classmethod
+    def tearDownClass(cls):
+        if os.path.exists(cls._container_filename):
+            os.unlink(cls._container_filename)
+        if os.path.exists(cls._unpack_dir):
+            shutil.rmtree(cls._unpack_dir)
+
+    def _create_unpackdir(self):
+        self._unpack_dir = mkdtemp()
+        self._unpacked_size = 0
+        for file in self.test_files + self.test_binaries:
+            unpacked_file = os.path.join(self._unpack_dir, file)
+            os.makedirs(os.path.dirname(unpacked_file), exist_ok=True)
+            if file in self.test_files:
+                with open(unpacked_file, "w+b") as fd:
+                    fd.write(b"Test")
+            else:
+                shutil.copyfile(os.path.join("/", file), unpacked_file)
+            self._unpacked_size += os.path.getsize(unpacked_file)
+
+    def _create_container(self):
+        self._container_size = 10000
+        fd, self._container_filename = mkstemp(suffix=".test")
+        with os.fdopen(fd, "w") as f:
+            f.truncate(self._container_size)
+
+    # Test class initialization
+    def test_initialization_container__happy(self):
+        try:
+            BaseContainer(self._container_filename)
+        except:
+            self.fail(
+                "An unexpected error occurred during BaseContainer initialization with container file"
+            )
+
+    def test_initialization_unpackdir__happy(self):
+        try:
+            BaseContainer(self._unpack_dir)
+        except:
+            self.fail(
+                "An unexpected error occurred during BaseContainer initialization with unpacked directory"
+            )
+
+    def test_initialization__missing_file(self):
+        with self.assertRaises(ContainerException) as context:
+            BaseContainer("/non/existing/path")
+            self.assertTrue(
+                "does not exists or has incorrect permissions"
+                in context.exception.value
+            )
+
+    # Test check container size
+    def test_check_container_size__happy(self):
+        try:
+            BaseContainer(self._container_filename).check_container_size(
+                minSize=self._container_size - 1, maxSize=self._container_size + 1
+            )
+        except:
+            self.fail("An unexpected error occurred while checking file size")
+
+    def test_check_container_size__too_big(self):
+        with self.assertRaises(ContainerException) as context:
+            BaseContainer(self._container_filename).check_container_size(
+                maxSize=self._container_size - 1
+            )
+            self.assertTrue("container file is too large " in context.exception.value)
+
+    def test_check_container_size__too_small(self):
+        with self.assertRaises(ContainerException) as context:
+            BaseContainer(self._container_filename).check_container_size(
+                minSize=self._container_size + 1
+            )
+            self.assertTrue("container file is too small " in context.exception.value)
+
+    # Test check unpacked size
+    def test_check_unpacked_size__happy(self):
+        try:
+            BaseContainer(self._unpack_dir).check_unpacked_size(
+                minSize=self._unpacked_size - 1, maxSize=self._unpacked_size + 1
+            )
+        except:
+            self.fail("An unexpected error occurred while checking file size")
+
+    def test_check_unpacked_size__too_big(self):
+        with self.assertRaises(ContainerException) as context:
+            BaseContainer(self._unpack_dir).check_unpacked_size(
+                maxSize=self._unpacked_size - 1
+            )
+            self.assertTrue("container file is too large " in context.exception.value)
+
+    def test_check_unpacked_size__too_small(self):
+        with self.assertRaises(ContainerException) as context:
+            BaseContainer(self._unpack_dir).check_unpacked_size(
+                minSize=self._unpacked_size + 1
+            )
+            self.assertTrue("container file is too small " in context.exception.value)
+
+    # Test get file
+    def test_get_file__happy(self):
+        try:
+            container = BaseContainer(self._unpack_dir)
+            snap_yaml = container.get_file("meta/snap.yaml")
+            self.assertEqual(snap_yaml.decode(), "Test")
+        except:
+            self.fail("An unexpected error occurred while getting meta/snap.yaml")
+
+    def test_get_file__missing_file(self):
+        try:
+            container = BaseContainer(self._unpack_dir)
+            file = container.get_file("non/existent/file")
+            self.assertEqual(file, None)
+        except:
+            self.fail("An unexpected error occurred while getting non/existent/file")
+
+    # Test get files list
+    def test_get_files_list__happy(self):
+        try:
+            container = BaseContainer(self._unpack_dir)
+            self.assertCountEqual(
+                container.get_files_list(), self.test_files + self.test_binaries
+            )
+        except:
+            self.fail("An unexpected error occurred while getting files list")
+
+    def test_files__happy(self):
+        try:
+            container = BaseContainer(self._unpack_dir)
+            self.assertCountEqual(container.files, self.test_files + self.test_binaries)
+        except:
+            self.fail("An unexpected error occurred while getting files list")
+
+    # Test get binaries list
+    def test_get_compiled_binaries_list__happy(self):
+        try:
+            container = BaseContainer(self._unpack_dir)
+            self.assertCountEqual(
+                container.get_compiled_binaries_list(), self.test_binaries
+            )
+        except:
+            self.fail(
+                "An unexpected error occurred while getting compiled binaries list"
+            )
+
+    def test_bin_files__happy(self):
+        try:
+            container = BaseContainer(self._unpack_dir)
+            self.assertCountEqual(container.bin_files, self.test_binaries)
+        except:
+            self.fail(
+                "An unexpected error occurred while getting compiled binaries list"
+            )
diff --git a/reviewtools/tests/containers/test_squashfs_container.py b/reviewtools/tests/containers/test_squashfs_container.py
new file mode 100644
index 0000000..6bac90f
--- /dev/null
+++ b/reviewtools/tests/containers/test_squashfs_container.py
@@ -0,0 +1,165 @@
+import os
+import hashlib
+from tempfile import mkstemp, mkdtemp, TemporaryFile
+from reviewtools.containers.base_container import ContainerException
+from reviewtools.containers.squashfs_container import SquashfsContainer
+from reviewtools.tests.containers.test_base_container import TestBaseContainer
+from subprocess import run
+
+
+class TestSquashfsContainer(TestBaseContainer):
+    """Tests for reviewtools.containers"""
+
+    def _create_container(self):
+        fd, self._container_filename = mkstemp(suffix=".test")
+        os.unlink(self._container_filename)
+        # Ensure reproducible build
+        os.environ["SOURCE_DATE_EPOCH"] = "0"
+        run(["mksquashfs", self._unpack_dir, self._container_filename])
+        os.unsetenv("SOURCE_DATE_EPOCH")
+        self._container_size = os.path.getsize(self._container_filename)
+
+    #  Test initialization
+    def test_check_initialization__happy(self):
+        try:
+            SquashfsContainer(self._container_filename)
+        except:
+            self.fail(
+                "An unexpected error occurred during SquashfsContainer initialization with container file"
+            )
+
+    def test_check_initialization__invalid_format(self):
+        with self.assertRaises(ContainerException) as context:
+            fd, plain_file = mkstemp()
+            SquashfsContainer(plain_file)
+            self.assertEqual(
+                "unsupported package format (not squashfs)", context.exception.value
+            )
+            os.unlink(plain_file)
+
+    # Test deletion
+    def test_check_cleanup(self):
+        try:
+            squashfsContainer = SquashfsContainer(self._container_filename)
+            filename = squashfsContainer.filename
+            del squashfsContainer
+            self.assertFalse(os.path.exists(filename))
+        except:
+            self.fail("An unexpected error occurred during deletion test")
+
+    # Test check format
+    def test_check_container_format__missing_container(self):
+        with self.assertRaises(ContainerException) as context:
+            SquashfsContainer(self._unpack_dir).check_container_format()
+            self.assertEqual("container file does not exist", context.exception.value)
+
+    # Test check format
+    def test_calculate_unpacked_size__happy(self):
+        try:
+            # unpacked size calculated is a bit smaller than actual size as it does not consider that
+            # folders require at least one complete block
+            squashfsContainer = SquashfsContainer(self._container_filename)
+            size = squashfsContainer.calculate_unpacked_size()
+            self.assertGreaterEqual(size, self._unpacked_size)
+            self.assertLess(size, 1.05 * self._unpacked_size)
+        except:
+            self.fail("An unexpected error occurred during unpacked size calculation")
+
+    def test_calculate_unpacked_size__missing_container(self):
+        with self.assertRaises(ContainerException) as context:
+            SquashfsContainer(self._unpack_dir).calculate_unpacked_size()
+            self.assertEqual("container file does not exist", context.exception.value)
+
+    # Test unpack
+    def test_unpack__happy(self):
+        try:
+            squashfsContainer = SquashfsContainer(self._container_filename)
+            squashfsContainer.unpack()
+        except:
+            self.fail("An unexpected error occurred during unpack")
+
+    def test_unpack__force(self):
+        try:
+            squashfsContainer = SquashfsContainer(self._container_filename)
+            squashfsContainer.unpack()
+            squashfsContainer.unpack(force=True)
+        except:
+            self.fail("An unexpected error occurred during unpack")
+
+    # Test check format
+    def test_unpack__missing_container(self):
+        with self.assertRaises(ContainerException) as context:
+            SquashfsContainer(self._unpack_dir).unpack()
+            self.assertEqual("container file does not exist", context.exception.value)
+
+    def test_unpack__no_force(self):
+        with self.assertRaises(ContainerException) as context:
+            squashfsContainer = SquashfsContainer(self._container_filename)
+            squashfsContainer.unpack()
+            squashfsContainer.unpack()
+            self.assertEqual(
+                "unpack dir already exists and unpack function was called without force",
+                context.exception.value,
+            )
+
+    # Test unpack
+    def test_pack__happy(self):
+        try:
+            squashfsContainer = SquashfsContainer(self._unpack_dir)
+            squashfsContainer.pack()
+        except:
+            self.fail("An unexpected error occurred during pack")
+
+    def test_pack__force(self):
+        try:
+            squashfsContainer = SquashfsContainer(self._unpack_dir)
+            squashfsContainer.pack()
+            squashfsContainer.pack(force=True)
+        except:
+            self.fail("An unexpected error occurred during pack")
+
+    # Test check format
+    def test_pack__missing_container(self):
+        with self.assertRaises(ContainerException) as context:
+            SquashfsContainer(self._container_filename).pack()
+            self.assertEqual("unpack dir does not exist", context.exception.value)
+
+    def test_pack__no_force(self):
+        with self.assertRaises(ContainerException) as context:
+            squashfsContainer = SquashfsContainer(self._container_filename)
+            squashfsContainer.pack()
+            squashfsContainer.pack()
+            self.assertEqual(
+                "pack dir already exists and unpack function was called without force",
+                context.exception.value,
+            )
+
+    def test_repack(self):
+        with open(self._container_filename, "rb") as fd:
+            init_hash = hashlib.sha256(fd.read()).hexdigest()
+        squashfsContainer = SquashfsContainer(self._container_filename)
+
+        # # Test unpack dir
+        squashfsContainer.unpack()
+        original_hash = ""
+        for path, dirs, files in os.walk(self._unpack_dir):
+            for file in files:
+                with open("%s/%s" % (path, file), "rb") as fd:
+                    original_hash += hashlib.sha256(fd.read()).hexdigest()
+        original_hash = hashlib.sha256(original_hash.encode()).hexdigest()
+
+        unpacked_hash = ""
+        for path, dirs, files in os.walk(squashfsContainer.unpack_dir):
+            for file in files:
+                with open("%s/%s" % (path, file), "rb") as fd:
+                    unpacked_hash += hashlib.sha256(fd.read()).hexdigest()
+        unpacked_hash = hashlib.sha256(unpacked_hash.encode()).hexdigest()
+        self.assertEqual(original_hash, unpacked_hash)
+
+        # Test packed file
+        os.environ["SOURCE_DATE_EPOCH"] = "0"
+        squashfsContainer.pack(force=True)
+        os.unsetenv("SOURCE_DATE_EPOCH")
+        with open(squashfsContainer.filename, "rb") as fd:
+            late_hash = hashlib.sha256(fd.read()).hexdigest()
+        self.assertEqual(init_hash, late_hash)