def test_required_non_nullable_field(self):
field = api.CharField(True, False)
inst = self.create_class_with_field(field, None, False)
self.assertRaises(api.ValidationError, field.validate, inst)
inst = self.create_class_with_field(field, None, True)
self.assertRaises(api.ValidationError, field.validate, inst)
def test_invalid_char_field(value):
field = api.CharField(required=True, nullable=False)
try:
field.clean(value)
pytest.fail("ValidationError expected")
except api.ValidationError:
assert True
class FieldTester(api.Structure):
charfield = api.CharField(nullable=True) #
emailfield = api.EmailField(nullable=True)
phonefield = api.PhoneField(nullable=True)
birthdayfield = api.BirthDayField(nullable=True)
genderfield = api.GenderField(nullable=True)
datefield = api.DateField(nullable=True)
client_ids = api.ClientIDsField(required=True)
def test_char_field(self):
field = api.CharField()
field.field_name = 'field'
field.validate_value('19.12.2001')
self.assertTrue(field.is_null_value(''))
self.assertTrue(field.is_null_value(None))
self.assertFalse(field.is_null_value('19.12.2001'))
def test_char_field_bad_cases(required, nullable, field_value):
_field = api.CharField(required=required, nullable=nullable)
_field.field_name = "test_field"
MockRequest.test_field = _field
mock_obj = MockRequest(test_field=field_value)
mock_obj.fields["test_field"] = _field
with pytest.raises(api.ValidationError):
MockRequest.__dict__["test_field"].__set__(mock_obj, field_value)
def test_char_field_ok_cases(required, nullable, field_value):
_field = api.CharField(required=required, nullable=nullable)
_field.field_name = "test_field"
MockRequest.test_field = _field
mock_obj = MockRequest(test_field=field_value)
mock_obj.fields["test_field"] = _field
MockRequest.__dict__["test_field"].__set__(mock_obj, field_value)
assert getattr(mock_obj, "test_field") == field_value
class FieldsSet:
arguments_field = api.ArgumentsField()
char_field = api.CharField()
email_field = api.EmailField()
phone_field = api.PhoneField()
date_field = api.DateField()
birthday_field = api.BirthDayField()
gender_field = api.GenderField()
client_ids_field = api.ClientIDsField()
class FieldContainer(object):
char_field = api.CharField(nullable=False)
int_field = api.IntField(nullable=False)
arg_field = api.ArgumentsField(nullable=False)
email_field = api.EmailField(nullable=False)
phone_field = api.PhoneField(nullable=False)
date_field = api.DateField(nullable=False)
birthday_field = api.BirthDayField(nullable=False)
gender_field = api.GenderField(nullable=False)
ids_field = api.ClientIDsField(nullable=False)
class TestCharField(TestCase):
field = api.CharField()
@cases(['good text', ])
def test_field(self, val):
api.CharField.name = '_field'
self.field = val
self.assertEqual(self.field, val)
@cases([1, {}, [], ])
def test_bad_field(self, val):
def assign():
self.field = val
self.assertRaises(Exception, assign)
def setUp(self):
self.field = api.CharField()
self.field.field_name = 'char_field'
def test_invalid_char_field(self, value):
field = api.CharField()
self.assertInvalid(field, value)
def test_valid_char_field(self):
value = 'char_value'
field = api.CharField()
self.assertValid(field, value)
def test_invalid_value(self, value):
with self.assertRaises(ValueError):
api.CharField(nullable=False).validate(value)
def test_charfield_invalid(self, value):
self.assertRaises(ValueError, api.CharField().run_validators, value)
def test_char_field(self, param):
f = api.CharField()
self.assertEqual(f.parse_validate(param), param)
def test_non_required_non_nullable_field(self):
field = api.CharField(required=False, nullable=False)
inst = self.create_class_with_field(field,
field_value=None,
init_by_value=True)
self.assertRaises(api.ValidationError, field.validate, inst)
def test_invalid_value(self, val):
""" Test CharField INVALID values """
with self.assertRaises(ValidationError):
api.CharField(required=False, nullable=True, value=val, name='first_name').validate()
api.CharField(required=False, nullable=True, value=val, name='last_name').validate()
def test_valid_value(self, val):
""" Test CharField VALID values """
api.CharField(required=False, nullable=True, value=val).validate()
def test_invalid_char_field(self, value):
with self.assertRaises(api.ValidationError):
api.CharField().valid_value(value)
def test_char_field_valid_value(self, value):
self.assertEqual(value, api.CharField().valid_value(value))
self.assertIsInstance(api.CharField().valid_value(value), basestring)
def setUpClass(cls):
cls.field = api.CharField()
def test__null_not_required_nullable_ok(self):
field = a.CharField(required=False, nullable=True)
res = field.clean(None)
assert (res, None)
def test_non_char_field(self, param):
f = api.CharField()
with self.assertRaises(ValueError):
f.parse_validate(param)
def test__null_not_required_not_nullable_error(self):
field = a.CharField(required=False, nullable=False)
with pytest.raises(ValueError):
field.clean(None)
def test_charfield_valid(self, value):
self.assertEqual(value, api.CharField().run_validators(value))
def test__charfield_nonstring_error(self, value):
charfield = a.CharField()
with pytest.raises(ValueError):
charfield.clean(value)
def test_invalid_type_value(self, value):
with self.assertRaises(TypeError):
api.CharField(nullable=True).validate(value)
def test__charfield_string_ok(self, value):
charfield = a.CharField()
resp = charfield.clean(value)
assert (resp, value)
def test_valid_value(self, value):
self.assertEqual(value, api.CharField(nullable=True).validate(value))
def test__null_required_error(self):
field = a.CharField(required=True)
with pytest.raises(ValueError):
field.clean(None)
