def test(sql_form_ids, couch_form_ids, expect=None, n_changes=0):
if expect is None:
expect = sql_form_ids
tx_updates = []
sql_case = Config(
transactions=[
Config(id=i,
form_id=x.strip(),
server_date=to_date(x),
details={}) for i, x in enumerate(sql_form_ids)
],
track_update=lambda tx: tx_updates.append(tx),
)
couch_json = {
"actions": [{
"xform_id": x.strip()
} for x in couch_form_ids]
}
print("couch case", couch_json)
print_tx("before", sql_case.transactions)
txx, server_dates = mod.update_transaction_order(sql_case, couch_json)
print_tx("after", txx)
eq("".join([tx.form_id if tx.form_id else " " for tx in txx]), expect)
eq(len(server_dates), n_changes, server_dates)
eq(len(tx_updates), n_changes, tx_updates)
def test(sql_form_ids, couch_form_ids, expect):
sql_case = Config(
transactions=[Config(form_id=x, details={}) for x in sql_form_ids])
couch_json = {"actions": [{"xform_id": x} for x in couch_form_ids]}
print(sql_case)
print(couch_json)
eq(mod.should_sort_sql_transactions(sql_case, couch_json), expect)
def test_iter_cases_with_unprocessed_forms():
with init_db() as db:
db.update_cases([
Config(id="a", total_forms=2, processed_forms=1),
Config(id="b", total_forms=2, processed_forms=1),
Config(id="c", total_forms=4, processed_forms=1),
])
eq(list(db.iter_cases_with_unprocessed_forms()), ["a", "b", "c"])
def test_get_forms_count():
with init_db() as db:
db.update_cases([
Config(id="a", total_forms=2, processed_forms=1),
Config(id="b", total_forms=2, processed_forms=3),
])
eq(db.get_forms_count("a"), 2)
eq(db.get_forms_count("b"), 2)
eq(db.get_forms_count("c"), 0)
def test_add_processed_forms():
with init_db() as db:
db.update_cases([
Config(id="a", total_forms=2, processed_forms=1),
Config(id="b", total_forms=2, processed_forms=1),
Config(id="c", total_forms=4, processed_forms=1),
])
result = db.add_processed_forms({"b": 1, "c": 2, "d": 2})
eq(sorted(result), [
("b", 2, 2),
("c", 4, 3),
("d", None, None),
])
def add_ledger(self, case_id, **values):
ref = UniqueLedgerReference(case_id, "stock", case_id)
self.sql_ledgers[case_id] = Config(
ledger_reference=ref,
values=values,
to_json=lambda: dict(values, ledger_reference=ref.as_id()),
)
couch_values = dict(values)
stock = Config(
ledger_reference=ref,
values=couch_values,
to_json=lambda: dict(couch_values, ledger_reference=ref.as_id()),
)
self.couch_ledgers[case_id] = stock
return stock
def test_process_change_with_deleted_document(self):
self.obj.put_attachment("content", "name")
change = Config(id=self.obj._id, deleted=True)
self.processor.process_change(None, change)
msg = "FakeCouchDocument attachment: 'name'"
with assert_raises(ResourceNotFound, msg=msg):
self.obj.fetch_attachment("name")
def test_clone_casediff_data_from():
diffs = [make_diff(i) for i in range(3)]
try:
with init_db("main", memory=False) as main:
uid = main.unique_id
with init_db("cddb", memory=False) as cddb:
main.add_problem_form("problem")
main.save_form_diffs(
{
"doc_type": "XFormInstance",
"_id": "form"
}, {})
cddb.add_processed_forms({"case": 1})
cddb.update_cases([
Config(id="case", total_forms=1, processed_forms=1),
Config(id="a", total_forms=2, processed_forms=1),
Config(id="b", total_forms=2, processed_forms=1),
Config(id="c", total_forms=2, processed_forms=1),
])
cddb.add_missing_docs("CommCareCase", ["missing"])
cddb.replace_case_diffs([
("CommCareCase", "a", [diffs[0]]),
("CommCareCase-Deleted", "b", [diffs[1]]),
("stock state", "c/ledger", [diffs[2]]),
])
cddb.set_counter("CommCareCase", 4) # case, a, c, missing
cddb.set_counter("CommCareCase-Deleted", 1) # b
main.add_no_action_case_form("no-action")
main.set_resume_state("FormState", ["form"])
cddb.set_resume_state("CaseState", ["case"])
cddb.close()
main.clone_casediff_data_from(cddb.db_filepath)
main.close()
with StateDB.open("test", main.db_filepath) as db:
eq(list(db.iter_cases_with_unprocessed_forms()),
[("a", 2), ("b", 2), ("c", 2)])
eq(list(db.iter_problem_forms()), ["problem"])
eq(db.get_no_action_case_forms(), {"no-action"})
with db.pop_resume_state("CaseState", "nope") as value:
eq(value, ["case"])
with db.pop_resume_state("FormState", "fail") as value:
eq(value, ["form"])
eq(db.unique_id, uid)
finally:
delete_db("main")
delete_db("cddb")
def test_process_response_with_audit_doc_and_couch_user(self):
self.request.audit_doc = audit_doc = FakeAuditDoc(user=None)
self.request.couch_user = Config(username="******")
with configured_middleware() as ware:
ware(self.request)
self.assertEqual(audit_doc.status_code, 200)
self.assertEqual(audit_doc.user, "couch_user")
self.assertEqual(audit_doc.save_count, 1)
def intercept_save(cls):
def save(self):
real_save(self)
config.obj = self
config = Config()
real_save = cls.save
with patch.object(cls, "save", save):
yield config
def test_get_domain():
def test(cfg):
request = make_request(cfg.path)
if "request_domain" in cfg:
request.domain = cfg.request_domain
eq(mod.get_domain(request), cfg.expect)
cfg = Config(expect="block")
yield test, cfg(path="/path", expect=None)
yield test, cfg(path="/a/block/path")
yield test, cfg(path="/path", request_domain="block")
yield test, cfg(path="/a/block/path", request_domain="xx")
def add_case(self, case_id, **props):
assert case_id not in self.sql_cases, self.sql_cases[case_id]
assert case_id not in self.couch_cases, self.couch_cases[case_id]
props.setdefault("doc_type", "CommCareCase")
self.sql_cases[case_id] = Config(
case_id=case_id,
props=props,
to_json=lambda: dict(props, case_id=case_id),
is_deleted=False,
)
self.couch_cases[case_id] = couch_case = dict(props, case_id=case_id)
return couch_case
def add_ledger(self, case_id, **values):
ref = UniqueLedgerReference(case_id, "stock", case_id)
self.sql_ledgers[case_id] = Config(
ledger_reference=ref,
values=values,
last_modified_form_id="form",
to_json=lambda: dict(values, ledger_reference=ref.as_id()),
)
couch_values = dict(values)
stock = Config(
ledger_reference=ref,
values=couch_values,
last_modified_form_id="form",
to_json=lambda: dict(couch_values, ledger_reference=ref.as_id()),
)
self.couch_ledgers[case_id] = stock
tx = Config(
report=Config(form_id="form", type="transfer"),
ledger_reference=ref,
)
tx_helper = Config(ledger_reference=ref)
self.stock_transactions[ref] = [tx]
self.form_transactions["form"] = [("transfer", tx_helper)]
return stock
def test_update_cases():
with init_db() as db:
result = db.update_cases([
Config(id="a", total_forms=2, processed_forms=1),
Config(id="b", total_forms=2, processed_forms=1),
Config(id="c", total_forms=2, processed_forms=1),
])
eq(sorted(result), [
("a", 2, 1),
("b", 2, 1),
("c", 2, 1),
])
result = db.update_cases([
Config(id="b", total_forms=1, processed_forms=3),
Config(id="c", total_forms=3, processed_forms=1),
Config(id="d", total_forms=2, processed_forms=1),
])
eq(sorted(result), [
("b", 2, 4),
("c", 3, 2),
("d", 2, 1),
])
def make_request(path="/path", session_key="abc", params=None, **headers):
headers.setdefault("HTTP_ACCEPT", "html")
headers.setdefault("HTTP_USER_AGENT", "Mozilla")
request = RequestFactory().get(path, params or {"key": "value"}, **headers)
request.session = Config(session_key=session_key)
return request
def get_response(request):
ware.process_view(request, view, ARGS, KWARGS)
return Config(status_code=200)
self.save_count += 1
else:
self.save_count = 1
class AuditSaveErrorDoc(FakeAuditDoc):
def save(self):
super().save()
raise Exception("cannot save")
ARGS = () # positional view args are not audited, therefore are empty
KWARGS = {"non": "empty", "and": "audited", "view": "kwargs"}
EXPECTED_AUDIT = FakeAuditDoc(user="******", view_kwargs=KWARGS)
Settings = Config(
AUDIT_MODULES=default_settings.AUDIT_MODULES,
AUDIT_VIEWS=default_settings.AUDIT_VIEWS,
)
def default_get_response(request):
return Config(status_code=200)
@contextmanager
def configured_middleware(settings=Settings,
get_response=default_get_response):
with patch.object(mod.NavigationEventAudit, "audit_view", fake_audit), \
patch.object(mod, "settings", settings):
yield mod.AuditMiddleware(get_response)
def make_couch_retry_function(n_errors, error=None):
if error is None:
couch_url = mod._get_couch_base_urls()[0] + "/some/path"
error = mod.RequestException(request=Config(url=couch_url))
return make_retry_function(mod.retry_on_couch_error, n_errors, error)
def setUp(self):
self.request = Config(user="******")
def setUp(self):
self.request = RequestFactory().get("/path", {"key": "value"})
self.request.session = Config(session_key="abc")
def test_SubParser():
class is_enabled:
def __call__(self, editor):
return False
def __repr__(self):
return "is_enabled()"
sub = SubArgs("val", Int("num"), abc="xyz")
su2 = SubArgs("str", Choice(('yes', True), ('no', False)), abc="mno")
su3 = SubArgs("stx", String("args"), abc="pqr")
su4 = SubArgs("hid", String("not"), is_enabled=is_enabled())
field = SubParser("var", sub, su2, su3, su4)
eq_(str(field), 'var')
eq_(
repr(field), "SubParser('var', SubArgs('val', Int('num'), abc='xyz'), "
"SubArgs('str', Choice(('yes', True), ('no', False)), abc='mno'), "
"SubArgs('stx', String('args'), abc='pqr'), "
"SubArgs('hid', String('not'), is_enabled=is_enabled()))")
field = await_coroutine(field.with_context(Config(text_view=object)))
sub = field.args[1]
su2 = field.args[2]
test = make_completions_checker(field)
yield test, "", ["str", "stx", "val"]
yield test, "v", ["val"]
yield test, "v ", []
yield test, "val", ["val"]
yield test, "val ", []
yield test, "val v", []
yield test, "st", ["str", "stx"]
yield test, "str ", ["yes", "no"], 4
yield test, "str y", ["yes"], 4
test = make_placeholder_checker(field)
yield test, "", 0, ("", "var ...")
yield test, "v", 0, ("val", "num")
yield test, "v ", 0, ("val", "num")
yield test, "val", 0, ("val", "num")
yield test, "val ", 0, ("val", "num")
yield test, "val 1", 0, ("val 1", "")
yield test, "val x", 0, ("val", "")
yield test, "s", 0, ("", "...")
yield test, "s ", 0, ("", None)
yield test, "st", 0, ("", "...")
yield test, "str", 0, ("str", "yes")
yield test, "str ", 0, ("str", "yes")
yield test, "str y", 0, ("str yes", "")
yield test, "str yes", 0, ("str yes", "")
yield test, "str n", 0, ("str no", "")
yield test, "str x", 0, ("str", "")
yield test, "str x ", 0, ("str", "")
test = make_consume_checker(field)
yield test, '', 0, (None, 1)
yield test, 'x', 0, ParseError("'x' does not match any of: str, stx, val",
field, 0, 1)
yield test, 'v 1', 0, ((sub, Options(num=1)), 4)
yield test, 'val 1', 0, ((sub, Options(num=1)), 6)
yield test, 'val 1 2', 0, ((sub, Options(num=1)), 6)
yield test, 'val x 2', 0, ArgumentError(
"invalid arguments: val x 2",
Options(num=Arg(None, 'x', 0, Options())), [
ParseError("invalid literal for int() with base 10: 'x'",
Int("num"), 4, 5)
], 4)
test = make_arg_string_checker(field)
yield test, (sub, Options(num=1)), "val 1"
yield test, (su2, Options(yes=True)), "str "
yield test, (su2, Options(yes=False)), "str no"
def hard_rebuild_case(self, domain, case_id, *args, **kw):
return Config(to_json=lambda: self.couch_cases[case_id])
def default_get_response(request):
return Config(status_code=200)
def test_process_change_with_existing_document(self):
self.obj.put_attachment("content", "name")
change = Config(id=self.obj._id, deleted=False)
self.processor.process_change(None, change)
self.assertEqual(self.obj.fetch_attachment("name"), "content")