couchdb-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From robertkowal...@apache.org
Subject [37/50] [abbrv] couchdb-mango git commit: Refactor the test suite
Date Tue, 03 Feb 2015 15:13:44 GMT
Refactor the test suite

This moves the test suite to using unittest classes so that we can
control the database creation more directly. This also creates randomly
named databases so that we have fewer race conditions during test runs.

BugzId: 33294


Project: http://git-wip-us.apache.org/repos/asf/couchdb-mango/repo
Commit: http://git-wip-us.apache.org/repos/asf/couchdb-mango/commit/d1d13e6f
Tree: http://git-wip-us.apache.org/repos/asf/couchdb-mango/tree/d1d13e6f
Diff: http://git-wip-us.apache.org/repos/asf/couchdb-mango/diff/d1d13e6f

Branch: refs/heads/master
Commit: d1d13e6fdc42b81a7b333d213c3392dbe80bc825
Parents: fc8d7d0
Author: Paul J. Davis <paul.joseph.davis@gmail.com>
Authored: Thu Jan 8 17:12:20 2015 -0600
Committer: Paul J. Davis <paul.joseph.davis@gmail.com>
Committed: Fri Jan 16 13:32:49 2015 -0600

----------------------------------------------------------------------
 test/01-index-crud-test.py      | 362 +++++++++++------------
 test/02-basic-find-test.py      | 539 +++++++++++++++++------------------
 test/03-operator-test.py        | 132 ++++-----
 test/04-empty-selectors-test.py |  47 ---
 test/mango.py                   |  59 +++-
 test/user_docs.py               |  79 +++--
 6 files changed, 593 insertions(+), 625 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/couchdb-mango/blob/d1d13e6f/test/01-index-crud-test.py
----------------------------------------------------------------------
diff --git a/test/01-index-crud-test.py b/test/01-index-crud-test.py
index be13bdd..459566b 100644
--- a/test/01-index-crud-test.py
+++ b/test/01-index-crud-test.py
@@ -11,218 +11,184 @@
 # the License.
 
 import random
-import time
 
 import mango
 
 
-def mkdb():
-    return mango.Database("127.0.0.1", "5984", "mango_test")
+class IndexCrudTests(mango.DbPerClass):
+    def test_bad_fields(self):
+        bad_fields = [
+            None,
+            True,
+            False,
+            "bing",
+            2.0,
+            {"foo": "bar"},
+            [{"foo": 2}],
+            [{"foo": "asc", "bar": "desc"}],
+            [{"foo": "asc"}, {"bar": "desc"}]
+        ]
+        for fields in bad_fields:
+            try:
+                self.db.create_index(fields)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad create index")
+
+    def test_bad_types(self):
+        bad_types = [
+            None,
+            True,
+            False,
+            1.5,
+            "foo", # Future support
+            "geo", # Future support
+            {"foo": "bar"},
+            ["baz", 3.0]
+        ]
+        for bt in bad_types:
+            try:
+                self.db.create_index(["foo"], idx_type=bt)
+            except Exception, e:
+                assert e.response.status_code == 400, (bt, e.response.status_code)
+            else:
+                raise AssertionError("bad create index")
+
+    def test_bad_names(self):
+        bad_names = [
+            True,
+            False,
+            1.5,
+            {"foo": "bar"},
+            [None, False]
+        ]
+        for bn in bad_names:
+            try:
+                self.db.create_index(["foo"], name=bn)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad create index")
+            try:
+                self.db.create_index(["foo"], ddoc=bn)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad create index")
+
+    def test_create_idx_01(self):
+        fields = ["foo", "bar"]
+        ret = self.db.create_index(fields, name="idx_01")
+        assert ret is True
+        for idx in self.db.list_indexes():
+            if idx["name"] != "idx_01":
+                continue
+            assert idx["def"]["fields"] == [{"foo": "asc"}, {"bar": "asc"}]
+            return
+        raise AssertionError("index not created")
+
+    def test_create_idx_01_exists(self):
+        fields = ["foo", "bar"]
+        ret = self.db.create_index(fields, name="idx_01")
+        assert ret is False
+
+    def test_create_idx_02(self):
+        fields = ["baz", "foo"]
+        ret = self.db.create_index(fields, name="idx_02")
+        assert ret is True
+        for idx in self.db.list_indexes():
+            if idx["name"] != "idx_02":
+                continue
+            assert idx["def"]["fields"] == [{"baz": "asc"}, {"foo": "asc"}]
+            return
+        raise AssertionError("index not created")
 
+    def test_read_idx_doc(self):
+        for idx in self.db.list_indexes():
+            if idx["type"] == "special":
+                continue
+            ddocid = idx["ddoc"]
+            doc = self.db.open_doc(ddocid)
+            assert doc["_id"] == ddocid
+            info = self.db.ddoc_info(ddocid)
+            assert info["name"] == ddocid
+
+    def test_delete_idx_escaped(self):
+        pre_indexes = self.db.list_indexes()
+        ret = self.db.create_index(["bing"], name="idx_del_1")
+        assert ret is True
+        for idx in self.db.list_indexes():
+            if idx["name"] != "idx_del_1":
+                continue
+            assert idx["def"]["fields"] == [{"bing": "asc"}]
+            self.db.delete_index(idx["ddoc"].replace("/", "%2F"), idx["name"])
+        post_indexes = self.db.list_indexes()
+        assert pre_indexes == post_indexes
 
