def test_deleted_case_migration(self):
parent_case_id = uuid.uuid4().hex
child_case_id = uuid.uuid4().hex
parent_case = create_and_save_a_case(self.domain_name, case_id=parent_case_id, case_name='test parent')
child_case = create_and_save_a_case(self.domain_name, case_id=child_case_id, case_name='test child')
set_parent_case(self.domain_name, child_case, parent_case)
form_ids = self._get_form_ids()
self.assertEqual(3, len(form_ids))
FormAccessors(self.domain.name).soft_delete_forms(
form_ids, datetime.utcnow(), 'test-deletion-with-cases'
)
CaseAccessors(self.domain.name).soft_delete_cases(
[parent_case_id, child_case_id], datetime.utcnow(), 'test-deletion-with-cases'
)
self.assertEqual(2, len(get_doc_ids_in_domain_by_type(
self.domain_name, "CommCareCase-Deleted", XFormInstance.get_db())
))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(2, len(CaseAccessorSQL.get_deleted_case_ids_in_domain(self.domain_name)))
self._compare_diffs([])
parent_transactions = CaseAccessorSQL.get_transactions(parent_case_id)
self.assertEqual(2, len(parent_transactions))
self.assertTrue(parent_transactions[0].is_case_create)
self.assertTrue(parent_transactions[1].is_form_transaction)
child_transactions = CaseAccessorSQL.get_transactions(child_case_id)
self.assertEqual(2, len(child_transactions))
self.assertTrue(child_transactions[0].is_case_create)
self.assertTrue(child_transactions[1].is_case_index)
def test_migrate_ledgers(self):
case_id = uuid.uuid4().hex
create_and_save_a_case(self.domain_name,
case_id=case_id,
case_name="Simon's sweet shop")
self._set_balance(100,
case_id,
self.liquorice._id,
type="set_the_liquorice_balance")
self._set_balance(50, case_id, self.sherbert._id)
self._set_balance(175, case_id, self.jelly_babies._id)
expected_stock_state = {
'stock': {
self.liquorice._id: 100,
self.sherbert._id: 50,
self.jelly_babies._id: 175
}
}
self._validate_ledger_data(self._get_ledger_state(case_id),
expected_stock_state)
self._do_migration_and_assert_flags(self.domain_name)
self._validate_ledger_data(self._get_ledger_state(case_id),
expected_stock_state)
transactions = LedgerAccessorSQL.get_ledger_transactions_for_case(
case_id)
self.assertEqual(3, len(transactions))
self._compare_diffs([])
def test_report_case_reindexer(self):
cases_included = set()
for i in range(3):
case = create_and_save_a_case(DOMAIN,
uuid.uuid4().hex,
'case_name-{}'.format(i))
cases_included.add(case.case_id)
def _create_case_and_sync_to_es(self):
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
with self.process_case_changes:
create_and_save_a_case(self.domain, case_id, case_name)
self.elasticsearch.indices.refresh(CASE_INDEX_INFO.index)
return case_id, case_name
def test_global_registry_ucr(self):
"""Globally accessible UCR get's data from all participating domains regardless
of grants.
"""
config = get_sample_registry_data_source(
domain=self.registry_owner_domain,
registry_slug=self.registry_1.slug,
globally_accessible=True)
config.save()
self.addCleanup(config.delete)
adapter = get_indicator_adapter(config)
adapter.build_table()
self.addCleanup(adapter.drop_table)
pillow = get_kafka_ucr_registry_pillow(ucr_configs=[config],
processor_chunk_size=100)
expected = {}
with process_pillow_changes(pillow):
for domain in self.participants:
case = create_and_save_a_case(domain,
uuid.uuid4().hex,
f"name-{domain}",
case_type="ticket",
case_properties={
"category": "bug",
"tags": "easy-win public",
"is_starred": "yes",
"estimate": "2.3",
"priority": "4",
})
expected[case.case_id] = domain
def test_deleted_case_migration(self):
parent_case_id = uuid.uuid4().hex
child_case_id = uuid.uuid4().hex
parent_case = create_and_save_a_case(self.domain_name, case_id=parent_case_id, case_name='test parent')
child_case = create_and_save_a_case(self.domain_name, case_id=child_case_id, case_name='test child')
set_parent_case(self.domain_name, child_case, parent_case)
form_ids = self._get_form_ids()
self.assertEqual(3, len(form_ids))
FormAccessors(self.domain.name).soft_delete_forms(
form_ids, datetime.utcnow(), 'test-deletion-with-cases'
)
CaseAccessors(self.domain.name).soft_delete_cases(
[parent_case_id, child_case_id], datetime.utcnow(), 'test-deletion-with-cases'
)
self.assertEqual(2, len(get_doc_ids_in_domain_by_type(
self.domain_name, "CommCareCase-Deleted", XFormInstance.get_db())
))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(2, len(CaseAccessorSQL.get_deleted_case_ids_in_domain(self.domain_name)))
self._compare_diffs([])
parent_transactions = CaseAccessorSQL.get_transactions(parent_case_id)
self.assertEqual(2, len(parent_transactions))
self.assertTrue(parent_transactions[0].is_case_create)
self.assertTrue(parent_transactions[1].is_form_transaction)
child_transactions = CaseAccessorSQL.get_transactions(child_case_id)
self.assertEqual(2, len(child_transactions))
self.assertTrue(child_transactions[0].is_case_create)
self.assertTrue(child_transactions[1].is_case_index)
def _create_case_and_sync_to_es(self, domain):
case_id = uuid.uuid4().hex
case_name = "case-name-{}".format(uuid.uuid4().hex)
with process_kafka_changes("ReportCaseToElasticsearchPillow"):
with process_couch_changes("DefaultChangeFeedPillow"):
create_and_save_a_case(domain, case_id, case_name)
self.elasticsearch.indices.refresh(REPORT_CASE_INDEX_INFO.index)
return case_id, case_name
def test_case_lookups(self):
case_id = uuid.uuid4().hex
create_and_save_a_case(domain=self.domain,
case_id=case_id,
case_name='related doc test case')
expression = self._get_expression('CommCareCase')
doc = self._get_doc(case_id)
self.assertEqual(case_id, expression(doc, EvaluationContext(doc, 0)))
def _create_case_and_sync_to_es(self):
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
with process_kafka_changes('CaseToElasticsearchPillow'):
with process_couch_changes('DefaultChangeFeedPillow'):
create_and_save_a_case(self.domain, case_id, case_name)
self.elasticsearch.indices.refresh(CASE_INDEX_INFO.index)
return case_id, case_name
def test_basic_case_migration(self):
create_and_save_a_case(self.domain_name,
case_id=uuid.uuid4().hex,
case_name='test case')
self.assertEqual(1, len(self._get_case_ids()))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(1, len(self._get_case_ids()))
self._compare_diffs([])
def _create_case_and_sync_to_es(self, domain):
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
with process_pillow_changes('case-pillow'):
with process_pillow_changes('DefaultChangeFeedPillow'):
create_and_save_a_case(domain, case_id, case_name)
self.elasticsearch.indices.refresh(REPORT_CASE_INDEX_INFO.index)
return case_id, case_name
def _create_case_and_sync_to_es(self, domain):
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
with process_pillow_changes('case-pillow'):
with process_pillow_changes('DefaultChangeFeedPillow'):
create_and_save_a_case(domain, case_id, case_name)
self.elasticsearch.indices.refresh(REPORT_CASE_INDEX_INFO.index)
return case_id, case_name
def _create_case_and_sync_to_es(self):
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
with process_kafka_changes('CaseToElasticsearchPillow'):
with process_couch_changes('DefaultChangeFeedPillow'):
create_and_save_a_case(self.domain, case_id, case_name)
self.elasticsearch.indices.refresh(CASE_INDEX_INFO.index)
return case_id, case_name
def _create_case_and_sync_to_es(self):
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
with process_pillow_changes('case-pillow', {'skip_ucr': True}):
with process_pillow_changes('DefaultChangeFeedPillow'):
create_and_save_a_case(self.domain, case_id, case_name)
self.elasticsearch.indices.refresh(CASE_INDEX_INFO.alias)
return case_id, case_name
def _make_case(self, domain, case_properties):
# make a case
case_properties = case_properties or {}
case_id = case_properties.pop('_id')
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
owner_id = case_properties.pop('owner_id', None)
case = create_and_save_a_case(domain, case_id, case_name, case_properties, owner_id=owner_id)
return case
def _make_case(self, domain=None, case_properties=None):
# make a case
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
if domain is None:
domain = self.domain
case = create_and_save_a_case(domain, case_id, case_name, case_properties)
return case
def test_basic_case_migration(self):
create_and_save_a_case(self.domain,
case_id=uuid.uuid4().hex,
case_name='test case')
self.assertEqual(
1, len(CaseAccessors(domain=self.domain).get_case_ids_in_domain()))
self._do_migration_and_assert_flags(self.domain)
self.assertEqual(
1, len(CaseAccessors(domain=self.domain).get_case_ids_in_domain()))
def test_case_with_indices_migration(self):
parent_case_id = uuid.uuid4().hex
child_case_id = uuid.uuid4().hex
parent_case = create_and_save_a_case(self.domain_name, case_id=parent_case_id, case_name='test parent')
child_case = create_and_save_a_case(self.domain_name, case_id=child_case_id, case_name='test child')
set_parent_case(self.domain_name, child_case, parent_case)
self.assertEqual(2, len(self._get_case_ids()))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(2, len(self._get_case_ids()))
self._compare_diffs([])
indices = CaseAccessorSQL.get_indices(self.domain_name, child_case_id)
self.assertEqual(1, len(indices))
self.assertEqual(parent_case_id, indices[0].referenced_id)
def test_case_with_indices_migration(self):
parent_case_id = uuid.uuid4().hex
child_case_id = uuid.uuid4().hex
parent_case = create_and_save_a_case(self.domain_name, case_id=parent_case_id, case_name='test parent')
child_case = create_and_save_a_case(self.domain_name, case_id=child_case_id, case_name='test child')
set_parent_case(self.domain_name, child_case, parent_case)
self.assertEqual(2, len(self._get_case_ids()))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(2, len(self._get_case_ids()))
self._compare_diffs([])
indices = CaseAccessorSQL.get_indices(self.domain_name, child_case_id)
self.assertEqual(1, len(indices))
self.assertEqual(parent_case_id, indices[0].referenced_id)
def test_case_soft_deletion(self):
# make a case
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
case = create_and_save_a_case(self.domain, case_id, case_name)
# send to elasticsearch
self._sync_couch_cases_to_es()
# verify there
results = CaseES().run()
self.assertEqual(1, results.total)
seq_before_deletion = self.pillow.get_change_feed().get_latest_change_id()
# soft delete the case
case.soft_delete()
# sync to elasticsearch
self._sync_couch_cases_to_es(since=seq_before_deletion)
# ensure not there anymore
results = CaseES().run()
self.assertEqual(0, results.total)
# cleanup
case.delete()
class ReportCaseReindexerTest(TestCase):
def setUp(self):
super(ReportCaseReindexerTest, self).setUp()
FormProcessorTestUtils.delete_all_xforms()
FormProcessorTestUtils.delete_all_cases()
with trap_extra_setup(ConnectionError):
self.elasticsearch = get_es_new()
ensure_index_deleted(REPORT_CASE_INDEX_INFO.index)
def tearDown(self):
FormProcessorTestUtils.delete_all_xforms()
FormProcessorTestUtils.delete_all_cases()
ensure_index_deleted(REPORT_CASE_INDEX_INFO.index)
super(ReportCaseReindexerTest, self).tearDown()
@run_with_all_backends
def test_report_case_reindexer(self):
cases_included = set()
for i in range(3):
case = create_and_save_a_case(DOMAIN,
uuid.uuid4().hex,
'case_name-{}'.format(i))
cases_included.add(case.case_id)
# excluded case
create_and_save_a_case('unsupported', uuid.uuid4().hex, 'unsupported')
reindex_and_clean('report-case')
# verify there
results = CaseES("report_cases").run()
self.assertEqual(3, results.total, results.hits)
ids_in_es = {doc['_id'] for doc in results.hits}
self.assertEqual(cases_included, ids_in_es)
def test_report_case_reindexer(self):
cases_included = set()
for i in range(3):
case = create_and_save_a_case(DOMAIN, uuid.uuid4().hex, 'case_name-{}'.format(i))
cases_included.add(case.case_id)
# excluded case
create_and_save_a_case('unsupported', uuid.uuid4().hex, 'unsupported')
reindex_and_clean('report-case')
# verify there
results = CaseES("report_cases").run()
self.assertEqual(3, results.total, results.hits)
ids_in_es = {doc['_id'] for doc in results.hits}
self.assertEqual(cases_included, ids_in_es)
def test_case_pillow_sql(self):
consumer = get_test_kafka_consumer(topics.CASE_SQL)
# have to get the seq id before the change is processed
kafka_seq = consumer.offsets()['fetch'][(topics.CASE_SQL, 0)]
# make a case
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
case = create_and_save_a_case(self.domain, case_id, case_name)
# confirm change made it to kafka
message = consumer.next()
change_meta = change_meta_from_kafka_message(message.value)
self.assertEqual(case.case_id, change_meta.document_id)
self.assertEqual(self.domain, change_meta.domain)
# send to elasticsearch
sql_pillow = get_sql_case_to_elasticsearch_pillow()
sql_pillow.process_changes(since=kafka_seq, forever=False)
self.elasticsearch.indices.refresh(self.pillow.es_index)
# confirm change made it to elasticserach
results = CaseES().run()
self.assertEqual(1, results.total)
case_doc = results.hits[0]
self.assertEqual(self.domain, case_doc['domain'])
self.assertEqual(case_id, case_doc['_id'])
self.assertEqual(case_name, case_doc['name'])
def setUpClass(cls):
super().setUpClass()
cls.es = get_es_new()
cls.es_interface = ElasticsearchInterface(cls.es)
cls.index = TEST_INDEX_INFO.index
cls.es_alias = TEST_INDEX_INFO.alias
with trap_extra_setup(ConnectionError):
ensure_index_deleted(cls.index)
initialize_index_and_mapping(cls.es, TEST_INDEX_INFO)
cls.domain = uuid.uuid4().hex
cls.case_ids = [uuid.uuid4().hex for i in range(4)]
with drop_connected_signals(sql_case_post_save):
for case_id in cls.case_ids:
create_and_save_a_case(cls.domain, case_id, case_id)
def test_form_touches_case_without_updates(self):
case_id = uuid.uuid4().hex
create_and_save_a_case(self.domain_name,
case_id=case_id,
case_name='touched by a form',
user_id='user1')
form_id = uuid.uuid4().hex
xml = """<?xml version='1.0' ?>
<data uiVersion="1" version="1" name="" xmlns="http://openrosa.org/formdesigner/123">
<name>fgg</name>
<date>2011-06-07</date>
<n0:case case_id="{case_id}" user_id="user1" date_modified="{date}"
xmlns:n0="http://commcarehq.org/case/transaction/v2">
</n0:case>
<n0:case case_id="case-123" user_id="user-abc" date_modified="{date}"
xmlns:n0="http://commcarehq.org/case/transaction/v2">
<n0:create>
<n0:case_type_id>cc_bc_demo</n0:case_type_id>
<n0:case_name>fgg</n0:case_name>
</n0:create>
</n0:case>
<n1:meta xmlns:n1="http://openrosa.org/jr/xforms">
<n1:deviceID>354957031935664</n1:deviceID>
<n1:timeStart>{date}</n1:timeStart>
<n1:timeEnd>{date}</n1:timeEnd>
<n1:username>bcdemo</n1:username>
<n1:userID>user1</n1:userID>
<n1:instanceID>{form_id}</n1:instanceID>
</n1:meta>
</data>""".format(date=datetime.utcnow(),
form_id=form_id,
case_id=case_id)
result = submit_form_locally(xml, self.domain_name)
case = [case for case in result.cases if case.case_id == case_id][0]
case.xform_ids.remove(
form_id
) # legacy bug that didn't include these form IDs in the case
case.save()
self.assertEqual(2, len(self._get_form_ids()))
self.assertEqual(2, len(self._get_case_ids()))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(2, len(self._get_form_ids()))
self.assertEqual(2, len(self._get_case_ids()))
self._compare_diffs([])
def test_report_case_reindexer(self):
cases_included = set()
for i in range(3):
case = create_and_save_a_case(DOMAIN, uuid.uuid4().hex, "case_name-{}".format(i))
cases_included.add(case.case_id)
# excluded case
create_and_save_a_case("unsupported", uuid.uuid4().hex, "unsupported")
reindexer = get_report_case_reindexer()
reindexer.reindex()
# verify there
results = CaseES("report_cases").run()
self.assertEqual(3, results.total, results.hits)
ids_in_es = {doc["_id"] for doc in results.hits}
self.assertEqual(cases_included, ids_in_es)
def test_case_is_published(self):
with process_kafka_changes(self.case_pillow):
with process_couch_changes('DefaultChangeFeedPillow'):
case = create_and_save_a_case(self.domain, case_id=uuid.uuid4().hex, case_name='test case')
self.assertEqual(1, len(self.processor.changes_seen))
change_meta = self.processor.changes_seen[0].metadata
self.assertEqual(case.case_id, change_meta.document_id)
self.assertEqual(self.domain, change_meta.domain)
def make_episode_case(self):
return create_and_save_a_case(
self.domain,
uuid.uuid4().hex,
case_name='prescription',
case_properties={'test_confirming_diagnosis': "Old Nan's wisdom",
'weight': "15 stone"},
case_type='episode',
)
def make_voucher(self):
return create_and_save_a_case(
self.domain,
uuid.uuid4().hex,
case_name='prescription',
case_properties={'amount_initial': '105',
'state': 'approved'},
case_type='voucher',
)
def test_registry_ucr(self):
expected = {}
with process_pillow_changes(self.pillow):
for domain in self.participants:
case = create_and_save_a_case(domain,
uuid.uuid4().hex,
f"name-{domain}",
case_type="ticket",
case_properties={
"category": "bug",
"tags": "easy-win public",
"is_starred": "yes",
"estimate": "2.3",
"priority": "4",
})
if domain != self.participator_3:
# 3 does not grant either of the others access
expected[case.case_id] = domain
def test_form_touches_case_without_updates(self):
case_id = uuid.uuid4().hex
create_and_save_a_case(self.domain_name, case_id=case_id, case_name='touched by a form', user_id='user1')
form_id = uuid.uuid4().hex
xml = """<?xml version='1.0' ?>
<data uiVersion="1" version="1" name="" xmlns="http://openrosa.org/formdesigner/123">
<name>fgg</name>
<date>2011-06-07</date>
<n0:case case_id="{case_id}" user_id="user1" date_modified="{date}"
xmlns:n0="http://commcarehq.org/case/transaction/v2">
</n0:case>
<n0:case case_id="case-123" user_id="user-abc" date_modified="{date}"
xmlns:n0="http://commcarehq.org/case/transaction/v2">
<n0:create>
<n0:case_type_id>cc_bc_demo</n0:case_type_id>
<n0:case_name>fgg</n0:case_name>
</n0:create>
</n0:case>
<n1:meta xmlns:n1="http://openrosa.org/jr/xforms">
<n1:deviceID>354957031935664</n1:deviceID>
<n1:timeStart>{date}</n1:timeStart>
<n1:timeEnd>{date}</n1:timeEnd>
<n1:username>bcdemo</n1:username>
<n1:userID>user1</n1:userID>
<n1:instanceID>{form_id}</n1:instanceID>
</n1:meta>
</data>""".format(
date=datetime.utcnow(),
form_id=form_id,
case_id=case_id
)
_, _, cases = submit_form_locally(xml, self.domain_name)
case = [case for case in cases if case.case_id == case_id][0]
case.xform_ids.remove(form_id) # legacy bug that didn't include these form IDs in the case
case.save()
self.assertEqual(2, len(self._get_form_ids()))
self.assertEqual(2, len(self._get_case_ids()))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(2, len(self._get_form_ids()))
self.assertEqual(2, len(self._get_case_ids()))
self._compare_diffs([])
def test_case_deletions(self):
case = create_and_save_a_case(self.domain, case_id=uuid.uuid4().hex, case_name='test case')
with process_pillow_changes(self.case_pillow):
with process_pillow_changes('DefaultChangeFeedPillow'):
case.soft_delete()
self.assertEqual(1, len(self.processor.changes_seen))
change_meta = self.processor.changes_seen[0].metadata
self.assertEqual(case.case_id, change_meta.document_id)
self.assertTrue(change_meta.is_deletion)
def test_migrate_ledgers(self):
case_id = uuid.uuid4().hex
create_and_save_a_case(self.domain_name, case_id=case_id, case_name="Simon's sweet shop")
self._set_balance(100, case_id, self.liquorice._id)
self._set_balance(50, case_id, self.sherbert._id)
self._set_balance(175, case_id, self.jelly_babies._id)
expected_stock_state = {'stock': {
self.liquorice._id: 100,
self.sherbert._id: 50,
self.jelly_babies._id: 175
}}
self._validate_ledger_data(self._get_ledger_state(case_id), expected_stock_state)
self._do_migration_and_assert_flags(self.domain_name)
self._validate_ledger_data(self._get_ledger_state(case_id), expected_stock_state)
transactions = LedgerAccessorSQL.get_ledger_transactions_for_case(case_id)
self.assertEqual(3, len(transactions))
self._compare_diffs([])
def test_user_can_acces_case(self):
self.case = create_and_save_a_case(
self.domain,
uuid.uuid4().hex,
'test-case',
owner_id=self.locations['Cambridge'].location_id)
self.assertTrue(
user_can_access_case(self.domain, self.cambridge_worker,
self.case))
self.assertFalse(
user_can_access_case(self.domain, self.suffolk_user, self.case))
def test_case_pillow_couch(self):
# make a case
case_id = uuid.uuid4().hex
case_name = 'case-name-{}'.format(uuid.uuid4().hex)
case = create_and_save_a_case(self.domain, case_id, case_name)
# send to elasticsearch
self._sync_couch_cases_to_es()
# verify there
results = CaseES().run()
self.assertEqual(1, results.total)
case_doc = results.hits[0]
self.assertEqual(self.domain, case_doc['domain'])
self.assertEqual(case_id, case_doc['_id'])
self.assertEqual(case_name, case_doc['name'])
# cleanup
case.delete()
def _create_and_save_a_case():
case_name = 'reindexer-test-case-{}'.format(uuid.uuid4().hex)
case_id = uuid.uuid4().hex
return create_and_save_a_case(DOMAIN, case_id, case_name)
def test_basic_case_migration(self):
create_and_save_a_case(self.domain_name, case_id=uuid.uuid4().hex, case_name='test case')
self.assertEqual(1, len(self._get_case_ids()))
self._do_migration_and_assert_flags(self.domain_name)
self.assertEqual(1, len(self._get_case_ids()))
self._compare_diffs([])
def test_case_is_published(self):
with self.process_case_changes:
case = create_and_save_a_case(self.domain,
case_id=uuid.uuid4().hex,
case_name='test case')
def test_case_lookups(self):
case_id = uuid.uuid4().hex
create_and_save_a_case(domain=self.domain, case_id=case_id, case_name='related doc test case')
expression = self._get_expression('CommCareCase')
doc = self._get_doc(case_id)
self.assertEqual(case_id, expression(doc, EvaluationContext(doc, 0)))
def test_case_is_published(self):
with process_pillow_changes(self.case_pillow):
with process_pillow_changes('DefaultChangeFeedPillow'):
case = create_and_save_a_case(self.domain,
case_id=uuid.uuid4().hex,
case_name='test case')
def test_case_is_published(self):
with process_pillow_changes(self.case_pillow):
with process_pillow_changes('DefaultChangeFeedPillow'):
case = create_and_save_a_case(self.domain,
case_id=uuid.uuid4().hex,
case_name='test case')
self.assertEqual(1, len(self.processor.changes_seen))
change_meta = self.processor.changes_seen[0].metadata
self.assertEqual(case.case_id, change_meta.document_id)
self.assertEqual(self.domain, change_meta.domain)
def test_case_deletions(self):
case = create_and_save_a_case(self.domain,
case_id=uuid.uuid4().hex,
case_name='test case')
with process_pillow_changes(self.case_pillow):
with process_pillow_changes('DefaultChangeFeedPillow'):
case.soft_delete()
self.assertEqual(1, len(self.processor.changes_seen))
change_meta = self.processor.changes_seen[0].metadata
self.assertEqual(case.case_id, change_meta.document_id)
self.assertTrue(change_meta.is_deletion)
@use_sql_backend
class KafkaPublishingTestSQL(KafkaPublishingTest):
pass
def _create_and_save_a_case():
case_name = 'reindexer-test-case-{}'.format(uuid.uuid4().hex)
case_id = uuid.uuid4().hex
return create_and_save_a_case(DOMAIN, case_id, case_name)
def test_case_is_published(self):
kafka_consumer = get_test_kafka_consumer(topics.CASE_SQL)
case = create_and_save_a_case(self.domain, case_id=uuid.uuid4().hex, case_name='test case')
change_meta = change_meta_from_kafka_message(kafka_consumer.next().value)
self.assertEqual(case.case_id, change_meta.document_id)
self.assertEqual(self.domain, change_meta.domain)
