def main():
create_dir(docgen)
build_helper()
tutorial()
schemas()
introspection_cmds()
def generate_tests(prefix, cmd_dict):
create_dir(os.path.join(docgen, prefix))
for k, v in cmd_dict.items():
out = run(v)
out = f"$ {v} \n" + out
fname = os.path.join(docgen, k)
write_file(fname, out)
print(f"Writing File: {fname}")
def test_create_dir(tmp_path):
# since tmp_path creates a directory we will create a subdirectory "test" in tmp_path using create_dir
assert is_dir(tmp_path)
dirname = os.path.join(tmp_path, "test")
# check we dont have a directory before creation
assert not is_dir(dirname)
# creating directory
create_dir(dirname)
# check if directory is created after invoking create_dir
assert is_dir(dirname)
with pytest.raises(BuildTestError):
create_dir("/xyz")
def _build_setup(self):
"""This method is the setup operation to get ready to build test which
includes getting unique build id, setting up metadata object to store
test details such as where test will be located and directory of test.
This section cannot be reached without a valid, loaded recipe.
"""
create_dir(self.testdir)
num_content = len(os.listdir(self.testdir))
# the testid is incremented for every run, this can be done by getting
# length of all files in testdir and creating a directory. Subsequent
# runs will increment this counter
self.test_id = os.path.join(self.testdir, str(num_content))
create_dir(self.test_id)
self.stage_dir = os.path.join(self.test_id, "stage")
self.run_dir = os.path.join(self.test_id, "run")
# create stage and run directories
create_dir(self.stage_dir)
create_dir(self.run_dir)
self.logger.debug("Creating the stage directory: %s ", self.stage_dir)
self.logger.debug("Creating the run directory: %s", self.run_dir)
# Derive the path to the test script
self.metadata["testpath"] = "%s.%s" % (
os.path.join(self.stage_dir, "generate"),
self.get_test_extension(),
)
self.metadata["testpath"] = os.path.expandvars(
self.metadata["testpath"])
self.metadata["testroot"] = self.test_id
def resolve_testdirectory(buildtest_configuration, cli_testdir=None):
"""This method resolves which test directory to select. For example, one
can specify test directory via command line ``buildtest build --testdir <path>``
or path in configuration file. The default is $BUILDTEST_ROOT/var/tests
:param buildtest_configuration: loaded buildtest configuration as a dict.
:type buildtest_configuration: dict
:param cli_testdir: test directory from command line ``buildtest build --testdir``
:type cli_testdir: str
:return: Path to test directory to use
:rtype: str
"""
prefix = buildtest_configuration.get("testdir")
# variable to set test directory if prefix is set
prefix_testdir = None
if prefix:
prefix = resolve_path(prefix, exist=False)
if prefix:
prefix_testdir = prefix
if cli_testdir:
# resolve full path for test directory specified by --testdir option
cli_testdir = resolve_path(cli_testdir, exist=False)
# Order of precedence when detecting test directory
# 1. Command line option --testdir
# 2. Configuration option specified by 'testdir'
# 3. Defaults to $BUILDTEST_ROOT/var/tests
test_directory = (cli_testdir or prefix_testdir
or os.path.join(BUILDTEST_ROOT, "var", "tests"))
if not test_directory:
raise BuildTestError(
"Invalid value for test directory, please specify a valid directory path through command line (--testdir) or configuration file"
)
create_dir(test_directory)
return test_directory
def setup(self):
"""This method creates directory ``var/executors/<executor-name>``
for every executor defined in buildtest configuration and write scripts
before_script.sh and after_script.sh if the fields ``before_script``
and ``after_script`` are specified in executor section. This method
is called after executors are initialized in the class **__init__**
method.
"""
for executor_name in self.executors.keys():
create_dir(os.path.join(executor_root, executor_name))
executor_settings = self.executors[executor_name]._settings
# if before_script field defined in executor section write content to var/executors/<executor>/before_script.sh
file = os.path.join(executor_root, executor_name,
"before_script.sh")
content = executor_settings.get("before_script") or ""
write_file(file, content)
# after_script field defined in executor section write content to var/executors/<executor>/after_script.sh
file = os.path.join(executor_root, executor_name,
"after_script.sh")
content = executor_settings.get("after_script") or ""
write_file(file, content)
def update_report(valid_builders):
"""This method will update BUILD_REPORT after every test run performed
by ``buildtest build``. If BUILD_REPORT is not created, we will create
file and update json file by extracting contents from builder.metadata
:param valid_builders: builder object that were successful during build and able to execute test
:type valid_builders: instance of BuilderBase (subclass)
"""
if not is_file(os.path.dirname(BUILD_REPORT)):
create_dir(os.path.dirname(BUILD_REPORT))
# if file exists, read json file otherwise set report to empty dict
try:
with open(BUILD_REPORT, "r") as fd:
report = json.loads(fd.read())
except OSError:
report = {}
for builder in valid_builders:
buildspec = builder.metadata["buildspec"]
name = builder.metadata["name"]
entry = {}
report[buildspec] = report.get(buildspec) or {}
report[buildspec][name] = report.get(buildspec, {}).get(name) or []
# query over attributes found in builder.metadata, we only assign
# keys that we care obout for reporting
for item in [
"id",
"full_id",
"testroot",
"testpath",
"command",
"outfile",
"errfile",
"schemafile",
"executor",
]:
entry[item] = builder.metadata[item]
entry["tags"] = ""
# convert tags to string if defined in buildspec
if builder.metadata["tags"]:
if isinstance(builder.metadata["tags"], list):
entry["tags"] = " ".join(builder.metadata["tags"])
else:
entry["tags"] = builder.metadata["tags"]
# query over result attributes, we only assign some keys of interest
for item in ["starttime", "endtime", "runtime", "state", "returncode"]:
entry[item] = builder.metadata["result"][item]
entry["output"] = builder.metadata["output"]
entry["error"] = builder.metadata["error"]
entry["job"] = builder.metadata.get("job") or None
report[buildspec][name].append(entry)
with open(BUILD_REPORT, "w") as fd:
json.dump(report, fd, indent=2)
def main():
"""Entry point to buildtest."""
if not os.getenv("BUILDTEST_COLOR"):
os.environ["BUILDTEST_COLOR"] = "True"
# create a temporary file to store logfile and we don't delete file by setting 'delete=False'
# by default tempfile will delete file upon exit.
tf = tempfile.NamedTemporaryFile(prefix="buildtest_",
delete=False,
suffix=".log")
dest_logfile = tf.name
logger = init_logfile(dest_logfile)
logger.info("Starting buildtest log")
create_dir(BUILDTEST_USER_HOME)
create_dir(var_root)
# Create a build test system, and check requirements
# BuildTestSystem()
system.check()
parser = BuildTestParser()
args = parser.parse_options()
if args.debug:
streamlog(args.debug)
if args.subcommands == "build":
# settings_file = resolve_settings_file(args.config)
# check_settings(args.config)
cmd = BuildTest(
config_file=args.config,
buildspecs=args.buildspec,
exclude_buildspecs=args.exclude,
executors=args.executor,
tags=args.tags,
filter_tags=args.filter_tags,
rebuild=args.rebuild,
stage=args.stage,
testdir=args.testdir,
)
cmd.build()
logdir = buildtest_configuration.target_config.get("logdir")
if not logdir:
print(f"Writing Logfile to: {dest_logfile}")
sys.exit(0)
logdir = resolve_path(logdir, exist=False)
if logdir:
create_dir(logdir)
fname = os.path.basename(dest_logfile)
logpath = os.path.join(logdir, fname)
shutil.copy2(dest_logfile, logpath)
print(f"Writing Logfile to: {logpath}")
else:
print(f"Writing Logfile to: {dest_logfile}")
# store copy of logfile at $BUILDTEST_ROOT/buildtest.log. A convenient location for user to
# find logfile for last build, this will be overwritten for every subsequent build.
shutil.copy2(
dest_logfile,
os.path.join(os.getenv("BUILDTEST_ROOT"), "buildtest.log"))
return
settings_file = resolve_settings_file()
logger.info(f"Processing buildtest configuration file: {settings_file}")
check_settings(settings_file)
# implementation for 'buildtest buildspec find'
if args.subcommands == "buildspec":
buildspec_find(args=args, settings_file=settings_file)
return
if args.subcommands and args.func:
args.func(args)
def main():
"""Entry point to buildtest."""
# create a temporary file to store logfile and we don't delete file by setting 'delete=False'
# by default tempfile will delete file upon exit.
tf = tempfile.NamedTemporaryFile(prefix="buildtest_",
delete=False,
suffix=".log")
dest_logfile = tf.name
logger = init_logfile(dest_logfile)
logger.info("Starting buildtest log")
create_dir(BUILDTEST_USER_HOME)
create_dir(var_root)
# Create a build test system, and check requirements
# BuildTestSystem()
system.check()
parser = BuildTestParser()
args = parser.parse_options()
if args.debug:
streamlog(args.debug)
# invoking load_settings will attempt to initialize buildtest settings and
# load the schema
settings_file = resolve_settings_file()
logger.info(f"Processing buildtest configuration file: {settings_file}")
buildtest_configuration = check_settings(settings_file,
retrieve_settings=True)
if args.subcommands == "build":
func_build_subcmd(args, buildtest_configuration)
else:
if args.subcommands and args.func:
args.func(args)
return
logdir = buildtest_configuration.get("logdir")
if not logdir:
print(f"Writing Logfile to: {dest_logfile}")
sys.exit(0)
logdir = resolve_path(logdir, exist=False)
if logdir:
create_dir(logdir)
fname = os.path.basename(dest_logfile)
logpath = os.path.join(logdir, fname)
shutil.copy2(dest_logfile, logpath)
print(f"Writing Logfile to: {logpath}")
else:
print(f"Writing Logfile to: {dest_logfile}")
# store copy of logfile at $BUILDTEST_ROOT/buildtest.log. A convenient location for user to
# find logfile for last build, this will be overwritten for every subsequent build.
shutil.copy2(dest_logfile,
os.path.join(os.getenv("BUILDTEST_ROOT"), "buildtest.log"))