-def setup():
-    db = mkdb()
-    db.recreate()
-    time.sleep(1)
+    def test_delete_idx_unescaped(self):
+        pre_indexes = self.db.list_indexes()
+        ret = self.db.create_index(["bing"], name="idx_del_2")
+        assert ret is True
+        for idx in self.db.list_indexes():
+            if idx["name"] != "idx_del_2":
+                continue
+            assert idx["def"]["fields"] == [{"bing": "asc"}]
+            self.db.delete_index(idx["ddoc"], idx["name"])
+        post_indexes = self.db.list_indexes()
+        assert pre_indexes == post_indexes
 
+    def test_delete_idx_no_design(self):
+        pre_indexes = self.db.list_indexes()
+        ret = self.db.create_index(["bing"], name="idx_del_3")
+        assert ret is True
+        for idx in self.db.list_indexes():
+            if idx["name"] != "idx_del_3":
+                continue
+            assert idx["def"]["fields"] == [{"bing": "asc"}]
+            self.db.delete_index(idx["ddoc"].split("/")[-1], idx["name"])
+        post_indexes = self.db.list_indexes()
+        assert pre_indexes == post_indexes
 
-def test_bad_fields():
-    db = mkdb()
-    bad_fields = [
-        None,
-        True,
-        False,
-        "bing",
-        2.0,
-        {"foo": "bar"},
-        [{"foo": 2}],
-        [{"foo": "asc", "bar": "desc"}],
-        [{"foo": "asc"}, {"bar": "desc"}]
-    ]
-    for fields in bad_fields:
+    def test_recreate_index(self):
+        pre_indexes = self.db.list_indexes()
+        for i in range(5):
+            ret = self.db.create_index(["bing"], name="idx_recreate")
+            assert ret is True
+            for idx in self.db.list_indexes():
+                if idx["name"] != "idx_recreate":
+                    continue
+                assert idx["def"]["fields"] == [{"bing": "asc"}]
+                self.db.delete_index(idx["ddoc"], idx["name"])
+                break
+            post_indexes = self.db.list_indexes()
+            assert pre_indexes == post_indexes
+
+    def test_delete_misisng(self):
+        # Missing design doc
         try:
-            db.create_index(fields)
+            self.db.delete_index("this_is_not_a_design_doc_id", "foo")
         except Exception, e:
-            assert e.response.status_code == 400
+            assert e.response.status_code == 404
         else:
-            raise AssertionError("bad create index")
-
-
-def test_bad_types():
-    db = mkdb()
-    bad_types = [
-        None,
-        True,
-        False,
-        1.5,
-        "foo",
-        "text", # Future support
-        "geo", # Future support
-        {"foo": "bar"},
-        ["baz", 3.0]
-    ]
-    for bt in bad_types:
-        try:
-            db.create_index(["foo"], idx_type=bt)
-        except Exception, e:
-            assert e.response.status_code == 400, (bt, e.response.status_code)
-        else:
-            raise AssertionError("bad create index")
-
-
-def test_bad_names():
-    db = mkdb()
-    bad_names = [
-        True,
-        False,
-        1.5,
-        {"foo": "bar"},
-        [None, False]
-    ]
-    for bn in bad_names:
+            raise AssertionError("bad index delete")
+
+        # Missing view name
+        indexes = self.db.list_indexes()
+        not_special = [idx for idx in indexes if idx["type"] != "special"]
+        idx = random.choice(not_special)
+        ddocid = idx["ddoc"].split("/")[-1]
         try:
-            db.create_index(["foo"], name=bn)
+            self.db.delete_index(ddocid, "this_is_not_an_index_name")
         except Exception, e:
-            assert e.response.status_code == 400
+            assert e.response.status_code == 404
         else:
-            raise AssertionError("bad create index")
+            raise AssertionError("bad index delete")
+
+        # Bad view type
         try:
-            db.create_index(["foo"], ddoc=bn)
+            self.db.delete_index(ddocid, idx["name"], idx_type="not_a_real_type")
         except Exception, e:
-            assert e.response.status_code == 400
+            assert e.response.status_code == 404
         else:
