def test_normal_multi_table(self, con_a0, con_b0):
out_db_path = "test.sqlite"
runner = CliRunner()
with runner.isolated_filesystem():
result = runner.invoke(
cmd,
[
"file", con_a0.database_path, con_b0.database_path,
"-o", out_db_path,
])
print_traceback(result)
assert result.exit_code == ExitCode.SUCCESS
expected_list = [
TableData(
table_name=TEST_TABLE_NAME_A,
header_list=["attr_a", "attr_b"],
record_list=[
[1, 2],
[3, 4],
]),
TableData(
table_name=TEST_TABLE_NAME_B,
header_list=["ba", "bb"],
record_list=[
[101, 102],
[103, 104],
]),
]
for tabledata in SqliteFileLoader(out_db_path).load():
print("[actual] {}".format(tabledata))
assert tabledata in expected_list
def test_normal(self, table_name, header_list, record_list):
tabledata = TableData(table_name, header_list, record_list)
dataframe = pandas.DataFrame(record_list)
if typepy.is_not_empty_sequence(header_list):
dataframe.columns = header_list
print("lhs: {}".format(tabledata.as_dataframe()))
print("rhs: {}".format(dataframe))
assert tabledata.as_dataframe().equals(dataframe)
def test_normal(self, table_name, header_list, record_list):
tabledata_a0 = TableData(table_name, header_list, record_list)
tabledata_a1 = TableData(table_name, header_list, record_list)
tabledata_b0 = TableData("dummy", header_list, record_list)
assert tabledata_a0.__hash__() == tabledata_a1.__hash__()
assert tabledata_a0.__hash__() != tabledata_b0.__hash__()
def test_normal(self, table_name, header_list, record_list, expected):
tabledata = TableData(table_name, header_list, record_list)
print("expected: {}".format(ptw.dump_tabledata(expected)))
print("actusl: {}".format(ptw.dump_tabledata(tabledata)))
assert tabledata == expected
def test_exception_invalid_data(
self, table_name, header_list, record_list, expected):
tabledata = TableData(table_name, header_list, record_list)
sanitizer = SQLiteTableDataSanitizer(tabledata)
with pytest.raises(expected):
sanitizer.sanitize()
def test_normal_same_table(self, con_a0, con_a1):
out_db_path = "test.sqlite"
runner = CliRunner()
with runner.isolated_filesystem():
result = runner.invoke(
cmd,
[
"file", con_a0.database_path, con_a1.database_path,
"-o", out_db_path,
])
print_traceback(result)
assert result.exit_code == ExitCode.SUCCESS
expected = TableData(
table_name=TEST_TABLE_NAME_A,
header_list=["attr_a", "attr_b"],
record_list=[
[1, 2],
[3, 4],
[11, 12],
[13, 14],
])
for tabledata in SqliteFileLoader(out_db_path).load():
assert tabledata == expected
def test_normal(
self, table_name, header_list, record_list,
expected):
tabledata = TableData(table_name, header_list, record_list)
sanitizer = SQLiteTableDataSanitizer(tabledata)
new_tabledata = sanitizer.sanitize()
print("lhs: {}".format(ptw.dump_tabledata(new_tabledata)))
print("rhs: {}".format(ptw.dump_tabledata(expected)))
assert new_tabledata == expected
class Test_TableData_constructor:
__MIXED_DATA = [
[1, 2],
(3, 4),
{
"attr_a": 5,
"attr_b": 6
},
{
"attr_a": 7,
"attr_b": 8,
"not_exist_attr": 100
},
{
"attr_a": 9
},
{
"attr_b": 10
},
{},
NamedTuple2(11, None),
]
@pytest.mark.parametrize(
["table_name", "header_list", "record_list", "expected"], [
[
"normal", ["a", "b"], [[1, 2], [3, 4]],
TableData("normal", ["a", "b"], [[1, 2], [3, 4]])
],
[
"empty_records", ["a", "b"], [],
TableData("empty_records", ["a", "b"], [])
],
[
"empty_header", [], [[1, 2], [3, 4]],
TableData("empty_header", [], [[1, 2], [3, 4]])
],
])
def test_normal(self, table_name, header_list, record_list, expected):
tabledata = TableData(table_name, header_list, record_list)
print("expected: {}".format(ptw.dump_tabledata(expected)))
print("actusl: {}".format(ptw.dump_tabledata(tabledata)))
assert tabledata == expected
@pytest.mark.parametrize(
["table_name", "header_list", "record_list", "expected"], [
[
"mixdata",
attr_list_2,
__MIXED_DATA,
TableData("mixdata", attr_list_2, [
[1, 2],
[3, 4],
[5, 6],
[7, 8],
[9, None],
[None, 10],
[None, None],
[11, None],
]),
],
])
def test_normal_none_value(self, table_name, header_list, record_list,
expected):
tabledata = TableData(table_name, header_list, record_list)
print("expected: {}".format(ptw.dump_tabledata(expected)))
print("actusl: {}".format(ptw.dump_tabledata(tabledata)))
assert tabledata == expected
@pytest.mark.parametrize(
["table_name", "header_list", "record_list", "expected"], [
["tablename", ["a", "b"], [1, 2], InvalidDataError],
])
def test_exception(self, table_name, header_list, record_list, expected):
with pytest.raises(expected):
TableData(table_name, header_list, record_list)
def test_normal(self, table_name, header_list, record_list, expected):
tabledata = TableData(table_name, header_list, record_list)
assert tabledata.is_empty() == expected
class Test_TableData_eq:
__DATA_0 = TableData("Sheet1", [
'i',
'f',
'c',
'if',
'ifc',
'bool',
'inf',
'nan',
'mix_num',
'time',
], [
[
1,
"1.1",
'aa',
1,
1,
'True',
float("inf"),
"nan",
1,
'2017-01-01T00:00:00',
],
[
2,
"2.2",
'bbb',
"2.2",
"2.2",
'False',
float("inf"),
float("NaN"),
float("inf"),
'2017-01-02 03:04:05+09:00',
],
[
3,
"3.33",
'cccc',
-3,
'ccc',
'True',
float("inf"),
float("NaN"),
float("NaN"),
'2017-01-01T00:00:00',
],
])
__DATA_1 = TableData("tablename", ["a", "b", "c", "dd", "e"], [])
@pytest.mark.parametrize(["lhs", "rhs", "expected"], [
[__DATA_0, __DATA_0, True],
[__DATA_0, __DATA_1, False],
])
def test_normal(self, lhs, rhs, expected):
assert (lhs == rhs) == expected
assert (lhs != rhs) == (not expected)
import io
import collections
from path import Path
import pytablewriter as ptw
import pytest
import pytablereader as ptr
from pytablereader.interface import TableLoader
from pytablereader import TableData
from pytablereader.html.formatter import HtmlTableFormatter
Data = collections.namedtuple("Data", "value table_name expected")
test_data_empty = Data("""[]""", "", [
TableData("tmp", [], []),
])
test_data_01 = Data(value="""<title>title</title>
<table>
<thead>
<tr>
<th>a</th>
<th>b</th>
<th>c</th>
</tr>
</thead>
<tbody>
<tr>
<td align="right">1</td>
<td align="right">123.1</td>
Data = collections.namedtuple("Data", "value expected")
test_data_00 = Data(
"\n".join([
'"attr_a"\t"attr_b"\t"attr_c"',
'1\t4\t"a"',
'2\t2.1\t"bb"',
'3\t120.9\t"ccc"',
]),
[
TableData(
"tmp",
["attr_a", "attr_b", "attr_c"],
[
[1, 4, "a"],
[2, "2.1", "bb"],
[3, "120.9", "ccc"],
])
])
test_data_01 = Data(
"\n".join([
'"attr_a"\t"attr_b"\t"attr_c"',
'1\t4\t"a"',
'2\t2.1\t"bb"',
'3\t120.9\t"ccc"',
]),
[
TableData(
"foo_bar",
import pytest
import pytablewriter as ptw
import pytablereader as ptr
from pytablereader.interface import TableLoader
from pytablereader import TableData
from pytablereader import InvalidTableNameError
Data = collections.namedtuple("Data", "value expected")
test_data_empty = Data(
"""[]""",
[
TableData("tmp", [], []),
])
test_data_01 = Data(
"""[
{"attr_b": 4, "attr_c": "a", "attr_a": 1},
{"attr_b": 2.1, "attr_c": "bb", "attr_a": 2},
{"attr_b": 120.9, "attr_c": "ccc", "attr_a": 3}
]""",
[
TableData(
"json1",
["attr_a", "attr_b", "attr_c"],
[
{'attr_a': 1, 'attr_b': 4, 'attr_c': 'a'},
{'attr_a': 2, 'attr_b': 2.1, 'attr_c': 'bb'},
class Test_SQLiteTableDataSanitizer:
@pytest.mark.parametrize(
[
"table_name", "header_list", "record_list", "expected"
],
[
[
"normal", ["a", "b"], [[1, 2], [3, 4]],
TableData("normal", ["a", "b"], [[1, 2], [3, 4]])
],
[
"OFFSET", ["abort", "ASC"], [[1, 2], [3, 4]],
TableData("OFFSET", ["abort", "ASC"], [[1, 2], [3, 4]])
],
[
"all_missing_header", [], [[1, 2], [3, 4]],
TableData(
"all_missing_header",
["complement_attr_0", "complement_attr_1"],
[[1, 2], [3, 4]])
],
[
"part_missing_header", ["", "b", None], [],
TableData(
"part_missing_header",
["complement_attr_0", "b", "complement_attr_2"], [])
],
[
r"@a!b\c#d$e%f&g'h(i)j_",
[r"a!b\c#d$e%f&g'h(i)j", r"k@l[m]n{o}p;q:r,s.t/u\\v"],
[[1, 2], [3, 4]],
TableData(
"a_b_c_d_e_f_g_h_i_j",
["abcdefghij", "klmnopqrstuv"], [[1, 2], [3, 4]])
],
[ # SQLite reserved keywords
"ALL", ["and", "Index"], [[1, 2], [3, 4]],
TableData(
"rename_ALL",
["and", "Index"], [[1, 2], [3, 4]])
],
[
"0invalid_tn", ["1invalid", "where"], [[1, 2], [3, 4]],
TableData(
"rename_0invalid_tn",
["rename_1invalid", "where"], [[1, 2], [3, 4]])
],
[
"Python (programming language) - Wikipedia, the free encyclopedia.html",
["a b", "c d"], [[1, 2], [3, 4]],
TableData(
"Python_programming_language_Wikipedia_the_free_encyclopedia_html",
["ab", "cd"], [[1, 2], [3, 4]])
],
[
"multibyte csv",
["姓", "名", "生年月日", "郵便番号", "住所", "電話番号"],
[
["山田", "太郎", "2001/1/1", "100-0002",
"東京都千代田区皇居外苑", "03-1234-5678"],
["山田", "次郎", "2001/1/2", "251-0036",
"神奈川県藤沢市江の島１丁目", "03-9999-9999"],
],
TableData(
"multibyte_csv",
["姓", "名", "生年月日", "郵便番号", "住所", "電話番号"],
[
["山田", "太郎", "2001/1/1", "100-0002",
"東京都千代田区皇居外苑", "03-1234-5678"],
["山田", "次郎", "2001/1/2", "251-0036",
"神奈川県藤沢市江の島１丁目", "03-9999-9999"],
])
],
]
)
def test_normal(
self, table_name, header_list, record_list,
expected):
tabledata = TableData(table_name, header_list, record_list)
sanitizer = SQLiteTableDataSanitizer(tabledata)
new_tabledata = sanitizer.sanitize()
print("lhs: {}".format(ptw.dump_tabledata(new_tabledata)))
print("rhs: {}".format(ptw.dump_tabledata(expected)))
assert new_tabledata == expected
@pytest.mark.parametrize(
["table_name", "header_list", "record_list", "expected"], [
["", ["a", "b"], [], ptr.InvalidTableNameError],
[None, ["a", "b"], [], ptr.InvalidTableNameError],
["dummy", [], [], ptr.EmptyDataError],
]
)
def test_exception_invalid_data(
self, table_name, header_list, record_list, expected):
tabledata = TableData(table_name, header_list, record_list)
sanitizer = SQLiteTableDataSanitizer(tabledata)
with pytest.raises(expected):
sanitizer.sanitize()
from pytablereader.interface import TableLoader
from pytablereader import TableData
from pytablereader import (InvalidTableNameError, InvalidDataError,
InvalidHeaderNameError)
Data = collections.namedtuple("Data", "value expected")
test_data_00 = Data(
"""a.0:1\tb-1:123.1\tc_2:"a"\t"dd":1.0\te.f-g_4:"1"
a.0:2\tb-1:2.2\tc_2:"bb"\t"dd":2.2\te.f-g_4:"2.2"
a.0:3\tb-1:3.3\tc_2:"ccc"\t"dd":3.0\te.f-g_4:"cccc"
""",
TableData("tmp", ["a.0", "b-1", "c_2", "dd", "e.f-g_4"], [
[1, Decimal("123.1"), "a", 1, 1],
[2, Decimal("2.2"), "bb",
Decimal("2.2"),
Decimal("2.2")],
[3, Decimal("3.3"), "ccc", 3, "cccc"],
]))
class Test_LtsvTableFileLoader_make_table_name:
def setup_method(self, method):
TableLoader.clear_table_count()
@pytest.mark.parametrize(["value", "source", "expected"], [
["%(default)s", "/path/to/data.ltsv", "data"],
["%(filename)s", "/path/to/data.ltsv", "data"],
["prefix_%(filename)s", "/path/to/data.ltsv", "prefix_data"],
["%(filename)s_suffix", "/path/to/data.ltsv", "data_suffix"],
[
from path import Path
from pytablereader import InvalidTableNameError
from pytablereader import TableData
from pytablereader.interface import TableLoader
import pytest
from simplesqlite import SimpleSQLite
import pytablereader as ptr
import pytablewriter as ptw
Data = collections.namedtuple("Data", "value expected")
test_data_00 = Data(
TableData("tmp", ["attr_a", "attr_b", "attr_c"], [
[1, 4, "a"],
[2, Decimal("2.1"), "bb"],
[3, Decimal("120.9"), "ccc"],
]), [
TableData("tmp", ["attr_a", "attr_b", "attr_c"], [
[1, 4, "a"],
[2, Decimal("2.1"), "bb"],
[3, Decimal("120.9"), "ccc"],
]),
])
test_data_01 = Data(
TableData("foo_bar", ["attr_a", "attr_b", "attr_c"], [
["attr_a", "attr_b", "attr_c"],
[1, 4, "a"],
[2, "2.1", "bb"],
[3, "120.9", "ccc"],
def test_normal(self, table_name, header_list, record_list, expected):
tabledata = TableData(table_name, header_list, record_list)
assert tabledata.as_dict() == json.loads(expected)
def test_exception(self, table_name, header_list, record_list, expected):
with pytest.raises(expected):
TableData(table_name, header_list, record_list).as_dict()
import collections
from path import Path
from pytablereader import TableData
from pytablereader.interface import TableLoader
from pytablereader.mediawiki.formatter import MediaWikiTableFormatter
import pytest
import pytablereader as ptr
SKIP_TEST = True
Data = collections.namedtuple("Data", "value expected")
test_data_empty = Data("""[]""", [
TableData("tmp", [], []),
])
test_data_01 = Data(
"""hogehoge
{| class="wikitable"
! a
! b
! c
|-
| style="text-align:right"| 1
| style="text-align:right"| 123.1
| a
|-
| style="text-align:right"| 2
| style="text-align:right"| 2.2
