Add test mecanism for FileManager (TreeScript)

Author: AbcSxyZ

test/test_file_manager.py

@@ -0,0 +1,19 @@
+import unittest
+from tree_generator import TreeScript
+
+class FileManagerTest(unittest.TestCase):
+ maxDiff = None
+
+ def run_script(self, script_file):
+ """
+ Perform test from a single tree script.
+ """
+ script_manager = TreeScript(script_file)
+ try:
+ result_tree, expected_tree = script_manager.launch()
+ finally:
+ script_manager.clean()
+ self.assertEqual(str(result_tree), str(expected_tree))
+
+ def test_first(self):
+ self.run_script("test/tree_script/test.txt")

test/tree_generator/__init__.py

@@ -0,0 +1 @@
+from .tree_script import TreeScript

test/tree_generator/file_utils.py

@@ -0,0 +1,168 @@
+import os
+import shutil
+import difflib
+from pathlib import Path
+
+class Workdir:
+ """
+ Context manager to switch working directory safely.
+ """
+ def __init__(self, directory):
+ self.destination_dir = directory
+
+ if not os.path.exists(directory):
+ Path(directory).mkdir()
+
+ def __enter__(self):
+ self._old_pwd = os.getcwd()
+ os.chdir(self.destination_dir)
+ 
+ def __exit__(self, *args, **kwargs):
+ os.chdir(self._old_pwd)
+
+class TaggedFile:
+ """
+ Represent a single file with his corresponding
+ subfolder level.
+
+ Used to facitilate tagging of tree/folder exploration.
+ """
+ def __init__(self, filename, level, isdir=None):
+ if isdir is None:
+ isdir = filename.endswith("/")
+
+ self.isdir = isdir
+ self.level = level
+ self.filename = self.clean_filename(filename)
+
+ @staticmethod
+ def clean_filename(filename):
+ if filename.endswith("/"):
+ filename = filename[:-1]
+ return filename.replace('|-', "").strip()
+
+class Directory:
+ """
+ Represent a single directory, with all availables files
+ and directories inside the given folder.
+
+ Understand which folder is a directory, and will store
+ directory childrens, subfolder also use Directory.
+ """
+ def __init__(self, name, potential_files, level=-1):
+ self.name = name
+ self.level = level
+ self.potential_files = potential_files
+
+ self.files = []
+ self.directories = []
+
+ self._retrieve_directory_files()
+ self._sort()
+
+
+ def generate(self):
+ """
+ Create each file and directory expected by
+ the given template.
+ """
+ with Workdir(self.name):
+ for directory in self.directories:
+ directory.generate()
+
+ for filename in self.files:
+ Path(filename).touch()
+
+ def delete(self):
+ """
+ Delete Directory folder
+ """
+ shutil.rmtree(self.name)
+
+ def diff(self, other):
+ """
+ Compare two different document, an return diff output.
+
+ Use the string representation of Directory to perform
+ comparaison.
+ With alphabetical sort and identical files/folder,
+ it must be the same.
+ """
+ self_repr = str(self).split("\n")
+ other_repr = str(other).split("\n")
+ res_diff = difflib.ndiff(self_repr, other_repr)
+ diff_ouput = "+ : Program output\n- : Reference output\n\n"
+ return diff_ouput + "\n".join(res_diff)
+
+
+ def __eq__(self, other):
+ return str(self) == str(other)
+
+ def __str__(self):
+ return self.__repr__()
+
+ def __repr__(self):
+ """
+ Print directory as a tree. Create back equivalent
+ of the template script file.
+
+ To be ordered, display sub folder, followed by regular files.
+ All directory and files are sorted in alphabetical order.
+ """
+ # Convert back Directory object to his string representation
+ directory_repr = ""
+
+ #Format Directory name
+ if self.name and self.level >= 0:
+ #add indentation and '|-' on left side
+ directory_repr = " " * self.level
+ directory_repr += "|- " if self.level else ""
+
+ directory_repr += self.name + "/\n"
+
+ #Recursive formatting of sub folders
+ for sub_directory in self.directories:
+ directory_repr += repr(sub_directory)
+
+ #Format all regular files
+ for filename in self.files:
+ #add indentation and '|-' on left side
+ directory_repr += " " * (self.level + 1)
+ directory_repr += "|- " if self.level > 0 else ""
+
+ directory_repr += filename + "\n"
+
+ return directory_repr
+
+ def _sort(self):
+ """
+ Order alphabetically files and directories.
+ """
+ self.directories.sort(key=lambda directory : directory.name)
+ self.files.sort()
+ 
+ (directory._sort() for directory in self.directories)
+
+ def _retrieve_directory_files(self):
+ """
+ Indentify files and directories inside the current
+ directory.
+ """
+ for index, tagged_file in enumerate(self.potential_files):
+ #Element contained by the directory
+ if tagged_file.level == self.level + 1:
+ if tagged_file.isdir:
+ new_dir = Directory(
+ tagged_file.filename,
+ self.potential_files[index + 1:],
+ self.level + 1, 
+ )
+ self.directories.append(new_dir)
+
+ else:
+ self.files.append(tagged_file.filename)
+
+ ## Stop iteration if actual file in template list
+ ## is a parent folder
+ elif tagged_file.level == self.level:
+ break

