def test_error_parse(self): with TestAreaContext("ecl_run") as ta: self.init_config() ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.ERROR.DATA")) ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.DATA")) argv = ["run_ecl100" , "2014.2" , "SPE1.DATA"] ecl_run = EclRun(argv) ecl_run.runEclipse( ) prt_file = os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/parse/ERROR.PRT") shutil.copy(prt_file , "SPE1.PRT") error_list = ecl_run.parseErrors( ) self.assertEqual( len(error_list) , 2 ) # NB: The ugly white space in the error0 literal is actually part of # the string we are matching; i.e. it must be retained. error0 = """ @-- ERROR AT TIME 0.0 DAYS ( 1-JAN-0): @ UNABLE TO OPEN INCLUDED FILE @ /private/joaho/ERT/git/Gurbat/XXexample_grid_sim.GRDECL @ SYSTEM ERROR CODE IS 29 """ error1 = """ @-- ERROR AT TIME 0.0 DAYS ( 1-JAN-0): @ INCLUDE FILES MISSING. """ self.assertEqual( error_list[0] , error0 ) self.assertEqual( error_list[1] , error1 )
def test_env(self): self.init_eclrun_config() with open("eclrun", "w") as f, open("DUMMY.DATA", "w"): f.write("""#!/usr/bin/env python import os import json with open("env.json", "w") as f: json.dump(dict(os.environ), f) """) os.chmod("eclrun", os.stat("eclrun").st_mode | stat.S_IEXEC) ecl_config = Ecl100Config() eclrun_config = EclrunConfig(ecl_config, "2019.3") ecl_run = EclRun("DUMMY", None, check_status=False) with mock.patch.object(ecl_run, "_get_run_command", mock.MagicMock(return_value="./eclrun")): ecl_run.runEclipse(eclrun_config=eclrun_config) with open("env.json") as f: run_env = json.load(f) eclrun_env = self._eclrun_conf()["eclrun_env"] for k, v in eclrun_env.items(): if v is None: assert k not in run_env continue if k == "PATH": assert run_env[k].startswith(v) else: assert v == run_env[k]
def test_flow(self): self.init_flow_config() shutil.copy( os.path.join(self.TESTDATA_ROOT, "local/eclipse/SPE1.DATA"), "SPE1.DATA", ) shutil.copy( os.path.join(self.TESTDATA_ROOT, "local/eclipse/SPE1_ERROR.DATA"), "SPE1_ERROR.DATA", ) flow_config = FlowConfig() sim = flow_config.sim() flow_run = EclRun("SPE1.DATA", sim) flow_run.runEclipse() run(flow_config, ["SPE1.DATA"]) flow_run = EclRun("SPE1_ERROR.DATA", sim) with self.assertRaises(Exception): flow_run.runEclipse() run(flow_config, ["SPE1_ERROR.DATA", "--ignore-errors"]) # Invalid version with self.assertRaises(Exception): run(flow_config, ["SPE1.DATA", "--version=no/such/version"])
def test_mpi_run(self): with TestAreaContext("ecl_run") as ta: self.init_config() ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1_PARALLELL.DATA")) argv = ["run_ecl100" , "2014.2" , "SPE1_PARALLELL.DATA" , "2"] ecl_run = EclRun(argv) ecl_run.runEclipse( ) self.assertTrue( os.path.isfile( os.path.join( ecl_run.runPath() , "%s.stderr" % ecl_run.baseName()))) self.assertTrue( os.path.isfile( os.path.join( ecl_run.runPath() , "%s.LOG" % ecl_run.baseName())))
def test_running_flow_given_env_variables_with_same_name_as_parent_env_variables_will_overwrite( # noqa self, ): version = "1111.11" # create a script that prints env vars ENV1 and ENV2 to a file with open("flow", "w") as f: f.write("#!/bin/bash\n") f.write("echo $ENV1 > out.txt\n") f.write("echo $ENV2 >> out.txt\n") executable = os.path.join(os.getcwd(), "flow") os.chmod(executable, 0o777) # create a flow_config.yml with environment extension ENV2 conf = { "default_version": version, "versions": { version: { "scalar": { "executable": executable, "env": {"ENV1": "OVERWRITTEN1", "ENV2": "OVERWRITTEN2"}, }, } }, } with open("flow_config.yml", "w") as f: f.write(yaml.dump(conf)) # set the environment variable ENV1 self.monkeypatch.setenv("ENV1", "VAL1") self.monkeypatch.setenv("ENV2", "VAL2") self.monkeypatch.setenv("FLOW_SITE_CONFIG", "flow_config.yml") with open("DUMMY.DATA", "w") as f: f.write("dummy") with open("DUMMY.PRT", "w") as f: f.write("Errors 0\n") f.write("Bugs 0\n") # run the script flow_config = FlowConfig() sim = flow_config.sim() flow_run = EclRun("DUMMY.DATA", sim) flow_run.runEclipse() # assert that the script was able to read both the variables correctly with open("out.txt") as f: lines = f.readlines() self.assertEqual(len(lines), 2) self.assertEqual(lines[0].strip(), "OVERWRITTEN1") self.assertEqual(lines[1].strip(), "OVERWRITTEN2")
def test_failed_run_OK(self): with TestAreaContext("ecl_run") as ta: self.init_config() ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.ERROR.DATA")) argv = ["run_ecl100_nocheck" , "2014.2" , "SPE1.ERROR"] ecl_run = EclRun(argv) ecl_run.runEclipse( ) # Monkey patching the ecl_run to use an executable which will fail with exit(1), # in the nocheck mode that should also be OK. ecl_run.sim.executable = os.path.join( self.SOURCE_ROOT , "python/tests/res/fm/ecl_run_fail") ecl_run.runEclipse( )
def test_failed_run(self): self.init_eclrun_config() shutil.copy( os.path.join(self.SOURCE_ROOT, "test-data/local/eclipse/SPE1_ERROR.DATA"), "SPE1_ERROR.DATA", ) ecl_config = Ecl100Config() eclrun_config = EclrunConfig(ecl_config, "2019.3") ecl_run = EclRun("SPE1_ERROR", None) with self.assertRaises(Exception) as error_context: ecl_run.runEclipse(eclrun_config=eclrun_config) self.assertIn("ERROR", str(error_context.exception))
def test_summary_block(self): with TestAreaContext("ecl_run") as ta: self.init_config() ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.ERROR.DATA")) ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.DATA")) argv = ["run_ecl100" , "2014.2" , "SPE1"] ecl_run = EclRun(argv) ret_value = ecl_run.summary_block( ) self.assertTrue( ret_value is None ) ecl_run.runEclipse( ) ecl_sum = ecl_run.summary_block( ) self.assertTrue(isinstance(ecl_sum, EclSum))
def test_failed_run(self): with TestAreaContext("ecl_run") as ta: self.init_config() ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.ERROR.DATA")) argv = ["run_ecl100" , "2014.2" , "SPE1.ERROR"] ecl_run = EclRun(argv) with self.assertRaises(Exception): ecl_run.runEclipse( ) try: ecl_run.runEclipse( ) except Exception as e: self.assertTrue( "ERROR" in str(e) )
def test_flow(self): with TestAreaContext("ecl_run") as ta: self.init_config() ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.DATA")) ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.ERROR.DATA")) os.makedirs("ecl_run") shutil.move("SPE1.DATA" , "ecl_run") argv = ["run_flow" , "daily" , "ecl_run/SPE1.DATA"] flow_run = EclRun(argv) flow_run.runEclipse( ) flow_run = EclRun(["run_flow" , "daily" , "SPE1.ERROR.DATA"]) with self.assertRaises(Exception): flow_run.runEclipse( )
def test_summary_block(self): self.init_eclrun_config() shutil.copy( os.path.join(self.SOURCE_ROOT, "test-data/local/eclipse/SPE1.DATA"), "SPE1.DATA", ) ecl_config = Ecl100Config() ecl_run = EclRun("SPE1.DATA", None) ret_value = ecl_run.summary_block() self.assertTrue(ret_value is None) ecl_run.runEclipse(eclrun_config=EclrunConfig(ecl_config, "2019.3")) ecl_sum = ecl_run.summary_block() self.assertTrue(isinstance(ecl_sum, EclSum))
def test_run(self): self.init_eclrun_config() shutil.copy( os.path.join(self.SOURCE_ROOT, "test-data/local/eclipse/SPE1.DATA"), "SPE1.DATA", ) ecl_config = Ecl100Config() ecl_run = EclRun("SPE1.DATA", None) ecl_run.runEclipse(eclrun_config=EclrunConfig(ecl_config, "2019.3")) ok_path = os.path.join(ecl_run.runPath(), "{}.OK".format(ecl_run.baseName())) log_path = os.path.join(ecl_run.runPath(), "{}.LOG".format(ecl_run.baseName())) self.assertTrue(os.path.isfile(ok_path)) self.assertTrue(os.path.isfile(log_path)) self.assertTrue(os.path.getsize(log_path) > 0) errors = ecl_run.parseErrors() self.assertEqual(0, len(errors))
def test_run(self): with TestAreaContext("ecl_run") as ta: self.init_config() ta.copy_file( os.path.join(self.SOURCE_ROOT , "test-data/local/eclipse/SPE1.DATA")) os.makedirs("ecl_run") shutil.move("SPE1.DATA" , "ecl_run") argv = ["run_ecl100" , "2014.2" , "ecl_run/SPE1.DATA"] ecl_run = EclRun(argv) ecl_run.runEclipse( ) self.assertTrue( os.path.isfile( os.path.join( ecl_run.runPath() , "%s.stderr" % ecl_run.baseName()))) self.assertTrue( os.path.isfile( os.path.join( ecl_run.runPath() , "%s.LOG" % ecl_run.baseName()))) self.assertTrue( os.path.isfile( os.path.join( ecl_run.runPath() , "%s.OK" % ecl_run.baseName()))) errors = ecl_run.parseErrors( ) self.assertEqual( 0 , len(errors )) # Monkey patching the ecl_run to use an executable which # will fail with exit(1); don't think Eclipse actually # fails with exit(1) - but let us at least be prepared # when/if it does. ecl_run.sim.executable = os.path.join( self.SOURCE_ROOT , "tests/classes/ecl_run_fail") with self.assertRaises(Exception): ecl_run.runEclipse( )