def test_Directory_list_files_missing(tmpdir):
# Make a source directory path, which does not exist
src_tmpdir = os.path.join(str(tmpdir), "missing")
src_dir = Directory(str(src_tmpdir))
with pytest.raises(IOError):
src_dir.list_files()
def test_makedir(tmpdir):
# Make a local directory
locd = tmpdir.mkdir("test")
locp = locd.join("test")
test = Directory(str(locp))
test.makedir()
assert os.path.isdir(str(locp))
def test_user_config_exists(tmpdir):
'''Test if the user_config_exists function returns false'''
# Make a local directory
locd = tmpdir.mkdir("config")
configdir = Directory(str(locd))
logger = Logger(configdir)
assert not configdir.isfile(logger.config_file_name)
def test_Directory_list_files(tmpdir):
# Make a source directory with some files
src_tmpdir = tmpdir.mkdir("test_src")
config1 = src_tmpdir.join("config.txt")
config1.write("content")
config2 = src_tmpdir.join("config.yaml")
config2.write("content")
src_dir = Directory(str(src_tmpdir))
dir_files = src_dir.list_files()
assert set(dir_files) == set(["config.txt", "config.yaml"])
def test_Directory_str():
path = os.path.join("some", "path", "with", "..", "in")
test = Directory(path)
assert str(test) != path
assert str(test) == os.path.join("some", "path", "in")
def test_DataMenu_deselect_database(mocker, tmpdir, project):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch("dtocean_core.utils.database.UserDataDirectory",
return_value=mock_dir)
# Create mock connection
mocker.patch("dtocean_core.menu.check_host_port",
return_value=(True, "Mock connection returned"))
data_menu = DataMenu()
project = deepcopy(project)
assert project.get_database_credentials() is None
dbs = data_menu.get_available_databases()
db_id = dbs[0]
data_menu.select_database(project, db_id)
assert project.get_database_credentials()
data_menu.deselect_database(project)
assert project.get_database_credentials() is None
def test_DataMenu_import_data(mocker, tmpdir, core, project, module_menu):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch("dtocean_core.utils.database.UserDataDirectory",
return_value=mock_dir)
data_menu = DataMenu()
var_tree = Tree()
project = deepcopy(project)
mod_name = "Mock Module"
core.register_level(project, core._markers["register"], "Mock Module")
module_menu.activate(core, project, mod_name)
mod_branch = var_tree.get_branch(core, project, mod_name)
mod_branch.read_test_data(core, project,
os.path.join(dir_path, "inputs_wp2_tidal.pkl"))
pre_length = len(project._pool)
dts_path = os.path.join(str(tmpdir), "test.dts")
data_menu.export_data(core, project, dts_path)
assert os.path.isfile(dts_path)
data_menu.import_data(core, project, dts_path)
assert len(project._pool) > pre_length
def start_logging():
"""Start python logger"""
# Pick up the configuration from the user directory if it exists
userdir = UserDataDirectory("dtocean_core", "DTOcean", "config")
# Look for files.ini
if userdir.isfile("files.ini"):
configdir = userdir
else:
configdir = ObjDirectory("dtocean_core", "config")
files_ini = ReadINI(configdir, "files.ini")
files_config = files_ini.get_config()
appdir_path = userdir.get_path("..")
log_folder = files_config["logs"]["path"]
log_path = os.path.join(appdir_path, log_folder)
logdir = Directory(log_path)
# Look for logging.yaml
if userdir.isfile("logging.yaml"):
configdir = userdir
else:
configdir = ObjDirectory("dtocean_core", "config")
log = Logger(configdir)
log_config_dict = log.read()
# Update the file logger if present
if "file" in log_config_dict["handlers"]:
log_filename = log_config_dict["handlers"]["file"]["filename"]
log_path = logdir.get_path(log_filename)
log_config_dict["handlers"]["file"]["filename"] = log_path
logdir.makedir()
log.configure_logger(log_config_dict)
logger = log.add_named_logger("dtocean_core")
# Rotate any rotating file handlers
for handler in logger.handlers:
if handler.__class__.__name__ == 'RotatingFileHandler':
handler.doRollover()
logger.info("Begin logging for dtocean_core")
return
def start_logging(debug=False):
# Pick up the configuration from the user directory if it exists
userdir = UserDataDirectory("dtocean_app", "DTOcean", "config")
if userdir.isfile("files.ini") and userdir.isfile("logging.yaml"):
configdir = userdir
else:
configdir = ObjDirectory("dtocean_app", "config")
files_ini = ReadINI(configdir, "files.ini")
files_config = files_ini.get_config()
appdir_path = userdir.get_path("..")
log_folder = files_config["logs"]["path"]
log_path = os.path.join(appdir_path, log_folder)
logdir = Directory(log_path)
# Disable the logging QtHandler if the debug flag is set
QtHandler.debug = debug
log = Logger(configdir)
log_config_dict = log.read()
# Update the file logger if present
if "file" in log_config_dict["handlers"]:
log_filename = log_config_dict["handlers"]["file"]["filename"]
log_path = logdir.get_path(log_filename)
log_config_dict["handlers"]["file"]["filename"] = log_path
logdir.makedir()
log.configure_logger(log_config_dict)
logger = log.add_named_logger("dtocean_app")
# Rotate any rotating file handlers
for handler in logger.handlers:
if handler.__class__.__name__ == 'RotatingFileHandler':
try:
handler.doRollover()
except WindowsError:
pass
logger.info("Welcome to DTOcean")
return
def test_init_config_install(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_app.UserDataDirectory', return_value=mock_dir)
init_config(install=True)
assert len(config_tmpdir.listdir()) == 3
def test_init_config_interface(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_app.UserDataDirectory', return_value=mock_dir)
mocker.patch('dtocean_app.init_config_parser', return_value=(False, False))
init_config_interface()
assert len(config_tmpdir.listdir()) == 2
def get_root_configuration(root_config_name="install.ini"):
"""Pick the necessary paths to configure the external files for the wave
and tidal packages."""
# Get the root path from the site data path.
root_config_dir = site_data_dir("DTOcean Installation", "DTOcean")
configdir = Directory(root_config_dir)
ini_reader = ReadINI(configdir, root_config_name)
config = ini_reader.get_config()
return config
def test_call_logger_options(tmpdir, directory):
'''Test if logger can be called'''
# Make a local directory
locd = tmpdir.mkdir("config")
configdir = Directory(str(locd))
dirmap = DirectoryMap(configdir, directory)
logger = Logger(dirmap)
logger('my_logger', level="CRITICAL", info_message="test")
assert True
def test_call_logger(tmpdir, directory):
'''Test if logger can be called'''
# Make a local directory
locd = tmpdir.mkdir("config")
configdir = Directory(str(locd))
dirmap = DirectoryMap(configdir, directory)
logger = Logger(dirmap)
logger('my_logger')
assert True
def test_get_install_paths(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_app.utils.config.UserDataDirectory',
return_value=mock_dir)
init_config(install=True)
test_dict = get_install_paths()
assert "man_user_path" in test_dict
def test_init_config(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_core.utils.config.UserDataDirectory',
return_value=mock_dir,
autospec=True)
init_config(logging=True, database=True, files=True)
assert len(config_tmpdir.listdir()) == 3
def test_copy_logger_config(tmpdir):
'''Test if logger configuration is copied'''
# Make a local directory
locd = tmpdir.mkdir("config")
configdir = Directory(str(locd))
logger = Logger(configdir)
with pytest.raises(ValueError):
# Copy the logging file
logger.copy_config()
def test_start_logging(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_app.UserDataDirectory', return_value=mock_dir)
start_logging()
logdir = config_tmpdir.join("..", "logs")
assert len(logdir.listdir()) == 1
def test_DataMenu_select_database_no_port_dbname(mocker, tmpdir, project):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch("dtocean_core.utils.database.UserDataDirectory",
return_value=mock_dir)
data_menu = DataMenu()
project = deepcopy(project)
with pytest.raises(RuntimeError):
data_menu.select_database(project, credentials={"host": "-1.-1.-1.-1"})
def test_DataMenu_select_database_bad_id(mocker, tmpdir, project):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch("dtocean_core.utils.database.UserDataDirectory",
return_value=mock_dir)
data_menu = DataMenu()
project = deepcopy(project)
with pytest.raises(ValueError):
data_menu.select_database(project, "bad_id")
def test_DataMenu_get_available_databases(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch("dtocean_core.utils.database.UserDataDirectory",
return_value=mock_dir)
data_menu = DataMenu()
dbs = data_menu.get_available_databases()
assert len(dbs) > 0
def test_get_user_database_config_empty(mocker, tmpdir):
# Make a source directory without files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_core.utils.database.UserDataDirectory',
return_value=mock_dir,
autospec=True)
useryaml, config = get_database_config()
assert not os.path.isfile(useryaml.get_config_path())
assert isinstance(config, dict)
def test_write_yaml(tmpdir):
'''Test if the configuration file is correctly copied.'''
# Make a local directory
locd = tmpdir.mkdir("config")
# Create Logger object and change path to user data dir to tmp
configdir = Directory(str(locd))
yaml_reader = ReadYAML(configdir, "logging.yaml")
test_list = ["curly", "larry", "moe"]
yaml_reader.write(test_list)
assert os.path.basename(str(locd.listdir()[0])) == "logging.yaml"
def test_copy_ini_config(tmpdir):
'''Test if the configuration file is correctly copied.'''
# Make a local directory
locd = tmpdir.mkdir("config")
# Create Logger object and change path to user data dir to tmp
configdir = Directory(str(locd))
ini_reader = ReadINI(configdir)
with pytest.raises(ValueError):
# Copy the logging file
ini_reader.copy_config()
def test_init_config_overwrite(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_app.utils.config.UserDataDirectory',
return_value=mock_dir)
init_config(logging=True, files=True)
assert len(config_tmpdir.listdir()) == 2
init_config(logging=True, files=True, overwrite=True)
assert len(config_tmpdir.listdir()) == 2
def test_config_exists(tmpdir, directory):
'''Test that the configuration file is read correctly'''
# Make a local directory
locd = tmpdir.mkdir("config")
# Create Logger object and change path to user data dir to tmp
configdir = Directory(str(locd))
dirmap = DirectoryMap(configdir, directory)
# Copy config and check for existance
ini_reader = ReadINI(dirmap)
ini_reader.copy_config()
test = ini_reader.config_exists()
assert test
def test_read_yaml(tmpdir, directory):
'''Test if the configuration file is correctly copied.'''
# Make a local directory
locd = tmpdir.mkdir("config")
# Create Logger object and change path to user data dir to tmp
configdir = Directory(str(locd))
dirmap = DirectoryMap(configdir, directory)
yaml_reader = ReadYAML(dirmap, "logging.yaml")
yaml_reader.copy_config()
yaml_dict = yaml_reader.read()
assert "loggers" in yaml_dict
def test_init_config_interface(mocker, tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_core.utils.config.UserDataDirectory',
return_value=mock_dir,
autospec=True)
mocker.patch('dtocean_core.utils.config.init_config_parser',
return_value=('logging', False),
autospec=True)
init_config_interface()
assert len(config_tmpdir.listdir()) == 1
def test_maintenance_interface_entry(module_menu,
core,
wave_project,
var_tree,
mocker,
tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_core.interfaces.maintenance.UserDataDirectory',
return_value=mock_dir,
autospec=True)
mod_name = 'Operations and Maintenance'
project_menu = ProjectMenu()
project = deepcopy(wave_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
operations_branch = var_tree.get_branch(core, project, mod_name)
operations_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_wp6.pkl"))
operations_branch.read_auto(core, project)
can_execute = module_menu.is_executable(core, project, mod_name)
if not can_execute:
inputs = operations_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "modules")
interface = connector.get_interface(core,
project,
mod_name)
interface.connect(debug_entry=True)
debugdir = config_tmpdir.join("..", "debug")
assert len(debugdir.listdir()) == 1
def test_configure_logger(tmpdir, directory):
'''Test if logger configuration can be loaded'''
# Make a local directory
locd = tmpdir.mkdir("config")
configdir = Directory(str(locd))
dirmap = DirectoryMap(configdir, directory)
logger = Logger(dirmap)
# Copy the logging file
logger.copy_config()
# Attempt to configure the logger
log_config_dict = logger.read()
logger.configure_logger(log_config_dict)
