testing django book

doc/source/sqlalchemy.rst

@@ -5,7 +5,7 @@ Suppose we have a pure sql database connection via sqlalchemy:
 
     >>> from sqlalchemy import create_engine
     >>> from sqlalchemy.ext.declarative import declarative_base
-    >>> from sqlalchemy import Column , Integer, String, Float, Date, ForeignKey, DateTime
+    >>> from sqlalchemy import Column , Integer, String, Float, Date
     >>> from sqlalchemy.orm import sessionmaker
     >>> engine=create_engine("sqlite:///tmp.db")
     >>> Base=declarative_base()
@@ -79,6 +79,7 @@ Before we start, let's clear off previous table:
 
 Now suppose we have these more complex tables:
 
+    >>> from sqlalchemy import ForeignKey, DateTime
     >>> from sqlalchemy.orm import relationship, backref
     >>> class Post(Base):
     ...     __tablename__ = 'post'

test.sh

@@ -1,4 +1,4 @@
 #/bin/bash
 
 nosetests --rednose --with-cov --cov pyexcel_io --cov tests --with-doctest --doctest-extension=.rst doc/source tests pyexcel_io
-rm tmp.db
+

tests/test_django_book.py

@@ -0,0 +1,149 @@
+from pyexcel_io import get_data, save_data, DB_DJANGO, OrderedDict
+from nose.tools import raises
+
+class Attributable:
+    def __init__(self, adict):
+        self.mydict = adict
+
+    def __getattr__(self, field):
+        return self.mydict[field]
+
+class Objects:
+    def __init__(self):
+        self.objs = None
+
+    def bulk_create(self, objs, batch_size):
+        self.objs = objs
+        self.batch_size = batch_size
+
+    def all(self):
+        return [Attributable(o) for o in self.objs]
+
+class Field:
+    def __init__(self, name):
+        self.attname = name
+
+class Meta:
+    def __init__(self):
+        self.model_name = "test"
+        self.concrete_fields = []
+
+    def update(self, data):
+        for f in data:
+            self.concrete_fields.append(Field(f))
+
+class FakeDjangoModel:
+    def __init__(self):
+        self.objects = Objects()
+        self._meta = Meta()
+
+    def __call__(self, **keywords):
+        return keywords
+
+
+class TestSheet:
+    def setUp(self):
+        self.data  = [
+            ["X", "Y", "Z"],
+            [1, 2, 3],
+            [4, 5, 6]
+        ]
+        self.result = [
+            {'Y': 2, 'X': 1, 'Z': 3},
+            {'Y': 5, 'X': 4, 'Z': 6}
+        ]
+
+    def test_sheet_save_to_django_model(self):
+        model=FakeDjangoModel()
+        save_data(DB_DJANGO, self.data[1:], models={"csv": [model, self.data[0], None, None]})
+        assert model.objects.objs == self.result
+
+    def test_sheet_save_to_django_model_3(self):
+        model=FakeDjangoModel()
+        def wrapper(row):
+            row[0] = row[0] + 1
+            return row
+        save_data(DB_DJANGO, self.data[1:], models={"csv": [model, self.data[0], None, wrapper]})
+        assert model.objects.objs == [
+            {'Y': 2, 'X': 2, 'Z': 3},
+            {'Y': 5, 'X': 5, 'Z': 6}
+        ]
+
+    def test_load_sheet_from_django_model(self):
+        model=FakeDjangoModel()
+        save_data(DB_DJANGO, self.data[1:], models={"csv": [model, self.data[0], None, None]})
+        assert model.objects.objs == self.result
+        model._meta.update(["X", "Y", "Z"])
+        data = get_data(DB_DJANGO, models=[model])
+        assert data == self.data
+
+    def test_mapping_array(self):
+        data2 = [
+            ["A", "B", "C"],
+            [1, 2, 3],
+            [4, 5, 6]
+        ]
+        mapdict = ["X", "Y", "Z"]
+        model=FakeDjangoModel()
+        save_data(DB_DJANGO, data2[1:], models={"csv": [model, data2[0], mapdict, None]})
+        assert model.objects.objs == self.result
+
+    def test_mapping_dict(self):
+        data2 = [
+            ["A", "B", "C"],
+            [1, 2, 3],
+            [4, 5, 6]
+        ]
+        mapdict = {
+            "C": "Z",
+            "A": "X",
+            "B": "Y"
+        }
+        model=FakeDjangoModel()
+        save_data(DB_DJANGO, data2[1:], models={"csv": [model, data2[0], mapdict, None]})
+        assert model.objects.objs == self.result
+
+
+class TestMultipleModels:
+    def setUp(self):
+        self.content = OrderedDict()
+        self.content.update({"Sheet1": [[u'X', u'Y', u'Z'], [1, 4, 7], [2, 5, 8], [3, 6, 9]]})
+        self.content.update({"Sheet2": [[u'A', u'B', u'C'], [1, 4, 7], [2, 5, 8], [3, 6, 9]]})
+        self.result1 = [{'Y': 4, 'X': 1, 'Z': 7}, {'Y': 5, 'X': 2, 'Z': 8}, {'Y': 6, 'X': 3, 'Z': 9}]
+        self.result2 = [{'B': 4, 'A': 1, 'C': 7}, {'B': 5, 'A': 2, 'C': 8}, {'B': 6, 'A': 3, 'C': 9}]
+
+    def test_save_to_more_models(self):
+        model1=FakeDjangoModel()
+        model2=FakeDjangoModel()
+        to_store = {
+            "Sheet1": self.content['Sheet1'][1:],
+            "Sheet2": self.content['Sheet2'][1:]
+        }
+        save_data(DB_DJANGO, to_store, models={
+            "Sheet1": [model1, self.content['Sheet1'][0], None, None],
+            "Sheet2": [model2, self.content['Sheet2'][0], None, None]
+        })
+        assert model1.objects.objs == self.result1
+        assert model2.objects.objs == self.result2
+
+    def test_reading_from_more_models(self):
+        model1=FakeDjangoModel()
+        model2=FakeDjangoModel()
+        to_store = {
+            "Sheet1": self.content['Sheet1'][1:],
+            "Sheet2": self.content['Sheet2'][1:]
+        }
+        save_data(DB_DJANGO, to_store, models={
+            "Sheet1": [model1, self.content['Sheet1'][0], None, None],
+            "Sheet2": [model2, self.content['Sheet2'][0], None, None]
+        })
+        assert model1.objects.objs == self.result1
+        assert model2.objects.objs == self.result2
+        model1._meta.model_name = "Sheet1"
+        model2._meta.model_name = "Sheet2"
+        model1._meta.update(["X", "Y", "Z"])
+        model2._meta.update(["A", "B", "C"])
+        data = get_data(DB_DJANGO, models=[model1, model2])
+        assert data == self.content
+
+