From 863da17c6fc1f6feb7ebc51842da246659f9d084 Mon Sep 17 00:00:00 2001 From: David Rousselie Date: Thu, 29 Mar 2007 18:00:47 +0200 Subject: [PATCH] Move set_register handlers to AccountManager darcs-hash:20070329160047-86b55-476be92b2db0b0b144a27d44111478b880adfa85.gz --- run_tests.py | 2 +- src/jcl/jabber/component.py | 286 ++++++++++++++++++----------- src/jcl/model/account.py | 2 +- tests/jcl/jabber/test_component.py | 80 ++++---- tests/jcl/model/account.py | 9 +- tests/jcl/model/test_account.py | 6 +- 6 files changed, 230 insertions(+), 155 deletions(-) diff --git a/run_tests.py b/run_tests.py index abffeee..b8b548a 100644 --- a/run_tests.py +++ b/run_tests.py @@ -58,7 +58,7 @@ if __name__ == '__main__': jcl_suite = unittest.TestSuite() # jcl_suite.addTest(FeederComponent_TestCase('test_handle_tick')) -# jcl_suite.addTest(JCLComponent_TestCase('test_handle_get_register_new_complex')) +# jcl_suite.addTest(JCLComponent_TestCase('test_handle_set_register_update_complex')) # jcl_suite.addTest(PresenceAccount_TestCase('test_possibles_actions')) # jcl_suite = unittest.TestSuite((component_suite)) # jcl_suite = unittest.TestSuite((presence_account_suite)) diff --git a/src/jcl/jabber/component.py b/src/jcl/jabber/component.py index 94105f2..320a7ac 100644 --- a/src/jcl/jabber/component.py +++ b/src/jcl/jabber/component.py @@ -244,12 +244,19 @@ class JCLComponent(Component, object): self.__logger.debug("Signal %i received, shutting down..." % (signum,)) self.running = False + def send_stanzas(self, stanzas): + """Send given stanza list""" + self.__logger.debug("Sending responses") + for stanza in stanzas: + self.stream.send(stanza) + def apply_behavior(self, info_query, \ account_handler, \ account_type_handler, \ root_handler, \ send_result = False): - bare_from_jid = unicode(info_query.get_from().bare()) + """Apply given handler depending on info_query receiver""" + bare_from_jid = info_query.get_from().bare() to_jid = info_query.get_to() name = to_jid.node account_type = to_jid.resource @@ -264,9 +271,7 @@ class JCLComponent(Component, object): self.__logger.debug("Applying behavior on account type " + account_type) result = account_type_handler(name, bare_from_jid, account_type, lang_class) if send_result: - self.__logger.debug("Sending responses") - for stanza in result: - self.stream.send(stanza) + self.send_stanzas(result) return result def disco_get_info(self, node, info_query): @@ -325,31 +330,6 @@ class JCLComponent(Component, object): lang_class), \ send_result = True) - def remove_all_accounts(self, user_jid): - """Unsubscribe all accounts associated to 'user_jid' then delete - those accounts from the DataBase""" - self.db_connect() - for _account in self.account_classes[0].select(\ - self.account_classes[0].q.user_jid == user_jid): - self.__logger.debug("Deleting " + _account.name \ - + " for " + user_jid) - presence = Presence(from_jid = self.get_jid(_account), \ - to_jid = user_jid, \ - stanza_type = "unsubscribe") - self.stream.send(presence) - presence = Presence(from_jid = self.get_jid(_account), \ - to_jid = user_jid, \ - stanza_type = "unsubscribed") - self.stream.send(presence) - _account.destroySelf() - presence = Presence(from_jid = self.jid, to_jid = user_jid, \ - stanza_type = "unsubscribe") - self.stream.send(presence) - presence = Presence(from_jid = self.jid, to_jid = user_jid, \ - stanza_type = "unsubscribed") - self.stream.send(presence) - self.db_disconnect() - def handle_set_register(self, info_query): """Handle user registration response """ @@ -361,7 +341,8 @@ class JCLComponent(Component, object): remove = info_query.xpath_eval("r:query/r:remove", \ {"r" : "jabber:iq:register"}) if remove: - self.remove_all_accounts(base_from_jid) + result = self.account_manager.remove_all_accounts(from_jid.bare()) + self.send_stanzas(result) return 1 x_node = info_query.xpath_eval("jir:query/jxd:x", \ @@ -377,81 +358,29 @@ class JCLComponent(Component, object): text.setNs(text.newNs(error.STANZA_ERROR_NS, None)) self.stream.send(iq_error) return - name = x_data["name"].value - self.__logger.debug("Account name received = " + str(name)) - self.db_connect() - accounts = Account.select(\ - AND(Account.q.name == name, \ - Account.q.user_jid == base_from_jid)) - accounts_count = accounts.count() - all_accounts = Account.select(\ - Account.q.user_jid == base_from_jid) - all_accounts_count = all_accounts.count() - if accounts_count > 1: - # Just print a warning, only the first account will be use - self.__logger.error("There might not exist 2 accounts for " + \ - base_from_jid + " and named " + name) - if accounts_count >= 1: - _account = list(accounts)[0] - else: - if info_query.get_to().resource is None: - if len(self.account_classes) > 1: - self.__logger.error("There might be only one account class declared") - new_account_class = self.account_classes[0] - else: - new_account_class = self._get_account_class(info_query.get_to().resource + "Account") - _account = new_account_class(user_jid = unicode(base_from_jid), \ - name = name, \ - jid = name + u"@" + unicode(self.jid)) - self.__logger.debug("Account '" + str(name) + "' created: " + str(_account)) - field = None - try: - for (field, field_type, field_options, field_post_func, \ - field_default_func) in _account.get_register_fields(): - if field is not None: - if field in x_data: - value = x_data[field].value - else: - value = None - setattr(_account, field, \ - field_post_func(value, field_default_func)) - except FieldError, exception: - _account.destroySelf() - type, value, stack = sys.exc_info() - self.__logger.error("Error while populating account: %s\n%s" % \ - (exception, "".join(traceback.format_exception - (type, value, stack, 5)))) - iq_error = info_query.make_error_response("not-acceptable") - text = iq_error.get_error().xmlnode.newTextChild(None, \ - "text", \ - lang_class.mandatory_field % (field)) - text.setNs(text.newNs(error.STANZA_ERROR_NS, None)) - self.stream.send(iq_error) - self.db_disconnect() - return - info_query = info_query.make_result_response() - self.stream.send(info_query) - - if all_accounts_count == 0: - self.stream.send(Presence(from_jid = self.jid, \ - to_jid = base_from_jid, \ - stanza_type = "subscribe")) - if accounts_count == 0: - self.stream.send(Message(\ - from_jid = self.jid, to_jid = from_jid, \ - stanza_type = "normal", \ - subject = _account.get_new_message_subject(lang_class), \ - body = _account.get_new_message_body(lang_class))) - self.stream.send(Presence(from_jid = self.get_jid(_account), \ - to_jid = base_from_jid, \ - stanza_type = "subscribe")) - else: - self.stream.send(Message(\ - from_jid = self.jid, to_jid = from_jid, \ - stanza_type = "normal", \ - subject = _account.get_update_message_subject(lang_class), \ - body = _account.get_update_message_body(lang_class))) - self.db_disconnect() + account_name = x_data["name"].value + self.apply_behavior(info_query, \ + lambda name, bare_from_jid, account_type, lang_class: \ + self.account_manager.account_set_register(name, \ + bare_from_jid, \ + lang_class, \ + x_data, \ + info_query), \ + lambda name, bare_from_jid, account_type, lang_class: \ + self.account_manager.account_type_set_register(account_name, \ + bare_from_jid, \ + account_type, \ + lang_class, \ + x_data, \ + info_query), \ + lambda name, bare_from_jid, account_type, lang_class: \ + self.account_manager.root_set_register(account_name, \ + bare_from_jid, \ + lang_class, \ + x_data, \ + info_query), \ + send_result = True) + return def handle_presence_available(self, stanza): """Handle presence availability @@ -810,7 +739,7 @@ class AccountManager(object): # TODO : do it only one time accounts = account_class.select(\ AND(account_class.q.name == name, \ - account_class.q.user_jid == bare_from_jid)) + account_class.q.user_jid == unicode(bare_from_jid))) if accounts is not None: query = info_query.new_query("jabber:iq:register") self.get_reg_form_init(lang_class, \ @@ -838,7 +767,148 @@ class AccountManager(object): return self._account_type_get_register(info_query, \ self.account_classes[0], \ lang_class) + + ###### set_register handlers ###### + def remove_all_accounts(self, user_jid): + """Unsubscribe all accounts associated to 'user_jid' then delete + those accounts from the DataBase""" + self.db_connect() + result = [] + for _account in Account.select(Account.q.user_jid == unicode(user_jid)): + self.__logger.debug("Deleting " + _account.name \ + + " for " + unicode(user_jid)) + # get_jid + result.append(Presence(from_jid = _account.jid, \ + to_jid = user_jid, \ + stanza_type = "unsubscribe")) + result.append(Presence(from_jid = _account.jid, \ + to_jid = user_jid, \ + stanza_type = "unsubscribed")) + _account.destroySelf() + result.append(Presence(from_jid = self.component.jid, to_jid = user_jid, \ + stanza_type = "unsubscribe")) + result.append(Presence(from_jid = self.component.jid, to_jid = user_jid, \ + stanza_type = "unsubscribed")) + self.db_disconnect() + return result + + def _populate_account(self, _account, lang_class, x_data, \ + info_query, new_account, first_account): + """Populate given account""" + field = None + result = [] + self.db_connect() + try: + for (field, field_type, field_options, field_post_func, \ + field_default_func) in _account.get_register_fields(): + if field is not None: + if field in x_data: + value = x_data[field].value + else: + value = None + setattr(_account, field, \ + field_post_func(value, field_default_func)) + except FieldError, exception: + _account.destroySelf() + type, value, stack = sys.exc_info() + self.__logger.error("Error while populating account: %s\n%s" % \ + (exception, "".join(traceback.format_exception + (type, value, stack, 5)))) + iq_error = info_query.make_error_response("not-acceptable") + text = iq_error.get_error().xmlnode.newTextChild(None, \ + "text", \ + lang_class.mandatory_field % (field)) + text.setNs(text.newNs(error.STANZA_ERROR_NS, None)) + result.append(iq_error) + self.db_disconnect() + return result + result.append(info_query.make_result_response()) + + # TODO : _account.user_jid or from_jid + if first_account: + result.append(Presence(from_jid = self.component.jid, \ + to_jid = _account.user_jid, \ + stanza_type = "subscribe")) + if new_account: + result.append(Message(\ + from_jid = self.component.jid, to_jid = _account.user_jid, \ + stanza_type = "normal", \ + subject = _account.get_new_message_subject(lang_class), \ + body = _account.get_new_message_body(lang_class))) + result.append(Presence(from_jid = _account.jid, \ + to_jid = _account.user_jid, \ + stanza_type = "subscribe")) + else: + result.append(Message(\ + from_jid = self.component.jid, to_jid = _account.user_jid, \ + stanza_type = "normal", \ + subject = _account.get_update_message_subject(lang_class), \ + body = _account.get_update_message_body(lang_class))) + self.db_disconnect() + return result + + def account_set_register(self, name, bare_from_jid, lang_class, \ + x_data, info_query): + """Update account""" + self.db_connect() + accounts = Account.select(\ + AND(Account.q.name == name, \ + Account.q.user_jid == unicode(bare_from_jid))) + accounts_count = accounts.count() + _account = list(accounts)[0] + self.db_disconnect() + if accounts_count > 1: + # Just print a warning, only the first account will be use + self.__logger.error("There might not exist 2 accounts for " + \ + bare_from_jid + " and named " + name) + if accounts_count >= 1: + return self._populate_account(_account, lang_class, + x_data, info_query, False, False) + else: + self.__logger.error("Account " + name + \ + " was not found, cannot update it") + return [] + + def _account_type_set_register(self, name, \ + bare_from_jid, \ + account_class, \ + lang_class, \ + x_data, \ + info_query): + """Create new account from account_class""" + self.db_connect() + _account = account_class(user_jid = unicode(bare_from_jid), \ + name = name, \ + jid = self.get_account_jid(name)) + all_accounts = Account.select(\ + Account.q.user_jid == unicode(bare_from_jid)) + first_account = (all_accounts.count() > 0) + self.db_disconnect() + return self._populate_account(_account, lang_class, x_data, \ + info_query, True, first_account) + def account_type_set_register(self, name, \ + bare_from_jid, \ + account_type, \ + lang_class, \ + x_data, \ + info_query): + """Create new typed account""" + return self._account_type_set_register(name, bare_from_jid, \ + self._get_account_class(account_type + "Account"), lang_class, \ + x_data, info_query) + + def root_set_register(self, name, bare_from_jid, lang_class, \ + x_data, info_query): + """Create new account when managing only one account type""" + if not self.has_multiple_account_type: + return self._account_type_set_register(name, bare_from_jid, \ + self.account_classes[0], \ + lang_class, x_data, \ + info_query) + else: + return [] + ###### Utils methods ###### def _list_accounts(self, disco_items, _account_class, bare_from_jid, account_type = ""): """List accounts in disco_items for given _account_class and user jid""" @@ -937,3 +1007,7 @@ class AccountManager(object): if hasattr(_account, field.name): field.value = getattr(_account, field.name) return reg_form + + def get_account_jid(self, name): + """Compose account jid from account name""" + return name + u"@" + unicode(self.component.jid) diff --git a/src/jcl/model/account.py b/src/jcl/model/account.py index 2e2ffce..3c2bc17 100644 --- a/src/jcl/model/account.py +++ b/src/jcl/model/account.py @@ -49,7 +49,7 @@ def int_post_func(field_value, default_func): return int(default_func()) return int(field_value) -def mandatory_field(field_name, field_value, default_func): +def mandatory_field(field_value): """Used as default function for field that must be specified and cannot have an empty value""" if field_value is None or str(field_value) == "": diff --git a/tests/jcl/jabber/test_component.py b/tests/jcl/jabber/test_component.py index cce7b8e..dbe4ecc 100644 --- a/tests/jcl/jabber/test_component.py +++ b/tests/jcl/jabber/test_component.py @@ -867,9 +867,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[0].q.name == "account1") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -911,7 +911,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_set_register_new_multiple_types(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.account_classes = [ExampleAccount, Example2Account] + self.comp.account_manager.account_classes = (ExampleAccount, Example2Account) x_data = Form("submit") x_data.add_field(name = "name", \ value = "account1", \ @@ -924,9 +924,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[1].select(\ - self.comp.account_classes[1].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[1].q.name == "account1") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -968,7 +968,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_set_register_new_complex(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.account_classes = [ExampleAccount] + self.comp.account_manager.account_classes = (ExampleAccount,) x_data = Form("submit") x_data.add_field(name = "name", \ value = "account1", \ @@ -996,9 +996,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[0].q.name == "account1") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -1045,7 +1045,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_set_register_new_default_values(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.account_classes = [ExampleAccount] + self.comp.account_manager.account_classes = (ExampleAccount,) x_data = Form("submit") x_data.add_field(name = "name", \ value = "account1", \ @@ -1061,9 +1061,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[0].q.name == "account1") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -1088,9 +1088,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[0].q.name == "account1") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account1") self.assertEquals(accounts.count(), 0) del account.hub.threadConnection @@ -1107,7 +1107,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_set_register_new_field_mandatory(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.account_classes = [ExampleAccount] + self.comp.account_manager.account_classes = (ExampleAccount,) x_data = Form("submit") x_data.add_field(name = "name", \ value = "account1", \ @@ -1120,9 +1120,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[0].q.name == "account1") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account1") self.assertEquals(accounts.count(), 0) del account.hub.threadConnection @@ -1140,6 +1140,7 @@ class JCLComponent_TestCase(unittest.TestCase): account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) self.comp.stream = MockStream() self.comp.stream_class = MockStream + self.comp.account_manager.account_classes = (Example2Account, ExampleAccount) existing_account = ExampleAccount(user_jid = "user1@test.com", \ name = "account1", \ jid = "account1@jcl.test.com", \ @@ -1178,17 +1179,18 @@ class JCLComponent_TestCase(unittest.TestCase): field_type = "text-single") iq_set = Iq(stanza_type = "set", \ from_jid = "user1@test.com", \ - to_jid = "jcl.test.com") + to_jid = "account1@jcl.test.com") query = iq_set.new_query("jabber:iq:register") x_data.as_xml(query) self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[0].q.name == "account1") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] + self.assertEquals(_account.__class__.__name__, "ExampleAccount") self.assertEquals(_account.user_jid, "user1@test.com") self.assertEquals(_account.name, "account1") self.assertEquals(_account.jid, "account1@jcl.test.com") @@ -1204,7 +1206,7 @@ class JCLComponent_TestCase(unittest.TestCase): iq_result = stanza_sent[0] self.assertTrue(isinstance(iq_result, Iq)) self.assertEquals(iq_result.get_node().prop("type"), "result") - self.assertEquals(iq_result.get_from(), "jcl.test.com") + self.assertEquals(iq_result.get_from(), "account1@jcl.test.com") self.assertEquals(iq_result.get_to(), "user1@test.com") message = stanza_sent[1] @@ -1238,11 +1240,11 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com") + accounts = Account.select(\ + Account.q.user_jid == "user1@test.com") self.assertEquals(accounts.count(), 0) - accounts = self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user2@test.com") + accounts = Account.select(\ + Account.q.user_jid == "user2@test.com") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user2@test.com") @@ -1773,14 +1775,14 @@ class JCLComponent_TestCase(unittest.TestCase): self.assertEqual(presence.xpath_eval("@type")[0].get_content(), \ "unsubscribed") account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - self.assertEquals(self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com" \ - and self.comp.account_classes[0].q.name == "account11").count(), \ + self.assertEquals(Account.select(\ + Account.q.user_jid == "user1@test.com" \ + and Account.q.name == "account11").count(), \ 0) - self.assertEquals(self.comp.account_classes[0].select(\ - self.comp.account_classes[0].q.user_jid == "user1@test.com").count(), \ + self.assertEquals(Account.select(\ + Account.q.user_jid == "user1@test.com").count(), \ 1) - self.assertEquals(self.comp.account_classes[0].select().count(), \ + self.assertEquals(Account.select().count(), \ 2) del account.hub.threadConnection @@ -1805,7 +1807,7 @@ class JCLComponent_TestCase(unittest.TestCase): presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - self.assertEquals(self.comp.account_classes[0].select().count(), \ + self.assertEquals(Account.select().count(), \ 3) del account.hub.threadConnection @@ -1831,7 +1833,7 @@ class JCLComponent_TestCase(unittest.TestCase): presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - self.assertEquals(self.comp.account_classes[0].select().count(), \ + self.assertEquals(Account.select().count(), \ 3) del account.hub.threadConnection diff --git a/tests/jcl/model/account.py b/tests/jcl/model/account.py index b7b4fe9..0656e28 100644 --- a/tests/jcl/model/account.py +++ b/tests/jcl/model/account.py @@ -38,7 +38,7 @@ class ExampleAccount(Account): test_int = IntCol(default = 42) def _get_register_fields(cls, real_class = None): - def password_post_func(password, default_func): + def password_post_func(password): if password is None or password == "": return None return password @@ -47,11 +47,10 @@ class ExampleAccount(Account): real_class = cls return Account.get_register_fields(real_class) + \ [("login", "text-single", None, \ - lambda field_value, default_func: account.mandatory_field("login", \ - field_value, \ - default_func), \ + lambda field_value, default_func: account.mandatory_field(field_value), \ lambda : ""), \ - ("password", "text-private", None, password_post_func, \ + ("password", "text-private", None, \ + lambda field_value, default_func: password_post_func(field_value), \ lambda : ""), \ ("store_password", "boolean", None, account.default_post_func, \ lambda : True), \ diff --git a/tests/jcl/model/test_account.py b/tests/jcl/model/test_account.py index ea4321e..a9a8e52 100644 --- a/tests/jcl/model/test_account.py +++ b/tests/jcl/model/test_account.py @@ -64,15 +64,15 @@ class AccountModule_TestCase(unittest.TestCase): def test_mandatory_field_empty(self): self.assertRaises(FieldError, \ account.mandatory_field, \ - "field", "", None) + "") def test_mandatory_field_none(self): self.assertRaises(FieldError, \ account.mandatory_field, \ - "field", None, None) + None) def test_mandatory_field_empty(self): - self.assertEquals(account.mandatory_field("field", "value", None), \ + self.assertEquals(account.mandatory_field("value"), \ "value") class Account_TestCase(unittest.TestCase):