[U-Boot,3/3] test/py: Create tests for ext4 and fat testing on sandbox

The following checks are currently implemented:
1. listing a directory
2. verifying size of a file
3. veryfying md5sum for a file region
4. reading the beginning of a file

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
---
 test/py/tests/test_fs.py | 298 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 298 insertions(+)
 create mode 100644 test/py/tests/test_fs.py

Hi,

On 5 November 2016 at 10:45, Stefan Brüns <stefan.bruens@rwth-aachen.de> wrote:
>
> The following checks are currently implemented:
> 1. listing a directory
> 2. verifying size of a file
> 3. veryfying md5sum for a file region
> 4. reading the beginning of a file
>
> Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
> ---
>  test/py/tests/test_fs.py | 298 +++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 298 insertions(+)
>  create mode 100644 test/py/tests/test_fs.py
>
> diff --git a/test/py/tests/test_fs.py b/test/py/tests/test_fs.py
> new file mode 100644
> index 0000000..5ac91e4
> --- /dev/null
> +++ b/test/py/tests/test_fs.py
> @@ -0,0 +1,298 @@
> +# Copyright (c) 2016, Stefan Bruens <stefan.bruens@rwth-aachen.de>
> +#
> +# SPDX-License-Identifier: GPL-2.0
> +
> +# Test U-Boot's filesystem implementations

Can you add a few details here about what this tests?

> +
> +import hashlib
> +import pytest
> +import os
> +import random
> +import re
> +import u_boot_utils as util
> +
> +
> +mkfs_opts = {
> +       "fat" :'-t vfat',
> +       "ext4" : '-t ext4 -F',

Can you please use a single quote unless you can't? That is the style
used in U-Boot.

> +}
> +
> +fs_commands = {
> +       "fat" : {
> +               'listcmd'   : 'ls',
> +               'readcmd'   : 'load',
> +               'sizecmd'   : 'size',
> +               'writecmd'  : 'size',
> +       },
> +       "ext4" : {
> +               'listcmd'   : 'ls',
> +               'readcmd'   : 'load',
> +               'sizecmd'   : 'size',
> +               'writecmd'  : 'size',
> +       },
> +}
> +
> +cmd_parameters = {
> +       "hostfs" : {
> +               'prefix'    : 'host ',
> +               'interface' : 'hostfs -',
> +       },
> +       "generic" : {
> +               'prefix'    : '',
> +               'interface' : 'host 0:0',
> +       },
> +}
> +
> +files = {
> +    "empty.file" : [(0, 0)],
> +    "1MB.file"   : [(0, 1e6)],
> +    "1MB.sparse.file"   : [(1e6-1, 1e6)],
> +}
> +    # "2_5GB.sparse.file"   : [(0, 1e6), (1e9, 1e9+1e6), (2.5e9-1e6, 2.5e9)],

What is that line for?

> +
> +@pytest.fixture(scope="session")
> +def prereq_commands():
> +    from distutils.spawn import find_executable

Why not import this at the top of the file?

> +    for command in ["mkfs", "mount", "umount"]:
> +        if find_executable(command) is None:
> +            pytest.skip('Filesystem tests, "{0}" not in PATH'.format(command))
> +
> +class FsImage:
> +    def __init__(self, fstype, imagename, mountpath):

Please add comments as to what these params are.

> +        self.fstype = fstype
> +        self.imagename = imagename
> +        self.mountpath = mountpath
> +        self.md5s = {}
> +        with open(self.imagename, 'w') as fd:
> +            fd.truncate(0)
> +            fd.seek(3e9)
> +            fd.write(bytes([0]))
> +
> +    def mkfs(self, log):
> +        mkfsopts = mkfs_opts.get(self.fstype)
> +        util.run_and_log(log,
> +            'mkfs {0} {1}'.format(mkfsopts, self.imagename))
> +
> +    def create_file(self, log, filename):

Please add a short comment on each non-function describing what it
does and what the args are (and return value if any).

> +        md5sums = []
> +        with open(self.mountpath + "/" + filename, 'w') as fd:

I think this is better as os.path.join(self.mountpath, filename)

