"""
This module contains a fake implementation of the Case class that can be used
for testing the tests.
"""
import os
from copy import deepcopy
[docs]
class CaseFake(object):
def __init__(self, case_root, create_case_root=True):
"""
Initialize a new case object for the given case_root directory.
Args:
case_root (str): path to CASEROOT
create_case_root (bool): If True, creates the directory given by case_root
"""
self.vars = dict()
if create_case_root:
os.makedirs(case_root)
self.set_value("CASEROOT", case_root)
casename = os.path.basename(case_root)
# Typically, CIME_OUTPUT_ROOT is independent of the case. Here,
# we nest it under CASEROOT so that (1) tests don't interfere
# with each other; (2) a cleanup that removes CASEROOT will also
# remove CIME_OUTPUT_ROOT.
self.set_value("CIME_OUTPUT_ROOT", os.path.join(case_root, "CIME_OUTPUT_ROOT"))
self.set_value("CASE", casename)
self.set_value("CASEBASEID", casename)
self.set_value("RUN_TYPE", "startup")
self.set_exeroot()
self.set_rundir()
[docs]
def set_initial_test_values(self):
pass
[docs]
def get_value(self, item):
"""
Get the value of the given item
Returns None if item isn't set for this case
Args:
item (str): variable of interest
"""
return self.vars.get(item)
[docs]
def set_value(self, item, value):
"""
Set the value of the given item to the given value
Args:
item (str): variable of interest
value (any type): new value for item
"""
self.vars[item] = value
[docs]
def copy(self, newcasename, newcaseroot):
"""
Create and return a copy of self, but with CASE and CASEBASEID set to newcasename,
CASEROOT set to newcaseroot, and RUNDIR set appropriately.
Args:
newcasename (str): new value for CASE
newcaseroot (str): new value for CASEROOT
"""
newcase = deepcopy(self)
newcase.set_value("CASE", newcasename)
newcase.set_value("CASEBASEID", newcasename)
newcase.set_value("CASEROOT", newcaseroot)
newcase.set_exeroot()
newcase.set_rundir()
return newcase
[docs]
def create_clone(
self,
newcase,
keepexe=False,
mach_dir=None,
project=None,
cime_output_root=None,
exeroot=None,
rundir=None,
):
# Need to disable unused-argument checking: keepexe is needed to match
# the interface of Case, but is not used in this fake implementation
#
# pylint: disable=unused-argument
"""
Create a clone of the current case. Also creates the CASEROOT directory
for the clone case (given by newcase).
Args:
newcase (str): full path to the new case. This directory should not
already exist; it will be created
keepexe (bool, optional): Ignored
mach_dir (str, optional): Ignored
project (str, optional): Ignored
cime_output_root (str, optional): New CIME_OUTPUT_ROOT for the clone
exeroot (str, optional): New EXEROOT for the clone
rundir (str, optional): New RUNDIR for the clone
Returns the clone case object
"""
newcaseroot = os.path.abspath(newcase)
newcasename = os.path.basename(newcase)
os.makedirs(newcaseroot)
clone = self.copy(newcasename=newcasename, newcaseroot=newcaseroot)
if cime_output_root is not None:
clone.set_value("CIME_OUTPUT_ROOT", cime_output_root)
if exeroot is not None:
clone.set_value("EXEROOT", exeroot)
if rundir is not None:
clone.set_value("RUNDIR", rundir)
return clone
[docs]
def make_rundir(self):
"""
Make directory given by RUNDIR
"""
os.makedirs(self.get_value("RUNDIR"))
[docs]
def set_exeroot(self):
"""
Assumes CASEROOT is already set; sets an appropriate EXEROOT
(nested inside CASEROOT)
"""
self.set_value("EXEROOT", os.path.join(self.get_value("CASEROOT"), "bld"))
[docs]
def set_rundir(self):
"""
Assumes CASEROOT is already set; sets an appropriate RUNDIR (nested
inside CASEROOT)
"""
self.set_value("RUNDIR", os.path.join(self.get_value("CASEROOT"), "run"))
[docs]
def case_setup(self, clean=False, test_mode=False, reset=False):
pass
[docs]
def load_env(self, reset=False):
pass
def __enter__(self):
pass
def __exit__(self, *_):
pass