test/tree_generator/tree_script.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+from bss_converter.file_manager import FileManager
+from .file_utils import TaggedFile, Directory, Workdir
+import shutil
+import difflib
+import os
+import re
+
+
+class ScriptFormatError(Exception):
+ pass
+
+class TreeScript:
+ """
+ Parse template of tree, generate file
+ and folders of the template, to compare moved files moved by
+ FileManager class.
+ """
+ DJANGO_DIR = os.path.realpath("tmp_django")
+ BSS_DIR = "tmp_bss"
+ def __init__(self, script_file):
+ # Fix folder name at the top of template
+ # represent Boostrap Studio export folder or
+ # a django project folder.
+ script, reference = self.from_script(script_file)
+ self.script = Directory(self.BSS_DIR, script)
+ self.reference = Directory('django', reference)
+
+ def launch(self):
+ #Create fake bss and django project
+ self.script.generate()
+ self.emulate_django_project()
+
+ os.environ["DJANGO_PROJECT"] = self.DJANGO_DIR
+
+ with Workdir(self.BSS_DIR):
+ FileManager()
+ result_folders = self.from_directory(self.DJANGO_DIR)
+ result_tree = Directory("django_result", result_folders)
+
+ return self.reference, result_tree
+
+ def clean(self):
+ shutil.rmtree(self.BSS_DIR, ignore_errors=True)
+ shutil.rmtree(self.DJANGO_DIR, ignore_errors=True)
+
+ @staticmethod
+ def file_indent(filename):
+ """
+ Find space size of left indentation.
+ """
+ return len(filename) - len(filename.lstrip())
+
+ def tag_folder_lvl(self, list_file):
+ """
+ Tag to each line a folder lvl, to understand subfolders
+ are organized.
+
+ Return list of line with tag number:
+ ex:
+ [ 
+ (0, "assets/"),
+ (1, "img/"),
+ (2, "logo.png"),
+ (1, "js/"),
+ ...
+ ]
+
+ Is equivalent to:
+
+ assets/
+ |- img/
+ |- logo.png
+ |- js/
+ """
+ tagged_lines = []
+ real_folder_lvl = 0
+
+ #Match a specific spacing with a folder level.
+ #Expect having file from a same level to have
+ #exact same number of spaces/tabulations
+ available_levels = {
+ 0:real_folder_lvl,
+ }
+
+ # Go through each line, find left space in the line,
+ # and use this spaces to tag a folder level
+ # using `available_levels`
+ for filename in list_file:
+ file_indent = self.file_indent(filename)
+ if file_indent not in available_levels:
+ real_folder_lvl += 1
+ available_levels[file_indent] = real_folder_lvl
+
+ current_folder_lvl = available_levels[file_indent]
+
+ file_info = TaggedFile(filename, current_folder_lvl)
+ tagged_lines.append(file_info)
+ 
+ return tagged_lines
+
+ def from_script(self, script_file):
+ """
+ Read strip and clean unexpected content.
+
+ Clean apply:
+ - split test and result tree
+ - right strip every line
+ """
+ with open(script_file) as script_stream:
+ self.apps = self.find_apps(script_stream.readline())
+ script_content = script_stream.read()
+
+ # Split test tree from a reference tree
+ # Delimited by EQUAL, delimited with some equal sign.
+ # 
+ # Example (see tests):
+ # =================== EQUAL ====================
+ test_script, result_script = re.split("=+\s*EQUAL\s*=+",
+ script_content, 
+ flags=re.IGNORECASE)
+
+ def clean_script(self, script):
+ line_split_script = script.strip().split("\n")
+ rstripped_lines = map(str.rstrip, line_split_script)
+ return self.tag_folder_lvl(rstripped_lines)
+
+ test_script = clean_script(self, test_script)
+ result_script = clean_script(self, result_script)
+
+ return test_script, result_script
+
+ def find_apps(self, app_config):
+ """
+ Retrieve list of django application, in the fist
+ line of a script.
+ """
+ if not app_config.startswith("apps="):
+ raise ScriptFormatError("Please specify script applications,"
+ " using 'apps=' at the first line.")
+ apps_string = app_config.split("=")[1].strip()
+ apps = apps_string.split(",")
+ return list(filter("".__ne__, apps))
+
+ def emulate_django_project(self):
+ """
+ Create folder structure of a django project, to
+ emulate file migration.
+
+ Create single folder for each specified apps.
+
+ App configuration is given in the first line of a test
+ script, with a format like:
+
+ apps=django-app[settings],app1,app2[,...]
+
+ - [settings] is used to generates a settings.py file in app.
+ """
+ with Workdir(self.DJANGO_DIR):
+ for application in self.apps:
+
+ #Check which app represent the settings module
+ is_setting = False
+ if "[settings]" in application:
+ application = application.replace(
+ "[settings]", ""
+ )
+ is_setting = True
+ 
+ #Create application folder in any case
+ Path(application).mkdir()
+
+ # Add settings.py in expected application
+ if is_setting:
+ settings_file = os.path.join(
+ application, "settings.py")
+ Path(settings_file).touch()
+
+ def from_directory(self, directory_name, level=0):
+ """
+ Create a template from an existing directory.
+ Generate tagged list with subfolder level,
+ equivalent to `TreeScript.tag_folder_lvl`
+ """
+ list_files = []
+ for filename in os.listdir(directory_name):
+ relativ_file = os.path.join(directory_name, filename)
+ is_dir = os.path.isdir(relativ_file)
+
+ list_files.append(TaggedFile(filename, level, is_dir))
+
+ if is_dir:
+ sub_files = self.from_directory(relativ_file,
+ level + 1)
+ list_files.extend(sub_files)
+ return list_files