class DocJoinExpressionTest(SimpleTestCase):
def setUp(self):
self.spec = {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
self.expression = ExpressionFactory.from_spec(self.spec)
self.nested_expression = ExpressionFactory.from_spec({
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
})
self.database = FakeCouchDb()
RelatedDocExpressionSpec.db_lookup = lambda _, type: self.database
def test_simple_lookup(self):
related_id = 'related-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'related_property': 'foo'
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc
}
self.assertEqual('foo', self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_related_doc_not_found(self):
self.assertEqual(None, self.expression({'parent_id': 'some-missing-id'}))
def test_cross_domain_lookups(self):
related_id = 'cross-domain-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'wrong-domain',
'related_property': 'foo'
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc
}
self.assertEqual(None, self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup(self):
related_id = 'nested-id-1'
related_id_2 = 'nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'test-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual('bar', self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup_cross_domains(self):
related_id = 'cross-nested-id-1'
related_id_2 = 'cross-nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'wrong-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual(None, self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_caching(self):
self.test_simple_lookup()
my_doc = self.database.get('my-id')
self.database.mock_docs.clear()
self.assertEqual({}, self.database.mock_docs)
self.assertEqual('foo', self.expression(my_doc, EvaluationContext(my_doc, 0)))
same_expression = ExpressionFactory.from_spec(self.spec)
self.assertEqual('foo', same_expression(my_doc, EvaluationContext(my_doc, 0)))
class RelatedDocExpressionTest(SimpleTestCase):
def setUp(self):
# we have to set the fake database before any other calls
self.orig_db = CommCareCase.get_db()
self.database = FakeCouchDb()
CommCareCase.set_db(self.database)
self.spec = {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
self.expression = ExpressionFactory.from_spec(self.spec)
self.nested_expression = ExpressionFactory.from_spec({
"type":
"related_doc",
"related_doc_type":
"CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
})
def tearDown(self):
CommCareCase.set_db(self.orig_db)
def test_simple_lookup(self):
related_id = 'related-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {'domain': 'test-domain', 'related_property': 'foo'}
self.database.mock_docs = {'my-id': my_doc, related_id: related_doc}
self.assertEqual('foo',
self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_related_doc_not_found(self):
doc = {'parent_id': 'some-missing-id', 'domain': 'whatever'}
self.assertEqual(None, self.expression(doc, EvaluationContext(doc, 0)))
def test_cross_domain_lookups(self):
related_id = 'cross-domain-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {'domain': 'wrong-domain', 'related_property': 'foo'}
self.database.mock_docs = {'my-id': my_doc, related_id: related_doc}
self.assertEqual(None,
self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup(self):
related_id = 'nested-id-1'
related_id_2 = 'nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'test-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual(
'bar', self.nested_expression(my_doc, EvaluationContext(my_doc,
0)))
def test_nested_lookup_cross_domains(self):
related_id = 'cross-nested-id-1'
related_id_2 = 'cross-nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'wrong-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual(
None, self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_fail_on_bad_doc_type(self):
spec = {
"type": "related_doc",
"related_doc_type": "BadDocument",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(spec)
def test_caching(self):
self.test_simple_lookup()
my_doc = self.database.get('my-id')
context = EvaluationContext(my_doc, 0)
self.assertEqual('foo', self.expression(my_doc, context))
my_doc = self.database.get('my-id')
self.database.mock_docs.clear()
self.assertEqual('foo', self.expression(my_doc, context))
class DocJoinExpressionTest(SimpleTestCase):
def setUp(self):
self.spec = {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
self.expression = ExpressionFactory.from_spec(self.spec)
self.nested_expression = ExpressionFactory.from_spec({
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
})
self.database = FakeCouchDb()
RelatedDocExpressionSpec.db_lookup = lambda _, type: self.database
def test_simple_lookup(self):
related_id = 'related-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'related_property': 'foo'
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc
}
self.assertEqual('foo', self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_related_doc_not_found(self):
self.assertEqual(None, self.expression({'parent_id': 'some-missing-id'}))
def test_cross_domain_lookups(self):
related_id = 'cross-domain-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'wrong-domain',
'related_property': 'foo'
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc
}
self.assertEqual(None, self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup(self):
related_id = 'nested-id-1'
related_id_2 = 'nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'test-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual('bar', self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup_cross_domains(self):
related_id = 'cross-nested-id-1'
related_id_2 = 'cross-nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'wrong-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual(None, self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_caching(self):
self.test_simple_lookup()
my_doc = self.database.get('my-id')
self.database.mock_docs.clear()
self.assertEqual({}, self.database.mock_docs)
self.assertEqual('foo', self.expression(my_doc, EvaluationContext(my_doc, 0)))
same_expression = ExpressionFactory.from_spec(self.spec)
self.assertEqual('foo', same_expression(my_doc, EvaluationContext(my_doc, 0)))
class DocJoinExpressionTest(SimpleTestCase):
def setUp(self):
# we have to set the fake database before any other calls
self.orig_db = CommCareCase.get_db()
self.database = FakeCouchDb()
CommCareCase.set_db(self.database)
self.spec = {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
self.expression = ExpressionFactory.from_spec(self.spec)
self.nested_expression = ExpressionFactory.from_spec({
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
})
def tearDown(self):
CommCareCase.set_db(self.orig_db)
def test_simple_lookup(self):
related_id = 'related-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'related_property': 'foo'
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc
}
self.assertEqual('foo', self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_related_doc_not_found(self):
self.assertEqual(None, self.expression({'parent_id': 'some-missing-id'}))
def test_cross_domain_lookups(self):
related_id = 'cross-domain-id'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'wrong-domain',
'related_property': 'foo'
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc
}
self.assertEqual(None, self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup(self):
related_id = 'nested-id-1'
related_id_2 = 'nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'test-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual('bar', self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup_cross_domains(self):
related_id = 'cross-nested-id-1'
related_id_2 = 'cross-nested-id-2'
my_doc = {
'domain': 'test-domain',
'parent_id': related_id,
}
related_doc = {
'domain': 'test-domain',
'parent_id': related_id_2,
'related_property': 'foo',
}
related_doc_2 = {
'domain': 'wrong-domain',
'related_property': 'bar',
}
self.database.mock_docs = {
'my-id': my_doc,
related_id: related_doc,
related_id_2: related_doc_2
}
self.assertEqual(None, self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_fail_on_bad_doc_type(self):
spec = {
"type": "related_doc",
"related_doc_type": "BadDocument",
"doc_id_expression": {
"type": "property_name",
"property_name": "parent_id"
},
"value_expression": {
"type": "property_name",
"property_name": "related_property"
}
}
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(spec)
def test_caching(self):
self.test_simple_lookup()
my_doc = self.database.get('my-id')
self.database.mock_docs.clear()
self.assertEqual({}, self.database.mock_docs)
self.assertEqual('foo', self.expression(my_doc, EvaluationContext(my_doc, 0)))
same_expression = ExpressionFactory.from_spec(self.spec)
self.assertEqual('foo', same_expression(my_doc, EvaluationContext(my_doc, 0)))
class DocJoinExpressionTest(SimpleTestCase):
def setUp(self):
self.spec = {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {"type": "property_name", "property_name": "parent_id"},
"value_expression": {"type": "property_name", "property_name": "related_property"},
}
self.expression = ExpressionFactory.from_spec(self.spec)
self.nested_expression = ExpressionFactory.from_spec(
{
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {"type": "property_name", "property_name": "parent_id"},
"value_expression": {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {"type": "property_name", "property_name": "parent_id"},
"value_expression": {"type": "property_name", "property_name": "related_property"},
},
}
)
self.database = FakeCouchDb()
RelatedDocExpressionSpec.db_lookup = lambda _, type: self.database
def test_simple_lookup(self):
related_id = "related-id"
my_doc = {"domain": "test-domain", "parent_id": related_id}
related_doc = {"domain": "test-domain", "related_property": "foo"}
self.database.mock_docs = {"my-id": my_doc, related_id: related_doc}
self.assertEqual("foo", self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_related_doc_not_found(self):
self.assertEqual(None, self.expression({"parent_id": "some-missing-id"}))
def test_cross_domain_lookups(self):
related_id = "cross-domain-id"
my_doc = {"domain": "test-domain", "parent_id": related_id}
related_doc = {"domain": "wrong-domain", "related_property": "foo"}
self.database.mock_docs = {"my-id": my_doc, related_id: related_doc}
self.assertEqual(None, self.expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup(self):
related_id = "nested-id-1"
related_id_2 = "nested-id-2"
my_doc = {"domain": "test-domain", "parent_id": related_id}
related_doc = {"domain": "test-domain", "parent_id": related_id_2, "related_property": "foo"}
related_doc_2 = {"domain": "test-domain", "related_property": "bar"}
self.database.mock_docs = {"my-id": my_doc, related_id: related_doc, related_id_2: related_doc_2}
self.assertEqual("bar", self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_nested_lookup_cross_domains(self):
related_id = "cross-nested-id-1"
related_id_2 = "cross-nested-id-2"
my_doc = {"domain": "test-domain", "parent_id": related_id}
related_doc = {"domain": "test-domain", "parent_id": related_id_2, "related_property": "foo"}
related_doc_2 = {"domain": "wrong-domain", "related_property": "bar"}
self.database.mock_docs = {"my-id": my_doc, related_id: related_doc, related_id_2: related_doc_2}
self.assertEqual(None, self.nested_expression(my_doc, EvaluationContext(my_doc, 0)))
def test_caching(self):
self.test_simple_lookup()
my_doc = self.database.get("my-id")
self.database.mock_docs.clear()
self.assertEqual({}, self.database.mock_docs)
self.assertEqual("foo", self.expression(my_doc, EvaluationContext(my_doc, 0)))
same_expression = ExpressionFactory.from_spec(self.spec)
self.assertEqual("foo", same_expression(my_doc, EvaluationContext(my_doc, 0)))
