datastore.objects/datastore/objects/test/test_objects_manager.py at 5301d7a595308261f7b3dcc31ac4c5da6fef62f6 · datastore/datastore.objects · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
import unittest
import datastore

from .. import manager
from ..manager import Manager
from ..model import Key
from ..model import Model
from datastore.core import Query
from ..object_datastore import ObjectDatastore


class TestManager(unittest.TestCase):

  def test_exists(self):
    self.assertTrue(hasattr(manager, 'Manager'))


  def test_is_class(self):
    self.assertTrue(isinstance(Manager, type))


  def test_model_is_attribute(self):
    self.assertTrue(hasattr(Manager, 'model'))

  def test_construct_with_model_option(self):
    class Foo(Model): pass

    ds = datastore.DictDatastore()
    mgr = Manager(ds, model=Foo)
    self.assertTrue(mgr.model is Foo)


  def test_get_constructs_model(self):
    ds = datastore.DictDatastore()
    mgr = Manager(ds)
    key = Key('/model:bar')
    data = {'key': str(key), 'foo': 'bar'}
    ds.put(key, data)
    instance = mgr.get('bar')
    self.assertTrue(isinstance(instance, Manager.model))
    self.assertEqual(instance.data, data)


  def test_get_constructs_model_with_model(self):
    class Foo(Model): pass

    ds = datastore.DictDatastore()
    mgr = Manager(ds, model=Foo)
    key = Key('/foo:bar')
    data = {'key': str(key), 'foo': 'bar'}
    ds.put(key, data)
    instance = mgr.get('bar')
    self.assertTrue(isinstance(instance, Manager.model))
    self.assertEqual(instance.data, data)


  def test_put_stores_model_data_copy(self):
    ds = datastore.DictDatastore()
    mgr = Manager(ds)
    key = Key('/model:bar')
    instance = Model.withData({'key': str(key), 'foo': 'bar'})
    mgr.put(instance)
    data = ds.get(key)
    self.assertFalse(instance.data is data)
    self.assertEqual(instance.data, data)

  def test_put_stores_model_data_copy_with_model(self):
    class Foo(Model): pass

    ds = datastore.DictDatastore()
    mgr = Manager(ds, model=Foo)
    key = Key('/foo:bar')
    instance = Foo.withData({'key': str(key), 'foo': 'bar'})
    mgr.put(instance)
    data = ds.get(key)
    self.assertFalse(instance.data is data)
    self.assertEqual(instance.data, data)

  def test_delete_and_contains_work(self):
    ds = datastore.DictDatastore()
    mgr = Manager(ds)
    key = Key('/model:bar')
    data = {'key': str(key), 'foo': 'bar'}
    instance = Model.withData(data)

    # put in mgr, delete from mgr
    mgr.put(instance)
    self.assertTrue(mgr.contains(key))
    self.assertTrue(ds.contains(key))

    mgr.delete(key)
    self.assertFalse(mgr.contains(key))
    self.assertFalse(ds.contains(key))

    # put in mgr, delete from ds
    mgr.put(instance)
    self.assertTrue(mgr.contains(key))
    self.assertTrue(ds.contains(key))

    ds.delete(key)
    self.assertFalse(mgr.contains(key))
    self.assertFalse(ds.contains(key))

    # put in ds, delete from mgr
    ds.put(key, data)
    self.assertTrue(mgr.contains(key))
    self.assertTrue(ds.contains(key))

    mgr.delete(key)
    self.assertFalse(mgr.contains(key))
    self.assertFalse(ds.contains(key))

    # put in ds, delete from mgr
    ds.put(key, data)
    self.assertTrue(mgr.contains(key))
    self.assertTrue(ds.contains(key))

    ds.delete(key)
    self.assertFalse(mgr.contains(key))
    self.assertFalse(ds.contains(key))

  def test_query_returns_results(self):
    class Foo(Model):
        def __eq__(self, other):
            return self.data == other.data

    ds = datastore.DictDatastore()
    mgr = Manager(ds, model=Foo)

    instance1 = Foo.withData({'key': '/foo:bar1', 'foo': 'bar1'})
    instance2 = Foo.withData({'key': '/foo:bar2', 'foo': 'bar2'})

    mgr.put(instance1)
    mgr.put(instance2)

    # Query all on the manager
    results = list(mgr.query())
    self.assertEqual(len(results), 2)

    # Query with filter
    results = list(mgr.query(Query().filter('foo','=','bar1')))
    self.assertEqual(len(results), 1)
    self.assertEqual(results[0], instance1)

    results = list(mgr.query(Query().filter('foo','=','bar2')))
    self.assertEqual(len(results), 1)
    self.assertEqual(results[0], instance2)

  def test_remove_all_items(self):
    class Foo(Model): pass

    ds = datastore.DictDatastore()
    mgr = Manager(ds, model=Foo)
    key1 = Key('/foo:bar1')
    key2 = Key('/foo:bar2')
    instance1 = Foo.withData({'key': str(key1), 'foo': 'bar1'})
    instance2 = Foo.withData({'key': str(key2), 'foo': 'bar2'})

    # put in mgr
    mgr.put(instance1)
    mgr.put(instance2)
    self.assertTrue(mgr.contains(key1))
    self.assertTrue(ds.contains(key1))
    self.assertTrue(mgr.contains(key2))
    self.assertTrue(ds.contains(key2))

    # delete all
    mgr.remove_all_items()
    self.assertFalse(mgr.contains(key1))
    self.assertFalse(ds.contains(key1))
    self.assertFalse(mgr.contains(key2))
    self.assertFalse(ds.contains(key2))


if __name__ == '__main__':
  unittest.main()