-            raise AssertionError("bad create index")
-
-
-def test_create_idx_01():
-    db = mkdb()
-    fields = ["foo", "bar"]
-    ret = db.create_index(fields, name="idx_01")
-    assert ret is True
-    for idx in db.list_indexes():
-        if idx["name"] != "idx_01":
-            continue
-        assert idx["def"]["fields"] == [{"foo": "asc"}, {"bar": "asc"}]
-        return
-    raise AssertionError("index not created")
-
-
-def test_create_idx_01_exists():
-    db = mkdb()
-    fields = ["foo", "bar"]
-    ret = db.create_index(fields, name="idx_01")
-    assert ret is False
-
-
-def test_create_idx_02():
-    db = mkdb()
-    fields = ["baz", "foo"]
-    ret = db.create_index(fields, name="idx_02")
-    assert ret is True
-    for idx in db.list_indexes():
-        if idx["name"] != "idx_02":
-            continue
-        assert idx["def"]["fields"] == [{"baz": "asc"}, {"foo": "asc"}]
-        return
-    raise AssertionError("index not created")
-
-
-def test_read_idx_doc():
-    db = mkdb()
-    for idx in db.list_indexes():
-        if idx["type"] == "special":
-            continue
-        ddocid = idx["ddoc"]
-        doc = db.open_doc(ddocid)
-        assert doc["_id"] == ddocid
-        info = db.ddoc_info(ddocid)
-        assert info["name"] == ddocid
-
-
-def test_delete_idx_escaped():
-    db = mkdb()
-    pre_indexes = db.list_indexes()
-    ret = db.create_index(["bing"], name="idx_del_1")
-    assert ret is True
-    for idx in db.list_indexes():
-        if idx["name"] != "idx_del_1":
-            continue
-        assert idx["def"]["fields"] == [{"bing": "asc"}]
-        db.delete_index(idx["ddoc"].replace("/", "%2F"), idx["name"])
-    post_indexes = db.list_indexes()
-    assert pre_indexes == post_indexes
-
-
-def test_delete_idx_unescaped():
-    db = mkdb()
-    pre_indexes = db.list_indexes()
-    ret = db.create_index(["bing"], name="idx_del_2")
-    assert ret is True
-    for idx in db.list_indexes():
-        if idx["name"] != "idx_del_2":
-            continue
-        assert idx["def"]["fields"] == [{"bing": "asc"}]
-        db.delete_index(idx["ddoc"], idx["name"])
-    post_indexes = db.list_indexes()
-    assert pre_indexes == post_indexes
-
-
-def test_delete_idx_no_design():
-    db = mkdb()
-    pre_indexes = db.list_indexes()
-    ret = db.create_index(["bing"], name="idx_del_3")
-    assert ret is True
-    for idx in db.list_indexes():
-        if idx["name"] != "idx_del_3":
-            continue
-        assert idx["def"]["fields"] == [{"bing": "asc"}]
-        db.delete_index(idx["ddoc"].split("/")[-1], idx["name"])
-    post_indexes = db.list_indexes()
-    assert pre_indexes == post_indexes
-
-
-def test_recreate_index():
-    db = mkdb()
-    pre_indexes = db.list_indexes()
-    for i in range(5):
-        ret = db.create_index(["bing"], name="idx_recreate")
-        assert ret is True
-        for idx in db.list_indexes():
-            if idx["name"] != "idx_recreate":
-                continue
-            assert idx["def"]["fields"] == [{"bing": "asc"}]
-            db.delete_index(idx["ddoc"], idx["name"])
-            break
-        post_indexes = db.list_indexes()
-        assert pre_indexes == post_indexes
-
-
-def test_delete_missing():
-    db = mkdb()
-
-    # Missing design doc
-    try:
-        db.delete_index("this_is_not_a_design_doc_id", "foo")
-    except Exception, e:
-        assert e.response.status_code == 404
-    else:
-        raise AssertionError("bad index delete")
-
-    # Missing view name
-    indexes = db.list_indexes()
-    idx = random.choice([idx for idx in indexes if idx["type"] != "special"])
-    ddocid = idx["ddoc"].split("/")[-1]
-    try:
-        db.delete_index(ddocid, "this_is_not_an_index_name")
-    except Exception, e:
-        assert e.response.status_code == 404
-    else:
-        raise AssertionError("bad index delete")
-
-    # Bad view type
-    try:
-        db.delete_index(ddocid, idx["name"], idx_type="not_a_real_type")
-    except Exception, e:
-        assert e.response.status_code == 404
-    else:
-        raise AssertionError("bad index delete")
+            raise AssertionError("bad index delete")

http://git-wip-us.apache.org/repos/asf/couchdb-mango/blob/d1d13e6f/test/02-basic-find-test.py
----------------------------------------------------------------------
diff --git a/test/02-basic-find-test.py b/test/02-basic-find-test.py
index f6b0610..58029ed 100644
--- a/test/02-basic-find-test.py
+++ b/test/02-basic-find-test.py
@@ -11,286 +11,275 @@
 # the License.
 
 # -*- coding: latin-1 -*-
-import user_docs
-
-def setup():
-    user_docs.create_db_and_indexes()
-
-
-def test_bad_selector():
-    db = user_docs.mkdb()
-    bad_selectors = [
-        None,
-        True,
-        False,
-        1.0,
-        "foobarbaz",
-        {"foo":{"$not_an_op": 2}},
-        {"$gt":2},
-        [None, "bing"]
-    ]
-    for bs in bad_selectors:
-        try:
-            db.find(bs)
-        except Exception, e:
-            assert e.response.status_code == 400
-        else:
-            raise AssertionError("bad find")
-
-
-def test_bad_limit():
-    db = user_docs.mkdb()
-    bad_limits = [
-        None,
-        True,
-        False,
-        -1,
-        1.2,
-        "no limit!",
-        {"foo": "bar"},
-        [2]
-    ],
-    for bl in bad_limits:
-        try:
-            db.find({"int":{"$gt":2}}, limit=bl)
-        except Exception, e:
-            assert e.response.status_code == 400
-        else:
-            raise AssertionError("bad find")
-
-
-def test_bad_skip():
-    db = user_docs.mkdb()
-    bad_skips = [
-        None,
-        True,
-        False,
-        -3,
-        1.2,
-        "no limit!",
-        {"foo": "bar"},
-        [2]
-    ],
-    for bs in bad_skips:
-        try:
-            db.find({"int":{"$gt":2}}, skip=bs)
-        except Exception, e:
-            assert e.response.status_code == 400
-        else:
-            raise AssertionError("bad find")
-
-
-def test_bad_sort():
-    db = user_docs.mkdb()
-    bad_sorts = [
-        None,
-        True,
-        False,
-        1.2,
-        "no limit!",
-        {"foo": "bar"},
-        [2],
-        [{"foo":"asc", "bar": "asc"}],
-        [{"foo":"asc"}, {"bar":"desc"}],
-    ],
-    for bs in bad_sorts:
-        try:
-            db.find({"int":{"$gt":2}}, sort=bs)
-        except Exception, e:
-            assert e.response.status_code == 400
-        else:
-            raise AssertionError("bad find")
-
-
-def test_bad_fields():
-    db = user_docs.mkdb()
-    bad_fields = [
-        None,
-        True,
-        False,
-        1.2,
-        "no limit!",
-        {"foo": "bar"},
-        [2],
-        [[]],
-        ["foo", 2.0],
-    ],
-    for bf in bad_fields:
-        try:
-            db.find({"int":{"$gt":2}}, fields=bf)
-        except Exception, e:
-            assert e.response.status_code == 400
-        else:
-            raise AssertionError("bad find")
-
-
-def test_bad_r():
-    db = user_docs.mkdb()
-    bad_rs = [
-        None,
-        True,
-        False,
-        1.2,
-        "no limit!",
-        {"foo": "bar"},
-        [2],
-    ],
-    for br in bad_rs:
-        try:
-            db.find({"int":{"$gt":2}}, r=br)
-        except Exception, e:
-            assert e.response.status_code == 400
-        else:
-            raise AssertionError("bad find")
 