> +            for stride in files[filename]:
> +                length = int(stride[1] - stride[0])
> +                data = bytearray(random.getrandbits(8) for _ in xrange(length))
> +                md5 = hashlib.md5(data).hexdigest()
> +                md5sums.append(md5)
> +                log.info("{0}: write {1} bytes @ {2} : {3}".format(
> +                    filename, int(stride[1] - stride[0]),
> +                    int(stride[0]), md5))
> +                fd.seek(stride[0])
> +                fd.write(data);
> +        self.md5s[filename] = md5sums
> +
> +    def create_files(self, log):
> +        with log.section("Create initial files"):
> +            for filename in files:
> +                self.create_file(log, filename)
> +            log.info("Created test files in {0}".format(self.mountpath))
> +            util.run_and_log(log, 'ls -la {0}'.format(self.mountpath))
> +            util.run_and_log(log, 'sync {0}'.format(self.mountpath))
> +
> +    def mount(self, log):
> +        if not os.path.exists(self.mountpath):
> +            os.mkdir(self.mountpath)
> +        log.info("Mounting {0} at {1}".format(self.imagename, self.mountpath))
> +        if self.fstype == "ext4":
> +            cmd = 'sudo -n mount -o loop,rw {0} {1}'.format(self.imagename, self.mountpath)
> +        else:
> +            cmd = 'sudo -n mount -o loop,rw,umask=000 {0} {1}'.format(self.imagename, self.mountpath)
> +        util.run_and_log(log, cmd)
> +        if self.fstype == "ext4":
> +            cmd = 'sudo -n chmod og+rw {0}'.format(self.mountpath)
> +            return util.run_and_log(log, cmd)
> +
> +    def unmount(self, log):
> +        log.info("Unmounting {0}".format(self.imagename))
> +        cmd = 'sudo -n umount -l {0}'.format(self.mountpath)
> +        util.run_and_log(log, cmd, ignore_errors=True)
> +
> +
> +@pytest.fixture(scope="module", params=["fat", "ext4"])
> +def fsimage(prereq_commands, u_boot_config, u_boot_log, request):
> +    datadir = u_boot_config.result_dir + '/'
> +    fstype = request.param
> +    imagename = datadir + "3GB." + fstype + ".img"
> +    mountpath = datadir + "mnt_" + fstype
> +
> +    with u_boot_log.section('Create image {0}'.format(imagename)):
> +        fsimage = FsImage(fstype, imagename, mountpath)
> +        fsimage.mkfs(u_boot_log)
> +
> +    yield fsimage
> +    fsimage.unmount(u_boot_log)
> +
> +@pytest.fixture(scope="module")
> +def populated_image(fsimage, u_boot_log):
> +    try:
> +        fsimage.mount(u_boot_log)
> +    except Exception as e:
> +        pytest.skip('{0}: could not mount {1}'.format(
> +            fsimage.fstype, fsimage.imagename))
> +        yield None
> +
> +    fsimage.create_files(u_boot_log)
> +    fsimage.unmount(u_boot_log)
> +    yield fsimage
> +
> +# 'Transfer' the image to the client and make it accessible

Please see other files to see how function comments should be formatted.

> +@pytest.fixture(scope="function")
> +def boundimage(populated_image, u_boot_console, request):
> +    image = populated_image
> +    if request.cls.scenario == "hostfs":
> +        image.mount(u_boot_console.log)
> +        image.rootpath = image.mountpath + "/"
> +        yield image
> +        image.unmount(u_boot_console.log)
> +    else:
> +        output = u_boot_console.run_command_list(
> +            ["host bind 0 {0}".format(image.imagename)])
> +        image.rootpath = "/"
> +        yield image
> +        output = u_boot_console.run_command_list(["host bind 0 "])
> +
> +
> +# Dummy test to create an image file with filesystem
> +# Useful to isolate fixture setup from actual tests
> +def test_fs_prepare_image(u_boot_config, fsimage, request):
> +    if not fsimage:
> +        pytest.fail("Failed to create image")
> +
> +# Dummy test to create initial filesystem contents
> +def test_fs_populate_image(populated_image, request):
> +    if not populated_image:
> +        pytest.fail("Failed create initial image content")
> +
> +# Scenarios:
> +#   hostfs: access image contents through the sandbox hostfs
> +#       facility, using the filesytem implementation of
> +#       the sandbox host, e.g. Linux kernel
> +#   generic: test u-boots native filesystem implementations,
> +#       using the 'generic' command names, e.g. 'load'
> +#   TODO -
> +#   fscommands: test u-boots native filesystem implementations,
> +#       using the fs specific commands, e.g. 'ext4load'
> +@pytest.fixture(scope="class", params=["generic", "hostfs"])
> +def scenario(request):
> +    request.cls.scenario = request.param
> +    return request.param
> +
> +@pytest.mark.usefixtures("u_boot_console", "scenario")
> +class TestFilesystems:
> +    ignore_cleanup_errors = True
> +    filesize_regex = re.compile("^filesize=([A-Fa-f0-9]+)")
> +    md5sum_regex = re.compile("^md5 for .* ==> ([A-Fa-f0-9]{32})")
> +    dirlist_regex = re.compile("\s+(\d+)\s+(\S+.file\S*)")

Should these be self. ?

