def setUpClass(cls):
super(MissingReportNotificationTestCase, cls).setUpClass()
cls.backend, cls.sms_backend_mapping = setup_default_sms_test_backend()
cls.domain = prepare_domain(cls.TEST_DOMAIN)
cls.program = Program(domain=cls.TEST_DOMAIN, name='Test Program')
cls.program.save()
cls.program2 = Program(domain=cls.TEST_DOMAIN, name='Test Program2')
cls.program2.save()
def setUpClass(cls):
super(UrgentNonReportingNotificationTestCase, cls).setUpClass()
delete_all_users()
cls.backend, cls.sms_backend_mapping = setup_default_sms_test_backend()
cls.domain = prepare_domain(cls.TEST_DOMAIN)
cls.program = Program(domain=cls.TEST_DOMAIN, name='Test Program')
cls.program.save()
def test_product_type_filter(self):
"""
Notifications will not be sent if the stockout is a product type does
not interest the user.
"""
self.user.get_domain_membership(self.TEST_DOMAIN).program_id = self.program.get_id
self.user.save()
program = Program(domain=self.TEST_DOMAIN, name='Test Program 2')
program.save()
other_user = bootstrap_web_user(
username='******', domain=self.TEST_DOMAIN, phone_number='+44445', location=self.region,
password='******', email='*****@*****.**', user_data={}
)
assign_products_to_location(self.facility, [self.product])
assign_products_to_location(self.other_facility, [self.product])
assign_products_to_location(self.last_facility, [self.product])
generated = list(UrgentNonReporting(self.TEST_DOMAIN).get_notifications())
self.assertEqual(len(generated), 2)
self.assertEqual({generated[0].user.get_id, generated[1].user.get_id},
{self.user.get_id, other_user.get_id})
def test_program_fixture_cache(self):
user = self.user
Program(domain=user.domain, name="test1", code="t1").save()
program_list = list(Program.by_domain(user.domain))
program_xml = self.generate_program_xml(program_list, user)
fixture = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(program_xml, fixture[0])
program = program_list[0]
program.name = 'new_name'
super(Program, program).save() # save but skip clearing the cache
fixture_cached = call_fixture_generator(program_fixture_generator,
user)
self.assertXmlEqual(program_xml, fixture_cached[0])
program.save()
program_xml_new = self.generate_program_xml(program_list, user)
fixture_regen = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(program_xml_new, fixture_regen[0])
self.assertXMLNotEqual(program_xml_new, program_xml)
def test_product_type_filter(self):
"""
Notifications will not be sent if the stockout is a product type does
not interest the user.
"""
self.user.get_domain_membership(self.TEST_DOMAIN).program_id = self.program.get_id
self.user.save()
program = Program(domain=self.TEST_DOMAIN, name='Test Program 2')
program.save()
bootstrap_web_user(
username='******', domain=self.TEST_DOMAIN, phone_number='+44445', location=self.district,
password='******', email='*****@*****.**', user_data={}, program_id=program.get_id
)
assign_products_to_location(self.facility, [self.product])
assign_products_to_location(self.other_facility, [self.product])
assign_products_to_location(self.last_facility, [self.product])
create_stock_report(self.facility, {'tp': 0})
create_stock_report(self.other_facility, {'tp': 0})
create_stock_report(self.last_facility, {'tp': 0})
generated = list(UrgentStockoutAlert(self.TEST_DOMAIN).get_notifications())
self.assertEqual(len(generated), 1)
self.assertEqual(generated[0].user.get_id, self.user.get_id)
def create_test_products(domain):
program = Program(domain=domain, name='HIV/AIDS', code='hiv')
program.save()
abacavir = Product(
domain=domain,
name="Abacavir 300mg",
code_="abc",
program_id=program.get_id,
)
abacavir.save()
ali = Product(
domain=domain,
name="AL 20mg/120mg 1X6",
code_="ali",
program_id=program.get_id,
)
ali.save()
al = Product(domain=domain, name="AL 20mg/120mg 4x6", code_="alk")
al.save()
ad = Product(domain=domain, name="A-L Dispersible", code_="ad")
ad.save()
al = Product(domain=domain, name="A-L Suspension", code_="al")
al.save()
def test_program_fixture(self):
user = self.user
Program(
domain=user.domain,
name="test1",
code="t1"
).save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture[0])
)
# test restore with different user
user2 = create_restore_user(self.domain, username='******')
self.addCleanup(user2._couch_user.delete)
program_xml = self.generate_program_xml(program_list, user2)
fixture = call_fixture_generator(program_fixture_generator, user2)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture[0])
)
def make_program(domain, name, code, default=False):
p = Program()
p.domain = domain
p.name = name
p.code = code.lower()
p.default = default
p.save()
return p
def test_program_fixture(self):
user = create_restore_user(self.domain.name)
Program(domain=user.domain, name="test1", code="t1").save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture = program_fixture_generator(user, V1)
self.assertXmlEqual(program_xml, ElementTree.tostring(fixture[0]))
def test_program_fixture(self):
user = self.user
Program(domain=user.domain, name="test1", code="t1").save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(program_xml, ElementTree.tostring(fixture[0]))
def test_program_fixture(self):
user = bootstrap_user(self, phone_number="1234567890")
Program(domain=user.domain, name="test1", code="t1").save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture = program_fixture_generator(user, V1)
self.assertXmlEqual(program_xml, ElementTree.tostring(fixture[0]))
def test_selective_program_sync(self):
user = self.user
Program(domain=user.domain, name="test1", code="t1").save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture_original = call_fixture_generator(program_fixture_generator,
user)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(program_xml,
ElementTree.tostring(fixture_original[0]))
first_sync = sorted(SyncLog.view("phone/sync_logs_by_user",
include_docs=True,
reduce=False).all(),
key=lambda x: x.date)[-1]
# make sure the time stamp on this first sync is
# not on the same second that the programs were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no programs synced
fixture_pre_change = call_fixture_generator(program_fixture_generator,
user,
last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual([], fixture_pre_change,
"Fixture was not empty on second sync")
second_sync = sorted(SyncLog.view("phone/sync_logs_by_user",
include_docs=True,
reduce=False).all(),
key=lambda x: x.date)[-1]
self.assertTrue(first_sync._id != second_sync._id)
# save should make the program more recently updated than the
# last sync
for program in program_list:
program.save()
# now that we've updated a program, we should get
# program data in sync again
fixture_post_change = call_fixture_generator(program_fixture_generator,
user,
last_sync=second_sync)
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(program_xml,
ElementTree.tostring(fixture_post_change[0]))
def test_set_program(self):
program_id = uuid.uuid4().hex
program = Program(_id=program_id, name="Program Name")
self._test_change_messages(UserChangeMessage.program_change, [program],
{
"program": {
"set_program": {
"id": program_id,
"name": "Program Name"
}
}
}, f"Program: Program Name[{program_id}]")
def sync_openlmis_program(domain, lmis_program):
program = get_program(domain, lmis_program)
if program is None:
program = Program(domain=domain)
program.name = lmis_program.name
program.code = lmis_program.code.lower()
program._doc_type_attr = "Program"
program.save()
if lmis_program.products:
for lmis_product in lmis_program.products:
sync_openlmis_product(domain, program, lmis_product)
return program
def ews_product_extension(couch_product, product):
if not product.program.code:
return couch_product
program = Program.get_by_code(couch_product.domain, product.program.code)
if not program:
program = Program(domain=couch_product.domain)
program.name = product.program.name
program.code = product.program.code.lower()
program._doc_type_attr = "Program"
program.save()
if couch_product.program_id != program._id:
couch_product.program_id = program._id
couch_product.save()
return couch_product
def product_sync(self, ilsgateway_product):
from custom.ilsgateway import PRODUCTS_CODES_PROGRAMS_MAPPING
product = super(ILSGatewayAPI, self).product_sync(ilsgateway_product)
programs = list(Program.by_domain(self.domain))
for program, products in PRODUCTS_CODES_PROGRAMS_MAPPING.iteritems():
if product.code in products:
existing_program = filter(lambda p: p.name == program,
programs)
if not existing_program:
new_program = Program(domain=self.domain)
new_program.name = program
new_program.save()
product.program_id = new_program.get_id
product.save()
else:
product.program_id = existing_program[0].get_id
product.save()
return product
def program(self):
return Program(domain=self.domain)