+import mango
+
+
+class BasicFindTests(mango.UserDocsTests):
+
+    def test_bad_selector(self):
+        bad_selectors = [
+            None,
+            True,
+            False,
+            1.0,
+            "foobarbaz",
+            {"foo":{"$not_an_op": 2}},
+            {"$gt":2},
+            [None, "bing"]
+        ]
+        for bs in bad_selectors:
+            try:
+                self.db.find(bs)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad find")
+
+    def test_bad_limit(self):
+        bad_limits = [
+            None,
+            True,
+            False,
+            -1,
+            1.2,
+            "no limit!",
+            {"foo": "bar"},
+            [2]
+        ],
+        for bl in bad_limits:
+            try:
+                self.db.find({"int":{"$gt":2}}, limit=bl)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad find")
+
+    def test_bad_skip(self):
+        bad_skips = [
+            None,
+            True,
+            False,
+            -3,
+            1.2,
+            "no limit!",
+            {"foo": "bar"},
+            [2]
+        ],
+        for bs in bad_skips:
+            try:
+                self.db.find({"int":{"$gt":2}}, skip=bs)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad find")
+
+    def test_bad_sort(self):
+        bad_sorts = [
+            None,
+            True,
+            False,
+            1.2,
+            "no limit!",
+            {"foo": "bar"},
+            [2],
+            [{"foo":"asc", "bar": "asc"}],
+            [{"foo":"asc"}, {"bar":"desc"}],
+        ],
+        for bs in bad_sorts:
+            try:
+                self.db.find({"int":{"$gt":2}}, sort=bs)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad find")
+
+    def test_bad_fields(self):
+        bad_fields = [
+            None,
+            True,
+            False,
+            1.2,
+            "no limit!",
+            {"foo": "bar"},
+            [2],
+            [[]],
+            ["foo", 2.0],
+        ],
+        for bf in bad_fields:
+            try:
+                self.db.find({"int":{"$gt":2}}, fields=bf)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad find")
+
+    def test_bad_r(self):
+        bad_rs = [
+            None,
+            True,
+            False,
+            1.2,
+            "no limit!",
+            {"foo": "bar"},
+            [2],
+        ],
+        for br in bad_rs:
+            try:
+                self.db.find({"int":{"$gt":2}}, r=br)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad find")
+
+    def test_bad_conflicts(self):
+        bad_conflicts = [
+            None,
+            1.2,
+            "no limit!",
+            {"foo": "bar"},
+            [2],
+        ],
+        for bc in bad_conflicts:
+            try:
+                self.db.find({"int":{"$gt":2}}, conflicts=bc)
+            except Exception, e:
+                assert e.response.status_code == 400
+            else:
+                raise AssertionError("bad find")
+
+    def test_simple_find(self):
+        docs = self.db.find({"age": {"$lt": 35}})
+        assert len(docs) == 3
+        assert docs[0]["user_id"] == 9
+        assert docs[1]["user_id"] == 1
+        assert docs[2]["user_id"] == 7
+
+    def test_multi_cond_and(self):
+        docs = self.db.find({"manager": True, "location.city": "Longbranch"})
+        assert len(docs) == 1
+        assert docs[0]["user_id"] == 7
+
+    def test_multi_cond_or(self):
+        docs = self.db.find({
+                "$and":[
+                    {"age":{"$gte": 75}},
+                    {"$or": [
+                        {"name.first": "Mathis"},
+                        {"name.first": "Whitley"}
+                    ]}
+                ]
+            })
+        assert len(docs) == 2
+        assert docs[0]["user_id"] == 11
+        assert docs[1]["user_id"] == 13
+
+    def test_multi_col_idx(self):
+        docs = self.db.find({
+            "location.state": {"$and": [
+                {"$gt": "Hawaii"},
+                {"$lt": "Maine"}
+            ]},
+            "location.city": {"$lt": "Longbranch"}
+        })
+        assert len(docs) == 1
+        assert docs[0]["user_id"] == 6
+
+    def test_missing_not_indexed(self):
+        docs = self.db.find({"favorites.3": "C"})
+        assert len(docs) == 1
+        assert docs[0]["user_id"] == 6
+
+        docs = self.db.find({"favorites.3": None})
+        assert len(docs) == 0
+
+        docs = self.db.find({"twitter": {"$gt": None}})
+        assert len(docs) == 4
+        assert docs[0]["user_id"] == 1
+        assert docs[1]["user_id"] == 4
+        assert docs[2]["user_id"] == 0
+        assert docs[3]["user_id"] == 13
+
+    def test_limit(self):
+        docs = self.db.find({"age": {"$gt": 0}})
+        assert len(docs) == 15
+        for l in [0, 1, 5, 14]:
+            docs = self.db.find({"age": {"$gt": 0}}, limit=l)
+            assert len(docs) == l
 