> +
> +    def get_filesize(self, filename):
> +        strides = files[filename]
> +        return int(strides[-1][1])
> +
> +    def check_dirlist(self, string, filenames):
> +        m = self.dirlist_regex.findall(string)
> +        assert(m)
> +        for i, e in enumerate(m):
> +            m[i] = (int(e[0]), e[1].lower())
> +        for f in filenames:
> +            e = (self.get_filesize(f), f.lower())
> +            assert(e in m)
> +
> +    def check_filesize(self, string, size):
> +        m = self.filesize_regex.match(string)
> +        assert(m)
> +        assert(int(m.group(1), 16) == size)
> +
> +    def check_md5sum(self, string, md5):
> +        m = self.md5sum_regex.match(string)
> +        assert(m)
> +        assert(len(m.group(1)) == 32)
> +        assert(m.group(1) == md5)
> +
> +    def run_listcmd(self, rootpath, dirname):
> +        cmd = "{0}{1} {2} {3}".format(
> +            self.fs_params.get('prefix'),
> +            self.fs_commands.get('listcmd'),
> +            self.fs_params.get('interface'),
> +            rootpath + dirname)
> +        with self.console.log.section('List "{0}"'.format(dirname)):
> +            output = self.console.run_command_list([cmd])
> +            return output[0]
> +
> +    def run_readcmd(self, rootpath, filename, offset, length):
> +        cmd = "{0}{1} {2} {3} {4} 0x{5:x} 0x{6:x}".format(
> +            self.fs_params.get('prefix'),
> +            self.fs_commands.get('readcmd'),
> +            self.fs_params.get('interface'),
> +            "0", # address
> +            rootpath + filename,
> +            length, offset)
> +        with self.console.log.section('Read file "{0}"'.format(filename)):
> +            output = self.console.run_command_list(
> +                [cmd, "env print filesize",
> +                 "md5sum 0 $filesize", "env set filesize"])
> +            return output[1:3]
> +
> +    def run_sizecmd(self, rootpath, filename):
> +        cmd = "{0}{1} {2} {3}".format(
> +            self.fs_params.get('prefix'),
> +            self.fs_commands.get('sizecmd'),
> +            self.fs_params.get('interface'),
> +            rootpath + filename)
> +        with self.console.log.section('Get size of "{0}"'.format(filename)):
> +            output = self.console.run_command_list(
> +                [cmd, "env print filesize", "env set filesize"])
> +            return output[1]
> +
> +    @pytest.mark.parametrize("dirname", ["", "./"])
> +    def test_fs_ls(self, boundimage, u_boot_console, dirname):
> +        self.console = u_boot_console
> +        self.fs_params = cmd_parameters.get(self.scenario)
> +        self.fs_commands = fs_commands.get(boundimage.fstype)
> +
> +        output = self.run_listcmd(boundimage.rootpath, dirname)
> +        self.check_dirlist(output, files.keys())
> +
> +    @pytest.mark.parametrize("filename", files.keys())
> +    def test_fs_filesize(self, boundimage, u_boot_console, filename):
> +        self.console = u_boot_console
> +        self.fs_params = cmd_parameters.get(self.scenario)
> +        self.fs_commands = fs_commands.get(boundimage.fstype)
> +        filesize = self.get_filesize(filename)
> +
> +        output = self.run_sizecmd(boundimage.rootpath, filename)
> +        self.check_filesize(output, filesize)
> +
> +    @pytest.mark.parametrize("filename", files.keys())
> +    def test_fs_read(self, boundimage, u_boot_console, filename):
> +        self.console = u_boot_console
> +        self.fs_params = cmd_parameters.get(self.scenario)
> +        self.fs_commands = fs_commands.get(boundimage.fstype)
> +        md5s = boundimage.md5s[filename]
> +
> +        for i, stride in enumerate(files[filename]):
> +            length = int(stride[1]) - int(stride[0])
> +            output = self.run_readcmd(
> +                boundimage.rootpath, filename, int(stride[0]), length)
> +            self.check_filesize(output[0], length)
> +            self.console.log.info("md5: {0}".format(md5s[i]))
> +            self.check_md5sum(output[1], md5s[i])
> +
> +    @pytest.mark.parametrize("filename", files.keys())
> +    def test_fs_read_head(self, boundimage, u_boot_console, filename):
> +        self.console = u_boot_console
> +        self.fs_params = cmd_parameters.get(self.scenario)
> +        self.fs_commands = fs_commands.get(boundimage.fstype)
> +
> +        filesize = self.get_filesize(filename)
> +        filesize = min(filesize, 4e6)
> +
> +        output = self.run_readcmd(
> +            boundimage.rootpath, filename, 0, filesize)
> +        self.check_filesize(output[0], filesize)
> --
> 2.10.1
>

Regards,
Simon