Merge branch 'develop'

1 files changed, 218 insertions, 11 deletions

diff --git a/test_tablib.py b/test_tablib.py
index 8245944..78d1045 100755
--- a/test_tablib.py
+++ b/test_tablib.py
@@ -1,13 +1,14 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
 """Tests for Tablib."""
 
+import json
 import unittest
 import sys
-
+import os
 import tablib
-from tablib.compat import markup
+from tablib.compat import markup, unicode, is_py3
+
 
 
 
@@ -28,7 +29,7 @@ class TablibTestCase(unittest.TestCase):
         self.george = ('George', 'Washington', 67)
         self.tom = ('Thomas', 'Jefferson', 50)
 
-        self.founders = tablib.Dataset(headers=self.headers)
+        self.founders = tablib.Dataset(headers=self.headers, title='Founders')
         self.founders.append(self.john)
         self.founders.append(self.george)
         self.founders.append(self.tom)
@@ -58,6 +59,18 @@ class TablibTestCase(unittest.TestCase):
 
         self.assertRaises(tablib.InvalidDimensions, data.append, new_row)
 
+    def test_set_headers_with_incorrect_dimension(self):
+        """Verify headers correctly detects mismatch of number of
+        headers and data.
+        """
+
+        data.append(self.john)
+
+        def set_header_callable():
+            data.headers = ['first_name']
+
+        self.assertRaises(tablib.InvalidDimensions, set_header_callable)
+
 
     def test_add_column(self):
         """Verify adding column works with/without headers."""
@@ -92,6 +105,53 @@ class TablibTestCase(unittest.TestCase):
         self.assertEqual(data.height, len(new_col))
 
 
+    def test_add_column_with_header_ignored(self):
+        """Verify append_col() ignores the header if data.headers has
+        not previously been set
+        """
+
+        new_col = ('reitz', 'monke')
+
+        data.append_col(new_col, header='first_name')
+
+        self.assertEqual(data[0], tuple([new_col[0]]))
+        self.assertEqual(data.width, 1)
+        self.assertEqual(data.height, len(new_col))
+        self.assertEqual(data.headers, None)
+
+
+    def test_add_column_with_header_and_headers_only_exist(self):
+        """Verify append_col() with header correctly detects mismatch when
+        headers exist but there is no existing row data
+        """
+
+        data.headers = ['first_name']
+        #no data
+
+        new_col = ('allen')
+
+        def append_col_callable():
+            data.append_col(new_col, header='middle_name')
+
+        self.assertRaises(tablib.InvalidDimensions, append_col_callable)
+
+
+    def test_add_column_with_header_and_data_exists(self):
+        """Verify append_col() works when headers and rows exists"""
+
+        data.headers = self.headers
+        data.append(self.john)
+
+        new_col = [10];
+
+        data.append_col(new_col, header='age')
+
+        self.assertEqual(data.height, 1)
+        self.assertEqual(data.width, len(self.john) + 1)
+        self.assertEqual(data['age'], new_col)
+        self.assertEqual(len(data.headers), len(self.headers) + 1)
+
+
     def test_add_callable_column(self):
         """Verify adding column with values specified as callable."""
 
@@ -113,6 +173,22 @@ class TablibTestCase(unittest.TestCase):
             [self.john[2], self.george[2], self.tom[2]])
 
 
+    def test_get_col(self):
+        """Verify getting columns by index"""
+
+        self.assertEqual(
+            self.founders.get_col(list(self.headers).index('first_name')),
+            [self.john[0], self.george[0], self.tom[0]])
+
+        self.assertEqual(
+            self.founders.get_col(list(self.headers).index('last_name')),
+            [self.john[1], self.george[1], self.tom[1]])
+
+        self.assertEqual(
+            self.founders.get_col(list(self.headers).index('gpa')),
+            [self.john[2], self.george[2], self.tom[2]])
+
+
     def test_data_slicing(self):
         """Verify slicing by data."""
 
@@ -172,9 +248,9 @@ class TablibTestCase(unittest.TestCase):
 
 
     def test_tsv_export(self):