-def test_bad_conflicts():
-    db = user_docs.mkdb()
-    bad_conflicts = [
-        None,
-        1.2,
-        "no limit!",
-        {"foo": "bar"},
-        [2],
-    ],
-    for bc in bad_conflicts:
+    def test_skip(self):
+        docs = self.db.find({"age": {"$gt": 0}})
+        assert len(docs) == 15
+        for s in [0, 1, 5, 14]:
+            docs = self.db.find({"age": {"$gt": 0}}, skip=s)
+            assert len(docs) == (15 - s)
+
+    def test_sort(self):
+        docs1 = self.db.find({"age": {"$gt": 0}}, sort=[{"age":"asc"}])
+        docs2 = list(sorted(docs1, key=lambda d: d["age"]))
+        assert docs1 is not docs2 and docs1 == docs2
+
+        docs1 = self.db.find({"age": {"$gt": 0}}, sort=[{"age":"desc"}])
+        docs2 = list(reversed(sorted(docs1, key=lambda d: d["age"])))
+        assert docs1 is not docs2 and docs1 == docs2
+
+    def test_fields(self):
+        selector = {"age": {"$gt": 0}}
+        docs = self.db.find(selector, fields=["user_id", "location.address"])
+        for d in docs:
+            assert sorted(d.keys()) == ["location", "user_id"]
+            assert sorted(d["location"].keys()) == ["address"]
+
+    def test_r(self):
+        for r in [1, 2, 3]:
+            docs = self.db.find({"age": {"$gt": 0}}, r=r)
+            assert len(docs) == 15
+
+    def test_dot_key(self):
+        fields = ["title", "dot\\.key", "none.dot"]
+        docs = self.db.find({"type": "complex_key"}, fields = fields)
+        assert len(docs) == 4
+        assert docs[1].has_key("dot.key")
+        assert docs[1]["dot.key"] == "dot's value"
+        assert docs[1].has_key("none")
+        assert docs[1]["none"]["dot"] == "none dot's value"
+
+    def test_peso_key(self):
+        fields = ["title", "$key", "deep.$key"]
+        docs = self.db.find({"type": "complex_key"}, fields = fields)
+        assert len(docs) == 4
+        assert docs[2].has_key("$key")
+        assert docs[2]["$key"] == "peso"
+        assert docs[2].has_key("deep")
+        assert docs[2]["deep"]["$key"] == "deep peso"
+
+    def test_unicode_key(self):
+        docs = self.db.find({"type": "complex_key"}, fields = ["title", ""])
+        assert len(docs) == 4
+        # note:  == \uf8ff
+        assert docs[3].has_key(u'\uf8ff')
+        assert docs[3][u'\uf8ff'] == "apple"
+
+    def test_empty(self):
         try:
-            db.find({"int":{"$gt":2}}, conflicts=bc)
+            self.db.find({})
         except Exception, e:
             assert e.response.status_code == 400
         else:
             raise AssertionError("bad find")
 
