def test_limit_offset(input_files, filename, as_file, limit, offset, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
result = read._read_spss(data, limit = limit)
assert result is not None
assert isinstance(result, tuple) is True
assert len(result) == 2
assert result[0] is not None
assert result[1] is not None
assert checkers.is_type(result[0], 'DataFrame') is True
assert checkers.is_type(result[1], 'Metadata') is True
if limit is None:
assert len(result[0]) == result[1].rows
else:
assert len(result[0]) == max((limit - offset), limit)
else:
with pytest.raises(error):
result = read._read_spss(data)
def test_exclude_variables(input_files, filename, as_file, exclude_variables, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
result = read._read_spss(data, exclude_variables = exclude_variables)
assert result is not None
assert isinstance(result, tuple) is True
assert len(result) == 2
assert result[0] is not None
assert result[1] is not None
assert checkers.is_type(result[0], 'DataFrame') is True
assert checkers.is_type(result[1], 'Metadata') is True
assert len(result[0]) == result[1].rows
for variable in exclude_variables:
metadata = result[1]
assert variable not in metadata.column_metadata
assert variable not in result[0]
else:
with pytest.raises(error):
result = read._read_spss(data)
def test_from_csv(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
with tempfile.NamedTemporaryFile(delete=False) as temp_file:
temp_file_name = temp_file.name
as_csv = read.to_csv(data, target=temp_file_name, limit=1)
assert as_csv is None
result = write.from_csv(temp_file_name, delimiter='|')
assert result is not None
os.remove(temp_file_name)
else:
with tempfile.NamedTemporaryFile(delete=False) as temp_file:
temp_file_name = temp_file.name
with pytest.raises(error):
as_csv = read.to_csv(data, target=temp_file_name, limit=1)
assert as_csv is None
result = write.from_csv(temp_file_name, delimiter='|')
assert result is not None
os.remove(temp_file_name)
def test_parse_yaml(input_files, input_value, deserialize_function,
expected_result, error):
input_value = check_input_file(input_files, input_value)
if not error:
result = parse_yaml(input_value,
deserialize_function=deserialize_function)
assert isinstance(result, (dict, list))
assert checkers.are_equivalent(result, expected_result)
else:
with pytest.raises(error):
result = parse_yaml(input_value)
def test_to_excel(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
result_as_records = read.to_excel(data, limit = 1)
assert result_as_records is not None
else:
with pytest.raises(error):
result_as_records = read.to_excel(data, limit = 1)
def test_get_metadata(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
result = read.get_metadata(data)
assert result is not None
assert checkers.is_type(result, 'Metadata') is True
assert result.column_metadata is not None
else:
with pytest.raises(error):
result = read.get_metadata(data)
def test_to_csv(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
result = read.to_csv(data, limit = 1)
assert result is not None
assert isinstance(result, str) is True
else:
with pytest.raises(error):
result = read.to_csv(data)
def test_update_from_yaml(request, model_complex_postgresql,
instance_postgresql, input_files, use_file, filename,
hybrid_value, expected_name, extra_keys,
error_on_extra_keys, drop_extra_keys,
deserialize_function, error):
model = model_complex_postgresql[0]
target = instance_postgresql[0][0]
as_dict = target.to_dict(max_nesting=5, current_nesting=0)
if isinstance(as_dict, OrderedDict):
as_dict = dict(as_dict)
as_dict['hybrid_value'] = hybrid_value
if extra_keys:
for key in extra_keys:
as_dict[key] = extra_keys[key]
if not use_file:
input_data = yaml.dump(as_dict)
else:
input_data = check_input_file(input_files, filename)
if not error:
target.update_from_yaml(input_data,
deserialize_function=deserialize_function,
error_on_extra_keys=error_on_extra_keys,
drop_extra_keys=drop_extra_keys)
assert isinstance(target, model)
assert getattr(target, 'name') == expected_name
assert getattr(target, 'hybrid') == hybrid_value
assert getattr(target, 'id') == target.id
if extra_keys and not error_on_extra_keys and not drop_extra_keys:
for key in extra_keys:
assert hasattr(target, key) is True
assert getattr(target, key) == extra_keys[key]
else:
with pytest.raises(error):
target.update_from_yaml(input_data,
deserialize_function=deserialize_function,
error_on_extra_keys=error_on_extra_keys,
drop_extra_keys=drop_extra_keys)
def test_from_dataframe(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
df, metadata = read.to_dataframe(data)
result = write.from_dataframe(df, metadata=metadata)
assert result is not None
else:
with pytest.raises(error):
df, metadata = read.to_dataframe(data)
result = write.from_dataframe(df, metadata=metadata)
def test_new_from_json(request, model_complex_postgresql, instance_postgresql,
input_files, use_file, filename, hybrid_value,
expected_name, extra_keys, error_on_extra_keys,
drop_extra_keys, deserialize_function, error):
target = model_complex_postgresql[0]
source = instance_postgresql[0][0]
as_dict = source.to_dict(max_nesting=5, current_nesting=0)
as_dict['hybrid_value'] = hybrid_value
if extra_keys:
for key in extra_keys:
as_dict[key] = extra_keys[key]
dumped_data = json.dumps(as_dict)
if not use_file:
as_json = dumped_data
else:
as_json = check_input_file(input_files, filename)
if not error:
result = target.new_from_json(
as_json,
deserialize_function=deserialize_function,
error_on_extra_keys=error_on_extra_keys,
drop_extra_keys=drop_extra_keys)
assert isinstance(result, target)
assert getattr(result, 'name') == expected_name
assert getattr(result, 'hybrid') == hybrid_value
assert getattr(result, 'id') == source.id
if extra_keys and not error_on_extra_keys and not drop_extra_keys:
for key in extra_keys:
assert hasattr(result, key) is True
assert getattr(result, key) == extra_keys[key]
else:
with pytest.raises(error):
result = target.new_from_json(
as_json,
deserialize_function=deserialize_function,
error_on_extra_keys=error_on_extra_keys,
drop_extra_keys=drop_extra_keys)
def test_from_excel(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
as_excel = read.to_excel(data, limit=1)
assert as_excel is not None
result = write.from_excel(as_excel)
assert result is not None
else:
with pytest.raises(error):
as_excel = read.to_excel(data, limit=1)
result = write.from_excel(as_excel)
def test_to_dict(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
result_as_records = read.to_dict(data, limit = 1, layout = 'records')
result_as_table = read.to_dict(data, limit = 1, layout = 'table')
assert result_as_records is not None
assert result_as_table is not None
assert isinstance(result_as_records, list) is True
assert isinstance(result_as_table, dict) is True
else:
with pytest.raises(error):
result_as_records = read.to_dict(data, limit = 1, layout = 'records')
result_as_table = read.to_dict(data, limit = 1, layout = 'table')
def test_new_from_csv(request, model_complex_postgresql, input_files,
input_value, expected_name, expected_smallint,
expected_id, expected_serialization, error):
model = model_complex_postgresql[0]
input_value = check_input_file(input_files, input_value)
if not error:
result = model.new_from_csv(input_value)
assert isinstance(result, model)
assert getattr(result, 'name') == expected_name
assert getattr(result, 'smallint_column') == expected_smallint
assert getattr(result, 'id') == expected_id
serialized = result.to_csv(include_header=False)
assert serialized == expected_serialization
else:
with pytest.raises(error):
result = model.new_from_csv(input_value)
def test_default_params(input_files, filename, as_file, error):
input_data = check_input_file(input_files, filename)
if not as_file:
with open(input_data, 'rb') as file_:
data = file_.read()
else:
data = input_data
if not error:
result = read._read_spss(data)
assert result is not None
assert isinstance(result, tuple) is True
assert len(result) == 2
assert result[0] is not None
assert result[1] is not None
assert checkers.is_type(result[0], 'DataFrame') is True
assert checkers.is_type(result[1], 'Metadata') is True
assert len(result[0]) == result[1].rows
else:
with pytest.raises(error):
result = read._read_spss(data)
def test_from_csv(input_files, input_data, tablename, primary_key,
column_kwargs, skip_nested, default_to_str, type_mapping,
expected_types, error):
input_data = check_input_file(input_files, input_data)
if column_kwargs is None:
column_kwargs = {}
# pylint: disable=no-member,line-too-long
if error:
with pytest.raises(error):
result = Table.from_csv(input_data,
tablename=tablename,
metadata=MetaData(),
primary_key=primary_key,
column_kwargs=column_kwargs,
skip_nested=skip_nested,
default_to_str=default_to_str,
type_mapping=type_mapping)
else:
result = Table.from_csv(input_data,
tablename=tablename,
metadata=MetaData(),
primary_key=primary_key,
column_kwargs=column_kwargs,
skip_nested=skip_nested,
default_to_str=default_to_str,
type_mapping=type_mapping)
assert isinstance(result, Table)
assert result.name == tablename
for key in column_kwargs:
item_column = None
for column in result.c:
if column.name == key:
item_column = column
break
assert item_column is not None
for subkey in column_kwargs[key]:
assert hasattr(item_column, subkey) is True
item_value = getattr(item_column, subkey)
if subkey == 'default':
item_value = item_value.arg
expected_value = column_kwargs[key][subkey]
assert item_value == expected_value
for item in expected_types:
item_column = None
for column in result.c:
if item[0] == column.name:
item_column = column
break
assert item_column is not None
assert isinstance(item_column.type, item[1]) is True
assert item_column.primary_key is (item[0] == primary_key)
def test_generate_model_from_csv(input_files,
input_data,
tablename,
primary_key,
serialization_config,
skip_nested,
default_to_str,
type_mapping,
base_model_attrs,
expected_types,
error):
# pylint: disable=no-member,line-too-long
input_data = check_input_file(input_files, input_data)
if error:
with pytest.raises(error):
result = generate_model_from_csv(input_data,
tablename = tablename,
primary_key = primary_key,
serialization_config = serialization_config,
skip_nested = skip_nested,
default_to_str = default_to_str,
type_mapping = type_mapping,
base_model_attrs = base_model_attrs)
else:
result = generate_model_from_csv(input_data,
tablename = tablename,
primary_key = primary_key,
serialization_config = serialization_config,
skip_nested = skip_nested,
default_to_str = default_to_str,
type_mapping = type_mapping,
base_model_attrs = base_model_attrs)
assert hasattr(result, 'to_json') is True
assert hasattr(result, 'new_from_json') is True
assert hasattr(result, 'update_from_json') is True
assert hasattr(result, '__serialization__') is True
assert result.__tablename__ == tablename
for item in expected_types:
assert hasattr(result, item[0]) is True
attribute = getattr(result, item[0], None)
assert isinstance(attribute.type, item[1]) is True
if serialization_config:
for item in serialization_config:
assert hasattr(result, item.name) is True
assert result.get_attribute_serialization_config(item.name) == item
else:
for item in expected_types:
assert hasattr(result, item[0]) is True
assert result.get_attribute_serialization_config(item[0]).supports_csv == (True, True)
assert result.get_attribute_serialization_config(item[0]).supports_json == (True, True)
assert result.get_attribute_serialization_config(item[0]).supports_yaml == (True, True)
assert result.get_attribute_serialization_config(item[0]).supports_dict == (True, True)
if base_model_attrs:
for key in base_model_attrs:
assert hasattr(result, key) is True
assert getattr(result, key) == base_model_attrs[key]