-        """Verify exporting dataset object as CSV."""
+        """Verify exporting dataset object as TSV."""
 
-        # Build up the csv string with headers first, followed by each row
+        # Build up the tsv string with headers first, followed by each row
         tsv = ''
         for col in self.headers:
             tsv += col + '\t'
@@ -209,10 +285,36 @@ class TablibTestCase(unittest.TestCase):
         self.assertEqual(html, self.founders.html)
 
 
+    def test_html_export_none_value(self):
+        """HTML export"""
+
+        html = markup.page()
+        html.table.open()
+        html.thead.open()
+
+        html.tr(markup.oneliner.th(['foo','', 'bar']))
+        html.thead.close()
+
+        html.tr(markup.oneliner.td(['foo','', 'bar']))
+
+        html.table.close()
+        html = str(html)
+
+        headers = ['foo', None, 'bar'];
+        d = tablib.Dataset(['foo', None, 'bar'], headers=headers)
+
+        self.assertEqual(html, d.html)
+
+
     def test_unicode_append(self):
-        """Passes in a single unicode charecter and exports."""
+        """Passes in a single unicode character and exports."""
+
+        if is_py3:
+            new_row = ('å', 'é')
+        else:
+            exec("new_row = (u'å', u'é')")
+
 
-        new_row = ('å', 'é')
         data.append(new_row)
 
         data.json
@@ -226,7 +328,7 @@ class TablibTestCase(unittest.TestCase):
 
 
     def test_book_export_no_exceptions(self):
-        """Test that varoius exports don't error out."""
+        """Test that various exports don't error out."""
 
         book = tablib.Databook()
         book.add_sheet(data)
@@ -248,7 +350,7 @@ class TablibTestCase(unittest.TestCase):
 
         data.json = _json
 
-        self.assertEqual(_json, data.json)
+        self.assertEqual(json.loads(_json), json.loads(data.json))
 
 
     def test_json_import_book(self):
@@ -262,7 +364,7 @@ class TablibTestCase(unittest.TestCase):
 
         book.json = _json
 
-        self.assertEqual(_json, book.json)
+        self.assertEqual(json.loads(_json), json.loads(book.json))
 
 
     def test_yaml_import_set(self):
@@ -319,6 +421,22 @@ class TablibTestCase(unittest.TestCase):
         self.assertEqual(_csv, data.csv)
 
 
+    def test_csv_import_set_with_newlines(self):
+        """Generate and import CSV set serialization when row values have
+        newlines."""
+        data.append(('Markdown\n=======',
+                     'A cool language\n\nwith paragraphs'))
+        data.append(('reStructedText\n==============',
+                     'Another cool language\n\nwith paragraphs'))
+        data.headers = ('title', 'body')
+
+        _csv = data.csv
+
+        data.csv = _csv
+
+        self.assertEqual(_csv, data.csv)
+
+
     def test_tsv_import_set(self):
         """Generate and import TSV set serialization."""
         data.append(self.john)
@@ -380,12 +498,14 @@ class TablibTestCase(unittest.TestCase):
         """Test YAML format detection."""
 
         _yaml = '- {age: 90, first_name: John, last_name: Adams}'
+        _tsv = 'foo\tbar'
         _bunk = (
             '¡¡¡¡¡¡---///\n\n\n¡¡£™∞¢£§∞§¶•¶ª∞¶•ªº••ª–º§•†•§º¶•†¥ª–º•§ƒø¥¨©πƒø†ˆ¥ç©¨√øˆ¥≈†ƒ¥ç©ø¨çˆ¥ƒçø¶'
         )
 
         self.assertTrue(tablib.formats.yaml.detect(_yaml))
         self.assertFalse(tablib.formats.yaml.detect(_bunk))
+        self.assertFalse(tablib.formats.yaml.detect(_tsv))
 
 
     def test_auto_format_detect(self):
@@ -394,10 +514,12 @@ class TablibTestCase(unittest.TestCase):
         _yaml = '- {age: 90, first_name: John, last_name: Adams}'
         _json = '[{"last_name": "Adams","age": 90,"first_name": "John"}]'
         _csv = '1,2,3\n4,5,6\n7,8,9\n'