-
-def test_simple_find():
-    db = user_docs.mkdb()
-    docs = db.find({"age": {"$lt": 35}})
-    assert len(docs) == 3
-    assert docs[0]["user_id"] == 9
-    assert docs[1]["user_id"] == 1
-    assert docs[2]["user_id"] == 7
-
-
-def test_multi_cond_and():
-    db = user_docs.mkdb()
-    docs = db.find({"manager": True, "location.city": "Longbranch"})
-    assert len(docs) == 1
-    assert docs[0]["user_id"] == 7
-
-
-def test_multi_cond_or():
-    db = user_docs.mkdb()
-    docs = db.find({
-            "$and":[
-                {"age":{"$gte": 75}},
-                {"$or": [
-                    {"name.first": "Mathis"},
-                    {"name.first": "Whitley"}
-                ]}
-            ]
-        })
-    assert len(docs) == 2
-    assert docs[0]["user_id"] == 11
-    assert docs[1]["user_id"] == 13
-
-
-def test_multi_col_idx():
-    db = user_docs.mkdb()
-    docs = db.find({
-        "location.state": {"$and": [
-            {"$gt": "Hawaii"},
-            {"$lt": "Maine"}
-        ]},
-        "location.city": {"$lt": "Longbranch"}
-    })
-    assert len(docs) == 1
-    assert docs[0]["user_id"] == 6
-
-
-def test_missing_not_indexed():
-    db = user_docs.mkdb()
-    docs = db.find({"favorites.3": "C"})
-    assert len(docs) == 2
-    assert docs[0]["user_id"] == 8
-    assert docs[1]["user_id"] == 6
-
-    docs = db.find({"favorites.3": None})
-    assert len(docs) == 0
-
-    docs = db.find({"twitter": {"$gt": None}})
-    assert len(docs) == 4
-    assert docs[0]["user_id"] == 1
-    assert docs[1]["user_id"] == 4
-    assert docs[2]["user_id"] == 0
-    assert docs[3]["user_id"] == 13
-
-def test_dot_key():
-    db = user_docs.mkdb()
-    fields = ["title", "dot\\.key", "none.dot"]
-    docs = db.find({"type": "complex_key"}, fields = fields)
-    assert len(docs) == 4
-    assert docs[1].has_key("dot.key")
-    assert docs[1]["dot.key"] == "dot's value"
-    assert docs[1].has_key("none")
-    assert docs[1]["none"]["dot"] == "none dot's value"
-
-def test_peso_key():
-    db = user_docs.mkdb()
-    fields = ["title", "$key", "deep.$key"]
-    docs = db.find({"type": "complex_key"}, fields = fields)
-    assert len(docs) == 4
-    assert docs[2].has_key("$key")
-    assert docs[2]["$key"] == "peso"
-    assert docs[2].has_key("deep")
-    assert docs[2]["deep"]["$key"] == "deep peso"
-
-def test_unicode_key():
-    db = user_docs.mkdb()
-    docs = db.find({"type": "complex_key"}, fields = ["title", ""])
-    assert len(docs) == 4
-    # note:  == \uf8ff
-    assert docs[3].has_key(u'\uf8ff')
-    assert docs[3][u'\uf8ff'] == "apple"
-
-def test_limit():
-    db = user_docs.mkdb()
-    docs = db.find({"age": {"$gt": 0}})
-    assert len(docs) == 15
-    for l in [0, 1, 5, 14]:
-        docs = db.find({"age": {"$gt": 0}}, limit=l)
-        assert len(docs) == l
-
-def test_skip():
-    db = user_docs.mkdb()
-    docs = db.find({"age": {"$gt": 0}})
-    assert len(docs) == 15
-    for s in [0, 1, 5, 14]:
-        docs = db.find({"age": {"$gt": 0}}, skip=s)
-        assert len(docs) == (15 - s)
-
-
-def test_sort():
-    db = user_docs.mkdb()
-
-    docs1 = db.find({"age": {"$gt": 0}}, sort=[{"age":"asc"}])
-    docs2 = list(sorted(docs1, key=lambda d: d["age"]))
-    assert docs1 is not docs2 and docs1 == docs2
-
-    docs1 = db.find({"age": {"$gt": 0}}, sort=[{"age":"desc"}])
-    docs2 = list(reversed(sorted(docs1, key=lambda d: d["age"])))
-    assert docs1 is not docs2 and docs1 == docs2
-
-
-def test_fields():
-    db = user_docs.mkdb()
-    docs = db.find({"age": {"$gt": 0}}, fields=["user_id", "location.address"])
-    for d in docs:
-        assert sorted(d.keys()) == ["location", "user_id"]
-        assert sorted(d["location"].keys()) == ["address"]
-
-
-def test_r():
-    db = user_docs.mkdb()
-    for r in [1, 2, 3]:
-        docs = db.find({"age": {"$gt": 0}}, r=r)
-        assert len(docs) == 15
+    def test_empty_subsel(self):
+        docs = self.db.find({
+                "_id": {"$gt": None},
+                "location": {}
+            })
+        assert len(docs) == 0
+
+    def test_empty_subsel_match(self):
+        self.db.save_docs([{"user_id": "eo", "empty_obj": {}}])
+        docs = self.db.find({
+                "_id": {"$gt": None},
+                "empty_obj": {}
+            })
+        assert len(docs) == 1
+        assert docs[0]["user_id"] == "eo"

http://git-wip-us.apache.org/repos/asf/couchdb-mango/blob/d1d13e6f/test/03-operator-test.py
----------------------------------------------------------------------
diff --git a/test/03-operator-test.py b/test/03-operator-test.py
index bd0500f..27418a6 100644
--- a/test/03-operator-test.py
+++ b/test/03-operator-test.py
@@ -10,83 +10,73 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-import user_docs
+import mango
 
 
-def setup():
-    user_docs.create_db_and_indexes()
+class OperatorTests(mango.UserDocsTests):
 
+    def test_all(self):
+        docs = self.db.find({
+                "manager": True,
+                "favorites": {"$all": ["Lisp", "Python"]}
+            })
+        print docs
+        assert len(docs) == 4
+        assert docs[0]["user_id"] == 2
+        assert docs[1]["user_id"] == 12
+        assert docs[2]["user_id"] == 9
+        assert docs[3]["user_id"] == 14
 
-def test_all():
-    db = user_docs.mkdb()
-    docs = db.find({
-            "manager": True,
-            "favorites": {"$all": ["Lisp", "Python"]}
-        })
-    assert len(docs) == 3
-    assert docs[0]["user_id"] == 2
-    assert docs[1]["user_id"] == 12
-    assert docs[2]["user_id"] == 9
-
-
-def test_all_non_array():
-    db = user_docs.mkdb()
-    docs = db.find({
-            "manager": True,
-            "location": {"$all": ["Ohai"]}
-        })
-    assert len(docs) == 0
-
+    def test_all_non_array(self):
+        docs = self.db.find({
+                "manager": True,
+                "location": {"$all": ["Ohai"]}
+            })
+        assert len(docs) == 0
 
