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_create(self): # This test can make do with a mock simulator; - just something executable conf = { "versions": { "2014.2": { "scalar": {"executable": "bin/scalar_exe"}, "mpi": {"executable": "bin/mpi_exe", "mpirun": "bin/mpirun"}, } } } with open("ecl100_config.yml", "w") as f: f.write(yaml.dump(conf)) os.mkdir("bin") self.monkeypatch.setenv("ECL100_SITE_CONFIG", "ecl100_config.yml") for f in ["scalar_exe", "mpi_exe", "mpirun"]: fname = os.path.join("bin", f) with open(fname, "w") as fh: fh.write("This is an exectable ...") os.chmod(fname, stat.S_IEXEC) with open("ECLIPSE.DATA", "w") as f: f.write("Mock eclipse data file") ecl_config = Ecl100Config() sim = ecl_config.sim("2014.2") mpi_sim = ecl_config.mpi_sim("2014.2") ecl_run = EclRun("ECLIPSE.DATA", sim) self.assertEqual(ecl_run.runPath(), os.getcwd()) os.mkdir("path") with open("path/ECLIPSE.DATA", "w") as f: f.write("Mock eclipse data file") ecl_run = EclRun("path/ECLIPSE.DATA", sim) self.assertEqual(ecl_run.runPath(), os.path.join(os.getcwd(), "path")) self.assertEqual(ecl_run.baseName(), "ECLIPSE") self.assertEqual(1, ecl_run.numCpu()) # invalid number of CPU with self.assertRaises(ValueError): ecl_run = EclRun("path/ECLIPSE.DATA", sim, num_cpu="xxx") ecl_run = EclRun("path/ECLIPSE.DATA", mpi_sim, num_cpu="10") self.assertEqual(10, ecl_run.numCpu()) # Missing datafile with self.assertRaises(IOError): ecl_run = EclRun("DOES/NOT/EXIST", mpi_sim, num_cpu="10")
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_error_parse(self): self.init_ecl100_config() shutil.copy( os.path.join(self.TESTDATA_ROOT, "local/eclipse/SPE1.DATA"), "SPE1.DATA", ) prt_file = os.path.join(self.TESTDATA_ROOT, "local/eclipse/parse/ERROR.PRT") shutil.copy(prt_file, "SPE1.PRT") ecl_config = Ecl100Config() sim = ecl_config.sim("2014.2") ecl_run = EclRun("SPE1.DATA", sim) 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 """ # noqa error1 = """ @-- ERROR AT TIME 0.0 DAYS ( 1-JAN-0): @ INCLUDE FILES MISSING. """ # noqa 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_run_new_log_file(self): self.init_ecl100_config() shutil.copy( os.path.join(self.TESTDATA_ROOT, "local/eclipse/SPE1.DATA"), "SPE1.DATA", ) ecl_config = Ecl100Config() sim = ecl_config.sim("2019.3") ecl_run = EclRun("SPE1.DATA", sim) ecl_run.runEclipse() ok_path = os.path.join(ecl_run.runPath(), "{}.OK".format(ecl_run.baseName())) log_path = os.path.join(ecl_run.runPath(), "{}.OUT".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)) # 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/libres_tests/res/fm/ecl_run_fail" ) with self.assertRaises(Exception): ecl_run.runEclipse()
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_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_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_summary_block(self): self.init_ecl100_config() shutil.copy( os.path.join(self.TESTDATA_ROOT, "local/eclipse/SPE1.DATA"), "SPE1.DATA", ) ecl_config = Ecl100Config() sim = ecl_config.sim("2014.2") ecl_run = EclRun("SPE1.DATA", sim) 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): self.init_ecl100_config() shutil.copy( os.path.join(self.TESTDATA_ROOT, "local/eclipse/SPE1_ERROR.DATA"), "SPE1_ERROR.DATA", ) ecl_config = Ecl100Config() sim = ecl_config.sim("2014.2") ecl_run = EclRun("SPE1_ERROR", sim) with self.assertRaises(Exception): ecl_run.runEclipse() try: ecl_run.runEclipse() except Exception as e: self.assertTrue("ERROR" in str(e))
def test_failed_run_OK(self): self.init_ecl100_config() shutil.copy( os.path.join(self.TESTDATA_ROOT, "local/eclipse/SPE1_ERROR.DATA"), "SPE1_ERROR.DATA", ) ecl_config = Ecl100Config() run(ecl_config, ["SPE1_ERROR", "--version=2014.2", "--ignore-errors"]) # Monkey patching the ecl_run to use an executable which will fail with exit(1), # in the nocheck mode that should also be OK. sim = ecl_config.sim("2014.2") ecl_run = EclRun("SPE1_ERROR", sim, check_status=False) ecl_run.sim.executable = os.path.join( self.SOURCE_ROOT, "tests/libres_tests/res/fm/ecl_run_fail" ) ecl_run.runEclipse()
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( )
def test_create(self): # This test can make do with a mock simulator; - just something executable with TestAreaContext("ecl_run"): self.init_config() conf = {"simulators" : {"ecl100" : {"2014.2" : {"scalar": {"executable" : "bin/scalar_exe"}, "mpi" : {"executable" : "bin/mpi_exe", "mpirun" : "bin/mpirun"}}}}} with open("ecl_config.yml","w") as f: f.write( yaml.dump(conf) ) os.mkdir("bin") os.environ["ECL_SITE_CONFIG"] = "ecl_config.yml" for f in ["scalar_exe", "mpi_exe", "mpirun"]: fname = os.path.join("bin", f) with open( fname, "w") as fh: fh.write("This is an exectable ...") os.chmod(fname, stat.S_IEXEC) # Wrong arg count with self.assertRaises(ValueError): argv = [] ecl_run = EclRun(argv) # Wrong arg count with self.assertRaises(ValueError): argv = [1,2,3,4,5] ecl_run = EclRun(argv) with open("ECLIPSE.DATA" , "w") as f: f.write("Mock eclipse data file") #Unknown simulator in argv[0] with self.assertRaises(ValueError): argv = ["Simulator" , "2014.2" , "ECLIPSE.DATA"] ecl_run = EclRun(argv) ecl_run = EclRun(["run_ecl100" , "2014.2" , "ECLIPSE.DATA"]) self.assertEqual( ecl_run.runPath() , os.getcwd()) os.mkdir("path") with open("path/ECLIPSE.DATA" , "w") as f: f.write("Mock eclipse data file") ecl_run = EclRun(["run_ecl100" , "2014.2" , "path/ECLIPSE.DATA"]) self.assertEqual( ecl_run.runPath() , os.path.join(os.getcwd() , "path")) self.assertEqual( ecl_run.baseName() , "ECLIPSE") argv = ["run_ecl100" , "2014.2" , "ECLIPSE.DATA"] ecl_run = EclRun(argv) self.assertEqual( 1 , ecl_run.numCpu()) # invalid number of CPU with self.assertRaises(ValueError): argv = ["run_ecl100" , "2014.2" , "ECLIPSE.DATA" , "xx"] ecl_run = EclRun(argv) argv = ["run_ecl100" , "2014.2" , "ECLIPSE.DATA" , "10"] ecl_run = EclRun(argv) self.assertEqual( 10 , ecl_run.numCpu()) argv = ["run_ecl100" , "MISSING_VERSION" , "ECLIPSE.DATA" , "10"] with self.assertRaises(KeyError): ecl_run = EclRun(argv) #Missing datafile with self.assertRaises(IOError): argv = ["run_ecl100" , "2014.2" , "ECLIPSE_DOES_NOT_EXIST.DATA"] ecl_run = EclRun(argv)