+        _tsv = '1\t2\t3\n4\t5\t6\n7\t8\t9\n'
         _bunk = '¡¡¡¡¡¡---///\n\n\n¡¡£™∞¢£§∞§¶•¶ª∞¶•ªº••ª–º§•†•§º¶•†¥ª–º•§ƒø¥¨©πƒø†ˆ¥ç©¨√øˆ¥≈†ƒ¥ç©ø¨çˆ¥ƒçø¶'
 
         self.assertEqual(tablib.detect(_yaml)[0], tablib.formats.yaml)
         self.assertEqual(tablib.detect(_csv)[0], tablib.formats.csv)
+        self.assertEqual(tablib.detect(_tsv)[0], tablib.formats.tsv)
         self.assertEqual(tablib.detect(_json)[0], tablib.formats.json)
         self.assertEqual(tablib.detect(_bunk)[0], None)
 
@@ -458,6 +580,7 @@ class TablibTestCase(unittest.TestCase):
         """Sort columns."""
 
         sorted_data = self.founders.sort(col="first_name")
+        self.assertEqual(sorted_data.title, 'Founders')
 
         first_row = sorted_data[0]
         second_row = sorted_data[2]
@@ -512,5 +635,89 @@ class TablibTestCase(unittest.TestCase):
 
         data.csv
 
+    def test_csv_column_select(self):
+        """Build up a CSV and test selecting a column"""
+
+        data = tablib.Dataset()
+        data.csv = self.founders.csv
+
+        headers = data.headers
+        self.assertTrue(isinstance(headers[0], unicode))
+
+        orig_first_name = self.founders[self.headers[0]]
+        csv_first_name = data[headers[0]]
+        self.assertEqual(orig_first_name, csv_first_name)
+
+
+    def test_csv_column_delete(self):
+        """Build up a CSV and test deleting a column"""
+
+        data = tablib.Dataset()
+        data.csv = self.founders.csv
+
+        target_header = data.headers[0]
+        self.assertTrue(isinstance(target_header, unicode))
+
+        del data[target_header]
+
+        self.assertTrue(target_header not in data.headers)
+
+    def test_csv_column_sort(self):
+        """Build up a CSV and test sorting a column by name"""
+
+        data = tablib.Dataset()
+        data.csv = self.founders.csv
+
+        orig_target_header = self.founders.headers[1]
+        target_header = data.headers[1]
+
+        self.founders.sort(orig_target_header)
+        data.sort(target_header)
+
+        self.assertEqual(self.founders[orig_target_header], data[target_header])
+
+    def test_unicode_renders_markdown_table(self):
+        # add another entry to test right field width for
+        # integer
+        self.founders.append(('Old', 'Man', 100500))
+
+        self.assertEqual(
+            """
+first_name|last_name |gpa   
+----------|----------|------
+John      |Adams     |90    
+George    |Washington|67    
+Thomas    |Jefferson |50    
+Old       |Man       |100500
+""".strip(),
+            unicode(self.founders)
+        )
+
+
+    def test_databook_add_sheet_accepts_only_dataset_instances(self):
+        class NotDataset(object):
+            def append(self, item):
+                pass
+
+        dataset = NotDataset()
+        dataset.append(self.john)
+
+        self.assertRaises(tablib.InvalidDatasetType, book.add_sheet, dataset)
+
+
+    def test_databook_add_sheet_accepts_dataset_subclasses(self):
+        class DatasetSubclass(tablib.Dataset):
+            pass
+
+        # just checking if subclass of tablib.Dataset can be added to Databook
+        dataset = DatasetSubclass()
+        dataset.append(self.john)
+        dataset.append(self.tom)
+
+        try:
+            book.add_sheet(dataset)
+        except tablib.InvalidDatasetType:
+            self.fail("Subclass of tablib.Dataset should be accepted by Databook.add_sheet")
+
 if __name__ == '__main__':
     unittest.main()