def run_case(self, base_case_root, run_type, run_length, overwrite=False):
user_mods_dirs = [
os.path.join(self.cesmroot, "cime_config", "usermods_dirs", "NEON",
self.name)
]
expect(os.path.isdir(base_case_root),
"Error base case does not exist in {}".format(base_case_root))
case_root = os.path.abspath(
os.path.join(base_case_root, "..", self.name + "." + run_type))
if os.path.isdir(case_root) and overwrite:
logger.info("---- removing the existing case -------")
shutil.rmtree(case_root)
if not os.path.isdir(case_root):
# read_only = False should not be required here
with Case(base_case_root, read_only=False) as basecase:
logger.info(
"---- cloning the base case in {}".format(case_root))
basecase.create_clone(case_root,
keepexe=True,
user_mods_dirs=user_mods_dirs)
with Case(case_root, read_only=False) as case:
case.set_value("STOP_OPTION", "nyears")
case.set_value("STOP_N", run_length)
case.set_value("REST_N", 100)
case.set_value("CONTINUE_RUN", False)
if run_type == "ad":
case.set_value("CLM_FORCE_COLDSTART", "on")
case.set_value("CLM_ACCELERATED_SPINUP", "on")
case.set_value("RUN_REFDATE", "0018-01-01")
case.set_value("RUN_STARTDATE", "0018-01-01")
def test_submit(self, read_xml, get_value, init, _submit): # pylint: disable=unused-argument
with tempfile.TemporaryDirectory() as tempdir:
get_value.side_effect = [
tempdir,
tempdir,
True,
"baseid",
None,
True,
]
make_valid_case(tempdir)
with Case(tempdir) as case:
case.submit(chksum=True)
_submit.assert_called_with(
case,
job=None,
no_batch=False,
prereq=None,
allow_fail=False,
resubmit=False,
resubmit_immediate=False,
skip_pnl=False,
mail_user=None,
mail_type=None,
batch_args=None,
workflow=True,
chksum=True,
)
def test_cmd_arg(self, get_value, flush, init): # pylint: disable=unused-argument
Case._force_read_only = False # pylint: disable=protected-access
mocked_open = mock.mock_open()
with self.tempdir as tempdir, mock.patch("CIME.case.case.open",
mocked_open):
with Case(tempdir) as case:
get_value.side_effect = [
tempdir,
"/src",
]
# We didn't need to make tempdir look like a valid case for the Case
# constructor because we mock that constructor, but we *do* need to make
# it look like a valid case for record_cmd.
make_valid_case(tempdir)
case.record_cmd(["/some/custom/command", "arg1"])
expected = [
"/some/custom/command arg1\n\n",
]
handle = mocked_open()
handle.writelines.assert_called_with(expected)
def test_create(self, get_user, getfqdn, configure, create_caseroot, # pylint: disable=unused-argument
apply_user_mods, set_lookup_value, lock_file, strftime, # pylint: disable=unused-argument
read_xml): # pylint: disable=unused-argument
with self.tempdir as tempdir:
caseroot = os.path.join(tempdir, "test1")
with Case(caseroot, read_only=False) as case:
os.environ["CIME_MODEL"] = "cesm"
srcroot = os.path.abspath(os.path.join(
os.path.dirname(__file__), "../../../../../"))
case.create("test1", srcroot, "A", "f19_g16_rx1",
machine_name="ubuntu-latest")
# Check that they're all called
configure.assert_called_with("A", "f19_g16_rx1",
machine_name="ubuntu-latest",
project=None, pecount=None,
compiler=None, mpilib=None,
pesfile=None, gridfile=None,
multi_driver=False, ninst=1,
test=False, walltime=None,
queue=None, output_root=None,
run_unsupported=False, answer=None,
input_dir=None, driver=None,
workflowid="default",
non_local=False,
extra_machines_dir=None,
case_group=None)
create_caseroot.assert_called()
apply_user_mods.assert_called()
lock_file.assert_called()
set_lookup_value.assert_called_with("CASE_HASH",
"134a939f62115fb44bf08a46bfb2bd13426833b5c8848cf7c4884af7af05b91a")
def test_sub_relative(self, strftime, get_value, flush, init): # pylint: disable=unused-argument
Case._force_read_only = False # pylint: disable=protected-access
mocked_open = mock.mock_open()
with self.tempdir as tempdir, mock.patch("CIME.case.case.open",
mocked_open):
with Case(tempdir) as case:
get_value.side_effect = [
tempdir,
"/src"
]
case.record_cmd(init=True)
expected = [
"#!/bin/bash\n\n",
"set -e\n\n",
"# Created 00:00:00\n\n",
"CASEDIR=\"{}\"\n\n".format(tempdir),
"/src/scripts/create_newcase\n\n",
"cd \"${CASEDIR}\"\n\n",
]
handle = mocked_open()
handle.writelines.assert_called_with(expected)
def bless_history(test_name, test_dir, baseline_name, baseline_root, report_only, force):
###############################################################################
with Case(test_dir) as case:
real_user = case.get_value("REALUSER")
with EnvironmentContext(USER=real_user):
if baseline_name is None:
baseline_name = case.get_value("BASELINE_NAME_CMP")
if not baseline_name:
baseline_name = CIME.utils.get_current_branch(repo=CIME.utils.get_cime_root())
if baseline_root is None:
baseline_root = case.get_value("BASELINE_ROOT")
baseline_full_dir = os.path.join(baseline_root, baseline_name, case.get_value("CASEBASEID"))
cmp_result, cmp_comments = compare_baseline(case, baseline_dir=baseline_full_dir, outfile_suffix=None)
if cmp_result:
logger.info("Diff appears to have been already resolved.")
return True, None
else:
logger.info(cmp_comments)
if (not report_only and
(force or six.moves.input("Update this diff (y/n)? ").upper() in ["Y", "YES"])):
gen_result, gen_comments = generate_baseline(case, baseline_dir=baseline_full_dir)
if not gen_result:
logger.warning("Hist file bless FAILED for test {}".format(test_name))
return False, "Generate baseline failed: {}".format(gen_comments)
else:
logger.info(gen_comments)
return True, None
else:
return True, None
def parse_input(argv):
###############################################################################
parser = argparse.ArgumentParser()
setup_standard_logging_options(parser)
parser.add_argument("caseroot", default=os.getcwd(),
help="Case directory")
parser.add_argument("libroot",
help="root for creating the library")
parser.add_argument("bldroot",
help="root for building library")
args = parse_args_and_handle_standard_logging_options(argv, parser)
# Some compilers have trouble with long include paths, setting
# EXEROOT to the relative path from bldroot solves the problem
# doing it in the environment means we don't need to change all of
# the component buildlib scripts
with Case(args.caseroot) as case:
os.environ["EXEROOT"] = os.path.relpath(case.get_value("EXEROOT"), args.bldroot)
return args.caseroot, args.libroot, args.bldroot
def set_ref_case(self, case):
rundir = case.get_value("RUNDIR")
case_root = case.get_value("CASEROOT")
if case_root.endswith(".postad"):
ref_case_root = case_root.replace(".postad", ".ad")
root = ".ad"
else:
ref_case_root = case_root.replace(".transient", ".postad")
root = ".postad"
expect(
os.path.isdir(ref_case_root),
"ERROR: spinup must be completed first, could not find directory {}"
.format(ref_case_root))
with Case(ref_case_root) as refcase:
refrundir = refcase.get_value("RUNDIR")
case.set_value("RUN_REFDIR", refrundir)
case.set_value("RUN_REFCASE", os.path.basename(ref_case_root))
for reffile in glob.iglob(refrundir +
"/{}{}.*.nc".format(self.name, root)):
m = re.search("(\d\d\d\d-\d\d-\d\d)-\d\d\d\d\d.nc", reffile)
if m:
refdate = m.group(1)
symlink_force(reffile,
os.path.join(rundir, os.path.basename(reffile)))
for rpfile in glob.iglob(refrundir + "/rpointer*"):
safe_copy(rpfile, rundir)
if not os.path.isdir(os.path.join(
rundir, "inputdata")) and os.path.isdir(
os.path.join(refrundir, "inputdata")):
symlink_force(os.path.join(refrundir, "inputdata"),
os.path.join(rundir, "inputdata"))
case.set_value("RUN_REFDATE", refdate)
if case_root.endswith(".postad"):
case.set_value("RUN_STARTDATE", refdate)
def bless_history(test_name, testcase_dir_for_test, baseline_name,
baseline_root, report_only, force):
###############################################################################
with Case(testcase_dir_for_test) as case:
baseline_full_dir = os.path.join(baseline_root, baseline_name,
case.get_value("CASEBASEID"))
result, comments = compare_baseline(case,
baseline_dir=baseline_full_dir)
if result:
return True, None
else:
print comments
if (not report_only and
(force or raw_input("Update this diff (y/n)? ").upper()
in ["Y", "YES"])):
result, comments = generate_baseline(
case, baseline_dir=baseline_full_dir)
if not result:
logging.warning("Hist file bless FAILED for test %s" %
test_name)
return False, "Generate baseline failed: %s" % comments
else:
print comments
return True, None
else:
return True, None
def build_data_nml(argv, compclass):
###############################################################################
# This function is just a wrapper for the one below, to avoid having to
# indent everything for the "with" block.
caseroot = parse_input(argv)
with Case(caseroot) as case:
_build_data_nml(case, caseroot, compclass)
def build_base_case(baseroot, basecasename, res, compset, overwrite,
user_mods_dir):
print(">>>>> BUILDING BASE CASE...")
caseroot = os.path.join(baseroot,basecasename+'.'+basecase_startval)
if overwrite and os.path.isdir(caseroot):
shutil.rmtree(caseroot)
with Case(caseroot, read_only=False) as case:
if not os.path.isdir(caseroot):
case.create(os.path.basename(caseroot), cesmroot, compset, res,
machine_name="cheyenne", driver="mct",
run_unsupported=True, answer="r",walltime="01:00:00",
user_mods_dir=user_mods_dir, project=project)
# make sure that changing the casename will not affect these variables
case.set_value("EXEROOT",case.get_value("EXEROOT", resolved=True))
case.set_value("RUNDIR",case.get_value("RUNDIR",resolved=True)+".00")
case.set_value("RUN_TYPE","startup")
case.set_value("GET_REFCASE",False)
rundir = case.get_value("RUNDIR")
caseroot = case.get_value("CASEROOT")
print(">> base case_setup...")
case.case_setup()
print(">> base case_build...")
build.case_build(caseroot, case=case)
return caseroot
def bless_history(test_name, testcase_dir_for_test, baseline_name,
baseline_root, compiler, report_only, force):
###############################################################################
with Case(testcase_dir_for_test) as case:
if get_model() == "acme":
baseline_full_dir = os.path.join(baseline_root, compiler,
baseline_name,
case.get_value("CASEBASEID"))
else:
baseline_full_dir = os.path.join(baseline_root, baseline_name,
case.get_value("CASEBASEID"))
result, comments = compare_baseline(case,
baseline_dir=baseline_full_dir,
outfile_suffix=None)
if result:
logging.info("Diff appears to have been already resolved.")
return True, None
else:
print comments
if (not report_only and
(force or raw_input("Update this diff (y/n)? ").upper()
in ["Y", "YES"])):
result, comments = generate_baseline(
case, baseline_dir=baseline_full_dir)
if not result:
logging.warning("Hist file bless FAILED for test %s" %
test_name)
return False, "Generate baseline failed: %s" % comments
else:
print comments
return True, None
else:
return True, None
def _case_from_existing_caseroot(self, caseroot):
"""
Returns a Case object from an existing caseroot directory
Args:
caseroot (str): path to existing caseroot
"""
return Case(case_root=caseroot, read_only=False)
def __init__(self, casename):
super(CaseWindow, self).__init__()
self.setupUi(self)
self.setMouseTracking(1)
with Case(casename) as case:
self.populate_case_tab(case)
self.populate_setup_tab(case)
self.populate_build_tab(case)
self.populate_run_tab(case)
def build_xcpl_nml(argv, compclass):
###############################################################################
caseroot = parse_input(argv)
compname = "x" + compclass
caseroot = parse_input(argv)
with Case(caseroot) as case:
rundir = case.get_value("RUNDIR")
ninst = case.get_value("NINST_%s" % compclass.upper())
nx = case.get_value("%s_NX" % compclass.upper())
ny = case.get_value("%s_NY" % compclass.upper())
if compname == "xrof":
flood_mode = case.get_value('XROF_FLOOD_MODE')
extras = []
dtype = 1
npes = 0
length = 0
if compname == "xatm":
if ny == 1:
dtype = 2
extras = [["24", "ncpl number of communications w/coupler per dat"],
["0.0", "simul time proxy (secs): time between cpl comms"]]
elif compname == "xglc" or compname == "xice":
dtype = 2
elif compname == "xlnd":
dtype = 11
elif compname == "xocn":
dtype = 4
elif compname == "xrof":
dtype = 11
if flood_mode == "ACTIVE":
extras = [[".true.", "flood flag"]]
else:
extras = [[".false.", "flood flag"]]
for i in range(1, ninst + 1):
# If only 1 file, name is 'compclass_in'
# otherwise files are 'compclass_in0001', 'compclass_in0002', etc
if ninst == 1:
filename = os.path.join(rundir, "%s_in" % compname)
else:
filename = os.path.join(rundir, "%s_in_%4.4d" % (compname, i))
with open(filename, 'w') as infile:
infile.write("%-20d ! i-direction global dimension\n" % nx)
infile.write("%-20d ! j-direction global dimension\n" % ny)
infile.write("%-20d ! decomp_type 1=1d-by-lat, 2=1d-by-lon,"
" 3=2d, 4=2d evensquare, 11=segmented\n" % dtype)
infile.write("%-20d ! num of pes for i (type 3 only)\n" % npes)
infile.write("%-20d ! length of segments (type 4 only)\n" % length)
for extra in extras:
infile.write("%-20s ! %s\n" % (extra[0], extra[1]))
def clone_base_case(caseroot, ensemble, user_mods_dir, overwrite, paramdict):
print(">>>>> CLONING BASE CASE...")
startval = ensemble_startval
nint = len(ensemble_startval)
cloneroot = caseroot
for i in range(int(startval), int(startval)+ensemble):
member_string = '{{0:0{0:d}d}}'.format(nint).format(i)
print("member_string="+member_string)
if ensemble > 1:
caseroot = caseroot[:-nint] + member_string
if overwrite and os.path.isdir(caseroot):
shutil.rmtree(caseroot)
if not os.path.isdir(caseroot):
with Case(cloneroot, read_only=False) as clone:
clone.create_clone(caseroot, keepexe=True,
user_mods_dir=user_mods_dir)
with Case(caseroot, read_only=False) as case:
per_run_case_updates(case, user_mods_dir, member_string, nint, paramdict)
def download_input_data(rundir):
"""Implementation of the download_input_data command
Args:
rundir: str - path to directory containing input_data_list files
"""
_create_lilac_input_data_list(rundir)
case = Case(os.path.realpath(os.path.join(rundir, os.pardir, 'case')))
case.check_all_input_data(data_list_dir=rundir,
download=True,
chksum=False)
os.remove(os.path.join(rundir, 'lilac.input_data_list'))
def compare_history(testcase_dir_for_test, baseline_name, baseline_root,
log_id):
###############################################################################
with Case(testcase_dir_for_test) as case:
baseline_full_dir = os.path.join(baseline_root, baseline_name,
case.get_value("CASEBASEID"))
outfile_suffix = "%s.%s" % (baseline_name, log_id)
result, comments = compare_baseline(case,
baseline_dir=baseline_full_dir,
outfile_suffix=outfile_suffix)
return result, comments
def compare_history(testcase_dir_for_test, baseline_name, baseline_root):
###############################################################################
with Case(testcase_dir_for_test) as case:
baseline_full_dir = os.path.join(baseline_root, baseline_name,
case.get_value("CASEBASEID"))
result, comments = compare_baseline(case,
baseline_dir=baseline_full_dir)
if result:
return True, None
else:
logging.info(comments)
return False, "Diff'd"
def create_new_case(self):
srcroot = os.path.dirname(os.path.abspath(get_cime_root()))
casename = self.CreateNewcaseArgs["case"]
with Case(os.path.join(self._casedir, casename),
read_only=False) as case:
case.create(casename,
srcroot,
self.CreateNewcaseArgs["compset"],
self.CreateNewcaseArgs["res"],
machine_name=self.CreateNewcaseArgs["machine"],
compiler=self.CreateNewcaseArgs["compiler"],
mpilib=self.CreateNewcaseArgs["mpilib"])
def clone_base_case(date, caseroot, ensemble, sdrestdir, user_mods_dir,
overwrite):
startval = "01"
nint = len(startval)
cloneroot = caseroot
for i in range(int(startval), int(startval) + ensemble):
member_string = '{{0:0{0:d}d}}'.format(nint).format(i)
if ensemble > 1:
caseroot = caseroot[:-nint] + member_string
if overwrite and os.path.isdir(caseroot):
shutil.rmtree(caseroot)
if not os.path.isdir(caseroot):
with Case(cloneroot, read_only=False) as clone:
clone.create_clone(caseroot,
keepexe=True,
user_mods_dir=user_mods_dir)
with Case(caseroot, read_only=True) as case:
# rundir is initially 00 reset to current member
rundir = case.get_value("RUNDIR")
rundir = rundir[:-nint] + member_string
case.set_value("RUNDIR", rundir)
per_run_case_updates(case, date, sdrestdir, user_mods_dir, rundir)
def cleanup_queue(test_root, test_id):
###############################################################################
"""
Delete all jobs left in the queue
"""
for teststatus_file in glob.iglob("{}/*{}*/TestStatus".format(test_root, test_id)):
case_dir = os.path.dirname(teststatus_file)
with Case(case_dir, read_only=True) as case:
jobmap = case.get_job_info()
jobkills = []
for jobname, jobid in jobmap.items():
logging.warning("Found leftover batch job {} ({}) that need to be deleted".format(jobid, jobname))
jobkills.append(jobid)
case.cancel_batch_jobs(jobkills)
def test_error(self, strftime, get_value, flush, init): # pylint: disable=unused-argument
Case._force_read_only = False # pylint: disable=protected-access
with self.tempdir as tempdir, mock.patch("CIME.case.case.open",
mock.mock_open()) as m:
m.side_effect = PermissionError()
with Case(tempdir) as case:
get_value.side_effect = [tempdir, "/src"]
# We didn't need to make tempdir look like a valid case for the Case
# constructor because we mock that constructor, but we *do* need to make
# it look like a valid case for record_cmd.
make_valid_case(tempdir)
case.record_cmd()
def build_data_lib(argv, compclass):
###############################################################################
caseroot, libroot, _ = parse_input(argv)
with Case(caseroot) as case:
cimeroot = case.get_value("CIMEROOT")
# Write directory list (Filepath)
compname = "d" + compclass
with open('Filepath', 'w') as out:
out.write(os.path.join(caseroot, "SourceMods", "src.{}\n".format(compname)) + "\n")
out.write(os.path.join(cimeroot, "src", "components", "data_comps", compname) + "\n")
# Build the component
run_gmake(case, compclass, libroot)
def test_copy(self, getuser, getfqdn, configure, create_caseroot, # pylint: disable=unused-argument
apply_user_mods, set_lookup_value, lock_file, strftime, # pylint: disable=unused-argument
read_xml): # pylint: disable=unused-argument
expected_first_hash = "134a939f62115fb44bf08a46bfb2bd13426833b5c8848cf7c4884af7af05b91a"
expected_second_hash = "3561339a49daab999e3c4ea2f03a9c6acc33296a5bc35f1bfb82e7b5e10bdf38"
with self.tempdir as tempdir:
caseroot = os.path.join(tempdir, "test1")
with Case(caseroot, read_only=False) as case:
os.environ["CIME_MODEL"] = "cesm"
srcroot = os.path.abspath(os.path.join(
os.path.dirname(__file__), "../../../../../"))
case.create("test1", srcroot, "A", "f19_g16_rx1",
machine_name="ubuntu-latest")
# Check that they're all called
configure.assert_called_with("A", "f19_g16_rx1",
machine_name="ubuntu-latest",
project=None, pecount=None,
compiler=None, mpilib=None,
pesfile=None, gridfile=None,
multi_driver=False, ninst=1,
test=False, walltime=None,
queue=None, output_root=None,
run_unsupported=False, answer=None,
input_dir=None, driver=None,
workflowid="default",
non_local=False,
extra_machines_dir=None,
case_group=None)
create_caseroot.assert_called()
apply_user_mods.assert_called()
lock_file.assert_called()
set_lookup_value.assert_called_with("CASE_HASH",
expected_first_hash)
strftime.return_value = "10:00:00"
with mock.patch("CIME.case.case.Case.set_value") as set_value, \
mock.patch("sys.argv", ["/src/create_clone"]):
case.copy("test2", "{}_2".format(tempdir))
set_value.assert_called_with("CASE_HASH",
expected_second_hash)
def build_stub_lib(argv, compclass):
###############################################################################
caseroot, libroot, _ = parse_input(argv)
with Case(caseroot) as case:
cimeroot = case.get_value("CIMEROOT")
# Write directory list
compname = "s" + compclass
with open('Filepath', 'w') as out:
out.write(os.path.join(caseroot, "SourceMods", "src.{}", compname) + "\n")
out.write(os.path.join(cimeroot, "src", "components", "stub_comps", "xshare") + "\n")
out.write(os.path.join(cimeroot, "src", "components", "stub_comps",compname, "cpl") + "\n")
# Build the component
run_gmake(case, compclass, libroot)
def test_new_hash(self, getuser, getfqdn, strftime, read_xml): # pylint: disable=unused-argument
with self.tempdir as tempdir:
with Case(tempdir) as case:
expected = "134a939f62115fb44bf08a46bfb2bd13426833b5c8848cf7c4884af7af05b91a"
# Check idempotency
for _ in range(2):
value = case.new_hash()
self.assertTrue(value == expected,
"{} != {}".format(value, expected))
expected = "bb59f1c473ac07e9dd30bfab153c0530a777f89280b716cf42e6fe2f49811a6e"
value = case.new_hash()
self.assertTrue(value == expected,
"{} != {}".format(value, expected))
def build_base_case(date,
baseroot,
basecasename,
basemonth,
res,
compset,
overwrite,
sdrestdir,
user_mods_dir,
pecount=None):
caseroot = os.path.join(baseroot,
basecasename + ".{:02d}".format(basemonth) + ".00")
if overwrite and os.path.isdir(caseroot):
shutil.rmtree(caseroot)
with Case(caseroot, read_only=False) as case:
if not os.path.isdir(caseroot):
case.create(os.path.basename(caseroot),
cesmroot,
compset,
res,
run_unsupported=True,
answer="r",
walltime="04:00:00",
user_mods_dir=user_mods_dir,
pecount=pecount,
project="NCGD0042")
# make sure that changing the casename will not affect these variables
case.set_value("EXEROOT", case.get_value("EXEROOT", resolved=True))
case.set_value("RUNDIR",
case.get_value("RUNDIR", resolved=True) + ".00")
case.set_value("RUN_TYPE", "hybrid")
case.set_value("GET_REFCASE", False)
case.set_value("RUN_REFDIR", sdrestdir)
if basecasename == "70Lwaccm6":
case.set_value("RUN_REFCASE",
"b.e21.BWHIST.SD.{}.002.nudgedOcn".format(res))
case.set_value("OCN_TRACER_MODULES", "")
case.set_value("NTHRDS", 1)
else:
def _main_func(description):
casename, _ = parse_command_line(sys.argv, description)
caseroot = os.path.abspath(casename)
# forcing_dir = "/glade/collections/nmme/ncgd0022/jcaron/CFSv2/forcing_files/"
forcing_dir = "/glade/scratch/ssfcst/forcing_files/"
forcing_files = {
"Precip": glob.glob(forcing_dir + "*Prec*.nc"),
"Solar": glob.glob(forcing_dir + "*Solar*.nc"),
"TPQW": glob.glob(forcing_dir + "*TPQW*.nc")
}
with Case(caseroot, read_only=False) as case:
rundir = case.get_value("RUNDIR")
for ftype in ["Solar", "Precip", "TPQW"]:
forcing_files[ftype] = sorted(forcing_files[ftype], reverse=True)
streamfile = os.path.join(rundir,
"datm.streams.txt.CLMCRUNCEP." + ftype)
newfile = os.path.join(caseroot,
"user_" + os.path.basename(streamfile))
#print("New forcing_files from {} to {}".format(forcing_files["Solar"][0],forcing_files["Solar"][-1]))
with open(streamfile) as fin, open(newfile, "w") as fout:
input_lines = fin.readlines()
skip_line = False
for line in input_lines:
if "</filePath>" in line:
skip_line = False
if skip_line:
continue
if "domain.lnd" in line:
line = "domain.ncepCFSv2.c2019.0.2d.nc\n"
if "clmforc.cruncep" in line or "clmforc.NCEPCFSv2" in line:
while forcing_files[ftype]:
newline = os.path.basename(
forcing_files[ftype].pop())
fout.write(newline + "\n")
continue
fout.write(line)
if "<filePath>" in line:
skip_line = True
fout.write("/glade/scratch/ssfcst/forcing_files/\n")
def test_cmd_arg(self, get_value, flush, init): # pylint: disable=unused-argument
Case._force_read_only = False # pylint: disable=protected-access
mocked_open = mock.mock_open()
with self.tempdir as tempdir, mock.patch("CIME.case.case.open",
mocked_open):
with Case(tempdir) as case:
get_value.side_effect = [
tempdir,
"/src",
]
case.record_cmd(["/some/custom/command", "arg1"])
expected = [
"/some/custom/command arg1\n\n",
]
handle = mocked_open()
handle.writelines.assert_called_with(expected)
