|
# coding: utf8
|
|
from __future__ import unicode_literals
|
|
import os
|
|
from csv import reader
|
|
import unittest
|
|
from tempfile import mkdtemp
|
|
from shutil import rmtree
|
|
|
|
from six import PY3, text_type, binary_type
|
|
|
|
from dataset import connect
|
|
from dataset.freeze.app import freeze
|
|
from dataset.freeze.format.fcsv import value_to_str
|
|
|
|
from .sample_data import TEST_DATA
|
|
|
|
|
|
class FreezeTestCase(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.db = connect('sqlite://')
|
|
self.tbl = self.db['weather']
|
|
for row in TEST_DATA:
|
|
self.tbl.insert(row)
|
|
self.d = mkdtemp()
|
|
|
|
def tearDown(self):
|
|
rmtree(self.d, ignore_errors=True)
|
|
|
|
def test_freeze(self):
|
|
freeze(self.tbl.all(), format='csv',
|
|
filename='wäther.csv'.encode('utf8'), prefix=self.d)
|
|
self.assertTrue(os.path.exists(os.path.join(self.d, 'wäther.csv')))
|
|
freeze(self.tbl.all(), format='csv',
|
|
filename='wäther.csv', prefix=self.d)
|
|
self.assertTrue(os.path.exists(os.path.join(self.d, 'wäther.csv')))
|
|
|
|
def test_freeze_csv(self):
|
|
freeze(self.tbl.all(), format='csv',
|
|
filename='weather.csv', prefix=self.d)
|
|
path = os.path.join(self.d, 'weather.csv')
|
|
if PY3:
|
|
fh = open(path, 'rt', encoding='utf8', newline='')
|
|
else:
|
|
fh = open(path, 'rU')
|
|
try:
|
|
rows = list(reader(fh))
|
|
keys = rows[0]
|
|
for i, d1 in enumerate(TEST_DATA):
|
|
d2 = dict(zip(keys, rows[i + 1]))
|
|
for k in d1.keys():
|
|
v2 = d2[k]
|
|
if not PY3:
|
|
v2 = v2.decode('utf8')
|
|
v1 = value_to_str(d1[k])
|
|
if not isinstance(v1, text_type):
|
|
if isinstance(v1, binary_type):
|
|
v1 = text_type(v1, encoding='utf8')
|
|
else:
|
|
v1 = '%s' % v1
|
|
self.assertEqual(v2, v1)
|
|
finally:
|
|
fh.close()
|
|
|
|
def test_memory_streams(self):
|
|
if PY3:
|
|
from io import StringIO
|
|
else:
|
|
from io import BytesIO as StringIO
|
|
|
|
for fmt in ('csv', 'json', 'tabson'):
|
|
with StringIO() as fd:
|
|
freeze(self.tbl.all(), format=fmt, fileobj=fd)
|
|
self.assertFalse(fd.closed, 'fileobj was closed for format %s' % fmt)
|
|
fd.getvalue() # should not throw
|
|
|
|
def test_freeze_json_no_wrap(self):
|
|
freeze(self.tbl.all(), format='json',
|
|
filename='weather.csv', prefix=self.d, wrap=False)
|
|
path = os.path.join(self.d, 'weather.csv')
|
|
if PY3:
|
|
fh = open(path, 'rt', encoding='utf8', newline='')
|
|
else:
|
|
fh = open(path, 'rU')
|
|
try:
|
|
import json
|
|
data = json.load(fh)
|
|
self.assertIsInstance(data, list,
|
|
'Without wrapping, returned JSON should be a list')
|
|
finally:
|
|
fh.close()
|
|
|
|
def test_freeze_json_wrap(self):
|
|
freeze(self.tbl.all(), format='json',
|
|
filename='weather.csv', prefix=self.d, wrap=True)
|
|
path = os.path.join(self.d, 'weather.csv')
|
|
if PY3:
|
|
fh = open(path, 'rt', encoding='utf8', newline='')
|
|
else:
|
|
fh = open(path, 'rU')
|
|
try:
|
|
import json
|
|
data = json.load(fh)
|
|
self.assertIsInstance(data, dict,
|
|
'With wrapping, returned JSON should be a dict')
|
|
self.assertIn('results', data.keys())
|
|
self.assertIn('count', data.keys())
|
|
self.assertIn('meta', data.keys())
|
|
finally:
|
|
fh.close()
|
|
|
|
|
|
class SerializerTestCase(unittest.TestCase):
|
|
|
|
def test_serializer(self):
|
|
from dataset.freeze.format.common import Serializer
|
|
from dataset.freeze.config import Export
|
|
from dataset.util import FreezeException
|
|
|
|
self.assertRaises(FreezeException, Serializer, {}, {})
|
|
s = Serializer(Export({'filename': 'f'}, {'mode': 'nomode'}), '')
|
|
self.assertRaises(FreezeException, getattr, s, 'wrap')
|
|
s = Serializer(Export({'filename': 'f'}, {}), '')
|
|
s.wrap
|
|
s = Serializer(Export({'filename': '-'}, {}), '')
|
|
self.assertTrue(s.fileobj)
|
|
|
|
def test_value_to_str1(self):
|
|
assert '2011-01-01T00:00:00' == value_to_str(TEST_DATA[0]['date']), \
|
|
value_to_str(TEST_DATA[0]['date'])
|
|
|
|
def test_value_to_str2(self):
|
|
if PY3:
|
|
assert 'hóla' == value_to_str('\u0068\u00f3\u006c\u0061')
|
|
else:
|
|
assert u'hóla'.encode('utf-8') == value_to_str(u'\u0068\u00f3\u006c\u0061'), \
|
|
[value_to_str(u'\u0068\u00f3\u006c\u0061')]
|
|
|
|
def test_value_to_str3(self):
|
|
assert '' == value_to_str(None)
|
|
|
|
def test_value_to_str4(self):
|
|
assert [] == value_to_str([])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|