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]