class OnlineScoreRequest(unittest.TestCase):
first_name = CharField(required=False, nullable=True)
last_name = CharField(required=False, nullable=True)
email = EmailField(required=False, nullable=True)
phone = PhoneField(required=False, nullable=True)
birthday = BirthDayField(required=False, nullable=True)
gender = GenderField(required=True, nullable=True)
@unittest.expectedFailure
@cases({"param": 123})
def test_first_name_field_bad(self):
self.first_name = 123
@cases({"param": 'tests'})
def test_first_name_field_good(self, param):
self.first_name = param
@unittest.expectedFailure
@cases({"param": 123})
def test_last_name_field_bad(self, param):
self.last_name = param
@cases({"param": 'tests'})
def test_last_name_field_good(self, param):
self.last_name = param
@unittest.expectedFailure
@cases({"param": 'tests@[email protected]'})
def test_email_field_bad(self, param):
self.email = param
@cases({"param": '*****@*****.**'})
def test_email_field_good(self, param):
self.email = param
@unittest.expectedFailure
def test_phone_field_bad(self):
self.phone = '899'
def test_phone_field_good(self):
self.phone = '79991231231'
@unittest.expectedFailure
def test_birthday_field_bad(self):
self.birthday = '10/10/2000'
def test_birthday_field_good(self):
self.birthday = '10.10.2000'
@unittest.expectedFailure
def test_gender_field_bad(self):
self.gender = 4
def test_gender_field_good(self):
self.gender = 1
def test_not_nullable(self):
f = CharField()
self.assertEqual('test', f.clean('test'))
with self.assertRaisesRegex(ValueError, r'This field cannot be empty.'):
f.clean('')
with self.assertRaisesRegex(ValueError, r'This field cannot be empty.'):
f.clean(None)
with self.assertRaisesRegex(ValueError, r'This field must be a string.'):
f.clean(123)
class MethodRequest(unittest.TestCase):
account = CharField(required=False, nullable=True)
login = CharField(required=True, nullable=True)
token = CharField(required=True, nullable=True)
arguments = ArgumentsField(required=True, nullable=True)
method = CharField(required=True, nullable=False)
@unittest.expectedFailure
def test_account_field_bad(self):
self.account = 123
def test_account_field_good(self):
self.account = '123'
@unittest.expectedFailure
def test_login_field_bad(self):
self.login = 123
def test_login_field_good(self):
self.login = '******'
@unittest.expectedFailure
def test_token_field_bad(self):
self.token = 123
@unittest.expectedFailure
def test_token_field_empty(self):
self.token = ''
def test_token_field_good(self):
self.token = '123'
@unittest.expectedFailure
def test_arguments_field_bad(self):
self.arguments = 123
def test_arguments_field_good(self):
self.arguments = {'test1':'1','test2':'2','test3':'3'}
@unittest.expectedFailure
def test_method_field_bad(self):
# self.token = b''
self.token.value_validate(123)
def test_method_field_good(self):
self.token = '123'
def test_nullable(self):
f = CharField(nullable=True)
self.assertEqual('', f.clean(None))
self.assertEqual('', f.clean(''))
self.assertEqual('test', f.clean('test'))
with self.assertRaisesRegex(ValueError, r'This field must be a string.'):
f.validate(123)
def test_wrong_char_field(self, value):
with self.assertRaises(DataFieldError):
CharField().validate(value)
def test_right_char_field(self, value):
self.assertEqual(CharField().validate(value), value)
def test_valid(self, value):
field = CharField()
self.assertEqual(field.parse(value), value)
def test_invalid(self, value):
field = CharField()
with self.assertRaises(ValidateFieldError):
field.parse(value)
def test_good_value(self, test_case):
instance = CharField(required=test_case['required'],
nullable=test_case['nullable'])
self.assertEqual(instance.parse_validate(test_case['value']),
test_case['value'])
def test_bad_value(self, test_case):
instance = CharField(required=test_case['required'],
nullable=test_case['nullable'])
self.assertRaises(ValueError, instance.parse_validate,
test_case['value'])
def test_valid_value(self, value):
self.assertEqual(value, CharField().parse(value), msg="Value {0} throws error".format(value))
def test_invalid_value(self, value):
with self.assertRaises(ValueError):
CharField().parse(value)