321 lines
14 KiB
Python
321 lines
14 KiB
Python
import pytest
|
||
import pandas as pd
|
||
from io import BytesIO
|
||
from unittest.mock import patch
|
||
|
||
from mail_order_bot.parsers.excel_parcer import ExcelFileParcer
|
||
|
||
|
||
class TestExcelFileParcer:
|
||
"""Тесты для класса ExcelFileParcer"""
|
||
|
||
@pytest.fixture
|
||
def sample_config(self):
|
||
"""Базовая конфигурация для тестов"""
|
||
return {
|
||
"sheet_name": 0,
|
||
"key_field": "Артикул",
|
||
"mapping": {
|
||
"article": "Артикул",
|
||
"manufacturer": "Производитель",
|
||
"name": "Наименование",
|
||
"price": "Цена",
|
||
"quantity": "Количество"
|
||
}
|
||
}
|
||
|
||
@pytest.fixture
|
||
def sample_excel_bytes(self):
|
||
"""Создает тестовый Excel файл в виде байтов"""
|
||
df = pd.DataFrame({
|
||
'Артикул': ['ART001', 'ART002', 'ART003'],
|
||
'Производитель': ['MAN001', 'MAN002', 'MAN003'],
|
||
'Наименование': ['Товар 1', 'Товар 2', 'Товар 3'],
|
||
'Цена': [100.0, 200.0, 300.0],
|
||
'Количество': [1, 2, 3]
|
||
})
|
||
buf = BytesIO()
|
||
with pd.ExcelWriter(buf, engine='xlsxwriter') as writer:
|
||
df.to_excel(writer, sheet_name='Sheet1', index=False)
|
||
buf.seek(0)
|
||
return buf.getvalue()
|
||
|
||
@pytest.fixture
|
||
def excel_with_header_row(self):
|
||
"""Создает Excel файл с заголовком не в первой строке"""
|
||
df = pd.DataFrame([
|
||
['Заголовок документа', None, None, None, None],
|
||
['Артикул', 'Производитель', 'Наименование', 'Цена', 'Количество'],
|
||
['ART001', 'MAN001', 'Товар 1', 100.0, 1],
|
||
['ART002', 'MAN002', 'Товар 2', 200.0, 2],
|
||
['ART003', 'MAN003', 'Товар 3', 300.0, 3],
|
||
[None, None, None, None, None] # Пустая строка для обрезки
|
||
])
|
||
buf = BytesIO()
|
||
with pd.ExcelWriter(buf, engine='xlsxwriter') as writer:
|
||
df.to_excel(writer, sheet_name='Sheet1', index=False, header=False)
|
||
buf.seek(0)
|
||
return buf.getvalue()
|
||
|
||
def test_init_with_valid_file(self, sample_excel_bytes, sample_config):
|
||
"""Тест инициализации с валидным файлом"""
|
||
parser = ExcelFileParcer(sample_excel_bytes, sample_config)
|
||
|
||
assert parser.config == sample_config
|
||
assert parser.bytes == sample_excel_bytes
|
||
assert parser.sheet_name == 0
|
||
assert parser.df is not None
|
||
assert isinstance(parser.df, pd.DataFrame)
|
||
|
||
def test_init_with_custom_sheet_name(self, sample_excel_bytes):
|
||
"""Тест инициализации с кастомным именем листа"""
|
||
config = {
|
||
"sheet_name": "Sheet2",
|
||
"key_field": "Артикул",
|
||
"mapping": {
|
||
"article": "Артикул",
|
||
"manufacturer": "Производитель"
|
||
}
|
||
}
|
||
parser = ExcelFileParcer(sample_excel_bytes, config)
|
||
assert parser.sheet_name == "Sheet2"
|
||
|
||
def test_init_with_default_sheet_name(self, sample_excel_bytes):
|
||
"""Тест инициализации с дефолтным именем листа"""
|
||
config = {
|
||
"key_field": "Артикул",
|
||
"mapping": {
|
||
"article": "Артикул",
|
||
"manufacturer": "Производитель"
|
||
}
|
||
}
|
||
parser = ExcelFileParcer(sample_excel_bytes, config)
|
||
assert parser.sheet_name == 0
|
||
|
||
@patch('mail_order_bot.parsers.excel_parcer.pd.read_excel')
|
||
def test_init_with_invalid_file(self, mock_read_excel, sample_config):
|
||
"""Тест инициализации с невалидным файлом"""
|
||
mock_read_excel.side_effect = Exception("Ошибка парсинга")
|
||
invalid_bytes = b"invalid excel content"
|
||
|
||
parser = ExcelFileParcer(invalid_bytes, sample_config)
|
||
|
||
assert parser.df is None
|
||
|
||
def test_parse_file_success(self, sample_excel_bytes, sample_config):
|
||
"""Тест успешного парсинга файла"""
|
||
parser = ExcelFileParcer(sample_excel_bytes, sample_config)
|
||
assert parser.df is not None
|
||
assert len(parser.df) > 0
|
||
|
||
@patch('mail_order_bot.parsers.excel_parcer.pd.read_excel')
|
||
def test_parse_file_failure(self, mock_read_excel, sample_config):
|
||
"""Тест обработки ошибки при парсинге файла"""
|
||
mock_read_excel.side_effect = Exception("Ошибка чтения")
|
||
invalid_bytes = b"invalid"
|
||
|
||
parser = ExcelFileParcer(invalid_bytes, sample_config)
|
||
assert parser.df is None
|
||
|
||
def test_get_header_row(self, excel_with_header_row, sample_config):
|
||
"""Тест поиска строки заголовка"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
header_row = parser._get_header_row()
|
||
|
||
assert header_row == 1 # Заголовок во второй строке (индекс 1)
|
||
|
||
def test_get_attr_column(self, excel_with_header_row, sample_config):
|
||
"""Тест поиска индекса колонки по имени"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
col_idx = parser._get_attr_column("Артикул")
|
||
|
||
assert isinstance(col_idx, int)
|
||
assert col_idx >= 0
|
||
|
||
def test_get_attr_column_nonexistent(self, excel_with_header_row, sample_config):
|
||
"""Тест поиска несуществующей колонки"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
|
||
with pytest.raises((IndexError, KeyError)):
|
||
parser._get_attr_column("Несуществующая колонка")
|
||
|
||
def test_get_attr_row(self, excel_with_header_row, sample_config):
|
||
"""Тест поиска строки по артикулу и производителю"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
row_idx = parser._get_attr_row("ART001", "MAN001")
|
||
|
||
assert isinstance(row_idx, (int, pd.core.indexes.numeric.Int64Index))
|
||
# Проверяем, что индекс найден
|
||
assert row_idx is not None
|
||
|
||
def test_get_attr_row_nonexistent(self, excel_with_header_row, sample_config):
|
||
"""Тест поиска несуществующей строки"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
|
||
with pytest.raises((IndexError, KeyError)):
|
||
parser._get_attr_row("NONEXISTENT", "NONEXISTENT")
|
||
|
||
def test_set_value(self, excel_with_header_row, sample_config):
|
||
"""Тест установки значения в ячейку"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
|
||
# Получаем исходное значение
|
||
original_value = parser.df.iloc[2, 3] # Строка с ART001, колонка "Цена"
|
||
|
||
# Устанавливаем новое значение
|
||
parser.set_value("ART001", "MAN001", "Цена", 999.0)
|
||
|
||
# Проверяем, что значение изменилось
|
||
new_value = parser.df.iloc[2, 3]
|
||
assert new_value == 999.0
|
||
assert new_value != original_value
|
||
|
||
def test_get_file_bytes(self, sample_excel_bytes, sample_config):
|
||
"""Тест получения файла в виде байтов"""
|
||
parser = ExcelFileParcer(sample_excel_bytes, sample_config)
|
||
result_bytes = parser.get_file_bytes()
|
||
|
||
assert result_bytes is not None
|
||
assert hasattr(result_bytes, 'read')
|
||
assert hasattr(result_bytes, 'seek')
|
||
|
||
# Проверяем, что можно прочитать байты
|
||
result_bytes.seek(0)
|
||
content = result_bytes.read()
|
||
assert len(content) > 0
|
||
|
||
def test_get_file_bytes_creates_valid_excel(self, sample_excel_bytes, sample_config):
|
||
"""Тест что get_file_bytes создает валидный Excel файл"""
|
||
parser = ExcelFileParcer(sample_excel_bytes, sample_config)
|
||
result_bytes = parser.get_file_bytes()
|
||
|
||
# Пытаемся прочитать созданный файл
|
||
result_bytes.seek(0)
|
||
df = pd.read_excel(result_bytes, sheet_name=0, header=None)
|
||
|
||
assert df is not None
|
||
assert len(df) > 0
|
||
|
||
def test_get_order_rows(self, excel_with_header_row, sample_config):
|
||
"""Тест получения строк заказа"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
order_rows = parser.get_order_rows()
|
||
|
||
assert order_rows is not None
|
||
assert isinstance(order_rows, pd.DataFrame)
|
||
assert len(order_rows) > 0
|
||
# Проверяем, что пустая строка обрезана
|
||
assert len(order_rows) == 3 # Только строки с данными
|
||
|
||
def test_get_order_rows_with_empty_file(self, sample_config):
|
||
"""Тест получения строк заказа из пустого файла"""
|
||
# Создаем пустой DataFrame
|
||
df = pd.DataFrame([['Артикул', 'Производитель'], [None, None]])
|
||
buf = BytesIO()
|
||
with pd.ExcelWriter(buf, engine='xlsxwriter') as writer:
|
||
df.to_excel(writer, sheet_name='Sheet1', index=False, header=False)
|
||
buf.seek(0)
|
||
empty_bytes = buf.getvalue()
|
||
|
||
parser = ExcelFileParcer(empty_bytes, sample_config)
|
||
|
||
# Должен вернуть пустой DataFrame или вызвать ошибку
|
||
try:
|
||
order_rows = parser.get_order_rows()
|
||
assert len(order_rows) == 0
|
||
except (IndexError, KeyError):
|
||
# Ожидаемое поведение при отсутствии данных
|
||
pass
|
||
|
||
def test_set_value_updates_dataframe(self, excel_with_header_row, sample_config):
|
||
"""Тест что set_value обновляет DataFrame"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
|
||
# Находим строку с ART002
|
||
row_idx = parser._get_attr_row("ART002", "MAN002")
|
||
price_col_idx = parser._get_attr_column("Цена")
|
||
|
||
original_price = parser.df.iloc[row_idx, price_col_idx]
|
||
|
||
# Устанавливаем новое значение
|
||
parser.set_value("ART002", "MAN002", "Цена", 555.0)
|
||
|
||
# Проверяем обновление
|
||
updated_price = parser.df.iloc[row_idx, price_col_idx]
|
||
assert updated_price == 555.0
|
||
assert updated_price != original_price
|
||
|
||
def test_multiple_set_value_operations(self, excel_with_header_row, sample_config):
|
||
"""Тест множественных операций set_value"""
|
||
parser = ExcelFileParcer(excel_with_header_row, sample_config)
|
||
|
||
# Устанавливаем несколько значений
|
||
parser.set_value("ART001", "MAN001", "Цена", 111.0)
|
||
parser.set_value("ART002", "MAN002", "Цена", 222.0)
|
||
parser.set_value("ART003", "MAN003", "Цена", 333.0)
|
||
|
||
# Проверяем все значения
|
||
price_col_idx = parser._get_attr_column("Цена")
|
||
row1_idx = parser._get_attr_row("ART001", "MAN001")
|
||
row2_idx = parser._get_attr_row("ART002", "MAN002")
|
||
row3_idx = parser._get_attr_row("ART003", "MAN003")
|
||
|
||
assert parser.df.iloc[row1_idx, price_col_idx] == 111.0
|
||
assert parser.df.iloc[row2_idx, price_col_idx] == 222.0
|
||
assert parser.df.iloc[row3_idx, price_col_idx] == 333.0
|
||
|
||
def test_get_order_rows_trimmed_correctly(self, sample_config):
|
||
"""Тест что get_order_rows правильно обрезает пустые строки"""
|
||
# Создаем файл с пустой строкой в середине
|
||
df = pd.DataFrame([
|
||
['Артикул', 'Производитель', 'Наименование'],
|
||
['ART001', 'MAN001', 'Товар 1'],
|
||
['ART002', 'MAN002', 'Товар 2'],
|
||
[None, None, None], # Пустая строка
|
||
['ART003', 'MAN003', 'Товар 3'],
|
||
[None, None, None] # Еще одна пустая строка
|
||
])
|
||
buf = BytesIO()
|
||
with pd.ExcelWriter(buf, engine='xlsxwriter') as writer:
|
||
df.to_excel(writer, sheet_name='Sheet1', index=False, header=False)
|
||
buf.seek(0)
|
||
excel_bytes = buf.getvalue()
|
||
|
||
parser = ExcelFileParcer(excel_bytes, sample_config)
|
||
order_rows = parser.get_order_rows()
|
||
|
||
# Должны остаться только строки до первой пустой
|
||
assert len(order_rows) == 2 # ART001 и ART002
|
||
|
||
@patch('mail_order_bot.parsers.excel_parcer.pd.read_excel')
|
||
def test_get_order_rows_with_calamine_engine(self, mock_read_excel, sample_config):
|
||
"""Тест что get_order_rows использует calamine engine"""
|
||
# Создаем мок DataFrame
|
||
mock_df = pd.DataFrame({
|
||
'Артикул': ['ART001', 'ART002', None],
|
||
'Производитель': ['MAN001', 'MAN002', None]
|
||
})
|
||
mock_read_excel.return_value = mock_df
|
||
|
||
# Создаем парсер с моком для первого чтения
|
||
df_init = pd.DataFrame([
|
||
['Артикул', 'Производитель'],
|
||
['ART001', 'MAN001'],
|
||
['ART002', 'MAN002'],
|
||
[None, None]
|
||
])
|
||
with patch('mail_order_bot.parsers.excel_parcer.pd.read_excel') as mock_init:
|
||
mock_init.return_value = df_init
|
||
parser = ExcelFileParcer(b"test", sample_config)
|
||
|
||
# Тестируем get_order_rows
|
||
with patch('mail_order_bot.parsers.excel_parcer.pd.read_excel') as mock_get:
|
||
mock_get.return_value = mock_df
|
||
result = parser.get_order_rows()
|
||
|
||
# Проверяем, что был вызван read_excel с engine='calamine'
|
||
mock_get.assert_called_once()
|
||
call_kwargs = mock_get.call_args[1]
|
||
assert call_kwargs.get('engine') == 'calamine'
|
||
|