-def test_elem_match():
-    db = user_docs.mkdb()
-    emdocs = [
-        {
-            "user_id": "a",
-            "bang": [{
-                "foo": 1,
-                "bar": 2
-            }]
-        },
-        {
-            "user_id": "b",
-            "bang": [{
-                "foo": 2,
+    def test_elem_match(self):
+        emdocs = [
+            {
+                "user_id": "a",
+                "bang": [{
+                    "foo": 1,
+                    "bar": 2
+                }]
+            },
+            {
+                "user_id": "b",
+                "bang": [{
+                    "foo": 2,
+                    "bam": True
+                }]
+            }
+        ]
+        self.db.save_docs(emdocs, w=3)
+        docs = self.db.find({
+            "_id": {"$gt": None},
+            "bang": {"$elemMatch": {
+                "foo": {"$gte": 1},
                 "bam": True
-            }]
-        }
-    ]
-    db.save_docs(emdocs)
-    docs = db.find({
-        "_id": {"$gt": None},
-        "bang": {"$elemMatch": {
-            "foo": {"$gte": 1},
-            "bam": True
-        }}
-    })
-    assert len(docs) == 1
-    assert docs[0]["user_id"] == "b"
-
-
-def test_regex():
-    db = user_docs.mkdb()
-
-    docs = db.find({
-            "age": {"$gt": 40},
-            "location.state": {"$regex": "(?i)new.*"}
+            }}
         })
-    assert len(docs) == 2
-    assert docs[0]["user_id"] == 2
-    assert docs[1]["user_id"] == 10
+        print docs
+        assert len(docs) == 1
+        assert docs[0]["user_id"] == "b"
 
+    def test_in_operator_array(self):
+        docs = self.db.find({
+                "manager": True,
+                "favorites": {"$in": ["Ruby", "Python"]}
+            })
+        assert len(docs) == 7
+        assert docs[0]["user_id"] == 2
+        assert docs[1]["user_id"] == 12
 
-def test_in_operator_array():
-    db = user_docs.mkdb()
-
-    docs = db.find({
-            "manager": True,
-            "favorites": {"$in": ["Ruby", "Python"]}
-        })
-    assert len(docs) == 7
-    assert docs[0]["user_id"] == 2
-    assert docs[1]["user_id"] == 12
+    def test_regex(self):
+        docs = self.db.find({
+                "age": {"$gt": 40},
+                "location.state": {"$regex": "(?i)new.*"}
+            })
+        assert len(docs) == 2
+        assert docs[0]["user_id"] == 2
+        assert docs[1]["user_id"] == 10

http://git-wip-us.apache.org/repos/asf/couchdb-mango/blob/d1d13e6f/test/04-empty-selectors-test.py
----------------------------------------------------------------------
diff --git a/test/04-empty-selectors-test.py b/test/04-empty-selectors-test.py
deleted file mode 100644
index 08bb03e..0000000
--- a/test/04-empty-selectors-test.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not
-# use this file except in compliance with the License. You may obtain a copy of
-# the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations under
-# the License.
-
-import user_docs
-
-
-def setup():
-    user_docs.create_db_and_indexes()
-
-
-def test_empty():
-    db = user_docs.mkdb()
-    try:
-        db.find({})
-    except Exception, e:
-        assert e.response.status_code == 400
-    else:
-        raise AssertionError("bad find")
-
-
-def test_empty_subsel():
-    db = user_docs.mkdb()
-    docs = db.find({
-            "_id": {"$gt": None},
-            "location": {}
-        })
-    assert len(docs) == 0
-
-
-def test_empty_subsel_match():
-    db = user_docs.mkdb()
-    db.save_docs([{"user_id": "eo", "empty_obj": {}}])
-    docs = db.find({
-            "_id": {"$gt": None},
-            "empty_obj": {}
-        })
-    assert len(docs) == 1
-    assert docs[0]["user_id"] == "eo"

http://git-wip-us.apache.org/repos/asf/couchdb-mango/blob/d1d13e6f/test/mango.py
----------------------------------------------------------------------
diff --git a/test/mango.py b/test/mango.py
index 3163cf5..c28f280 100644
--- a/test/mango.py
+++ b/test/mango.py
@@ -12,9 +12,17 @@
 
 import json
 import time
+import unittest
+import uuid
 
 import requests
 
+import user_docs
+
+
+def random_db_name():
+    return "mango_test_" + uuid.uuid4().hex
+
 
 class Database(object):
     def __init__(self, host, port, dbname, auth=None):
@@ -35,10 +43,10 @@ class Database(object):
             parts = [parts]
         return "/".join([self.url] + parts)
 
-    def create(self):
+    def create(self, q=1, n=3):
         r = self.sess.get(self.url)
         if r.status_code == 404:
-            r = self.sess.put(self.url)
+            r = self.sess.put(self.url, params={"q":q, "n": n})
             r.raise_for_status()
 
     def delete(self):
@@ -53,9 +61,9 @@ class Database(object):
     def save_doc(self, doc):
         self.save_docs([doc])
 
-    def save_docs(self, docs):
+    def save_docs(self, docs, **kwargs):
         body = json.dumps({"docs": docs})
-        r = self.sess.post(self.path("_bulk_docs"), data=body)
+        r = self.sess.post(self.path("_bulk_docs"), data=body, params=kwargs)
         r.raise_for_status()
         for doc, result in zip(docs, r.json()):
             doc["_id"] = result["id"]
@@ -124,3 +132,46 @@ class Database(object):
             return results[0]
         else:
             return None
+
+
+class DbPerClass(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(klass):
+        klass.db = Database("127.0.0.1", "5984", random_db_name())
+        klass.db.create(q=1, n=3)
+
+    def setUp(self):
+        self.db = self.__class__.db
+
+
+class UserDocsTests(DbPerClass):
+
+    @classmethod
+    def setUpClass(klass):
+        super(UserDocsTests, klass).setUpClass()
+        user_docs.setup(klass.db)
+
+
+class UserDocsTextTests(DbPerClass):
+
+    DEFAULT_FIELD = None
+    FIELDS = None
+
+    @classmethod
+    def setUpClass(klass):
+        super(UserDocsTextTests, klass).setUpClass()
+        user_docs.setup(
+                klass.db,
+                index_type="text",
+                default_field=klass.DEFAULT_FIELD,
+                fields=klass.FIELDS
+            )
+
+
+class FriendDocsTextTests(DbPerClass):
+
+    @classmethod
+    def setUpClass(klass):
+        super(FriendDocsTextTests, klass).setUpClass()
+        friend_docs.setup(klass.db, index_type="text")

http://git-wip-us.apache.org/repos/asf/couchdb-mango/blob/d1d13e6f/test/user_docs.py
----------------------------------------------------------------------
diff --git a/test/user_docs.py b/test/user_docs.py
index 1cccb58..465370a 100644
--- a/test/user_docs.py
+++ b/test/user_docs.py
@@ -9,8 +9,8 @@
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations under
 # the License.
-
-# -*- coding: latin-1 -*-
+#
+# -*- coding: utf-8 -*-
 """
 Generated with http://www.json-generator.com/
 
@@ -50,20 +50,20 @@ With this pattern:
 ]
 """
 
-import copy
-import time
-
-import mango
-
 
-def mkdb():
-    return mango.Database("127.0.0.1", "5984", "mango_test")
+import copy
 
 
-def create_db_and_indexes():
-    db = mkdb()
+def setup(db, index_type="view", **kwargs):
     db.recreate()
     db.save_docs(copy.deepcopy(DOCS))
+    if index_type == "view":
+        add_view_indexes(db, kwargs)
+    elif index_type == "text":
+        add_text_indexes(db, kwargs)
+
+
+def add_view_indexes(db, kwargs):
     indexes = [
         ["user_id"],
         ["name.last", "name.first"],
@@ -85,6 +85,10 @@ def create_db_and_indexes():
         assert db.create_index(idx) is True
 
 
+def add_text_indexes(db, kwargs):
+    db.create_text_index(**kwargs)
+
+
 DOCS = [
     {
         "_id": "71562648-6acb-42bc-a182-df6b1f005b09",
@@ -110,7 +114,8 @@ DOCS = [
             "Ruby",
             "C",
             "Python"
-        ]
+        ],
+        "test" : [{"a":1}, {"b":2}]
     },
     {
         "_id": "12a2800c-4fe2-45a8-8d78-c084f4e242a9",
@@ -136,8 +141,9 @@ DOCS = [
             "Ruby",
             "Python",
             "C",
-            "Python"
-        ]
+            {"Versions": {"Alpha": "Beta"}}
+        ],
+        "test" : [{"a":1, "b":2}]
     },
     {
         "_id": "48ca0455-8bd0-473f-9ae2-459e42e3edd1",
@@ -162,7 +168,8 @@ DOCS = [
             "Lisp",
             "Python",
             "Erlang"
-        ]
+        ],
+        "test_in": {"val1" : 1, "val2": "val2"}
     },
     {
         "_id": "0461444c-e60a-457d-a4bb-b8d811853f21",
@@ -183,7 +190,11 @@ DOCS = [
         "company": "Tasmania",
         "email": "madelynsoto@tasmania.com",
         "manager": True,
-        "favorites": [
+        "favorites": [[
+                "Lisp",
+                "Erlang",
+                "Python"
+            ],
             "Erlang",
             "C",
             "Erlang"
@@ -291,7 +302,9 @@ DOCS = [
             "Ruby",
             "Ruby",
             "Erlang"
-        ]
+        ],
+        "exists_field" : "should_exist1"
+
     },
     {
         "_id": "6c0afcf1-e57e-421d-a03d-0c0717ebf843",
@@ -312,12 +325,8 @@ DOCS = [
         "company": "Globoil",
         "email": "jamesmcdaniel@globoil.com",
         "manager": True,
-        "favorites": [
-            "Lisp",
-            "C",
-            "Ruby",
-            "C"
-        ]
+        "favorites": None,
+        "exists_field" : "should_exist2"
     },
     {
         "_id": "954272af-d5ed-4039-a5eb-8ed57e9def01",
@@ -342,7 +351,8 @@ DOCS = [
             "Lisp",
             "Erlang",
             "Python"
-        ]
+        ],
+        "exists_array" : ["should", "exist", "array1"]
     },
     {
         "_id": "e900001d-bc48-48a6-9b1a-ac9a1f5d1a03",
@@ -366,7 +376,8 @@ DOCS = [
         "favorites": [
             "Erlang",
             "Erlang"
-        ]
+        ],
+        "exists_array" : ["should", "exist", "array2"]
     },
     {
         "_id": "b06aadcf-cd0f-4ca6-9f7e-2c993e48d4c4",
@@ -393,7 +404,8 @@ DOCS = [
             "C",
             "C++",
             "C++"
-        ]
+        ],
+        "exists_object" : {"should": "object"}
     },
     {
         "_id": "5b61abc1-a3d3-4092-b9d7-ced90e675536",
@@ -418,7 +430,8 @@ DOCS = [
             "C",
             "Python",
             "Lisp"
-        ]
+        ],
+        "exists_object" : {"another": "object"}
     },
     {
         "_id": "b1e70402-8add-4068-af8f-b4f3d0feb049",
@@ -436,7 +449,7 @@ DOCS = [
                 "number": 8766
             }
         },
-        "company": "Fangold",
+        "company": None,
         "email": "whitleyharvey@fangold.com",
         "manager": False,
         "twitter": "@whitleyharvey",
@@ -444,11 +457,16 @@ DOCS = [
             "C",
             "Ruby",
             "Ruby"
-        ]
+        ],
+        "utf8-1[]:string" : "string",
+        "utf8-2[]:boolean[]" : True,
+        "utf8-3[]:number" : 9,
+        "utf8-3[]:null" : None
     },
     {
         "_id": "c78c529f-0b07-4947-90a6-d6b7ca81da62",
         "user_id": 14,
+        "«ταБЬℓσ»" : "utf-8",
         "name": {
             "first": "Faith",
             "last": "Hess"
@@ -466,7 +484,8 @@ DOCS = [
         "email": "faithhess@pharmex.com",
         "manager": True,
         "favorites": [
-            "Lisp",
+            "Erlang",
+            "Python",
             "Lisp"
         ]
     },


Mime
View raw message