class TestDateField(TestCase):
field = api.DateField()
@cases([
'01.01.2020',
'01.01.1900',
])
def test_good_field(self, val):
api.DateField.name = '_field'
self.field = val
self.assertEqual(self.field, datetime.strptime(val, '%d.%m.%Y'))
@cases([
'',
'01.13.2020',
'30.02.2020',
'32.03.2020',
'aaaaaa',
1,
])
def test_bad_field(self, val):
api.DateField.name = '_field'
def assign():
self.field = val
self.assertRaises(Exception, assign)
def test_invalid_date_field(value):
field = api.DateField(required=True, nullable=False)
try:
field.clean(value)
pytest.fail("ValidationError expected")
except api.ValidationError:
assert True
def test__validate_exception(self):
f = api.DateField()
value = 'test'
f.field_name = value
with pytest.raises(MyException, message=f.MSG_FORMAT.format(value, value)):
f._validate(input)
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)
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)
def test_date_field_bad_format_string(required=False,
nullable=True,
field_value="31.13.2000"):
_field = api.DateField(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_date_field_datime_value(required=False,
nullable=True,
field_value=datetime.datetime.utcnow()):
_field = api.DateField(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
def test_date_field_string_parse(required=False,
nullable=True,
field_value="31.12.2000"):
_field = api.DateField(required=required, nullable=nullable)
_field.field_name = "test_field"
datetime_value = datetime.datetime.strptime(field_value, "%d.%m.%Y")
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") == datetime_value
def test_date_field(self):
field = api.DateField()
field.field_name = 'field'
field.validate_value('19.12.2001')
self.assertRaises(api.ValidationError, field.validate_value,
'45.12.2001')
self.assertRaises(api.ValidationError, field.validate_value,
'asdf.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_date_field(self, datefield):
f = api.DateField()
dt = datetime.datetime.strptime(datefield, "%d.%m.%Y")
self.assertEqual(f.parse_validate(datefield), dt)
def test_not_date_field(self, datefield):
f = api.DateField()
with self.assertRaises(ValueError):
f.parse_validate(datefield)
def test_invalid_birthdate(self, value):
with self.assertRaises(api.ValidationError):
api.DateField().valid_value(value)
def test_bad_date_field(self, value):
field = api.DateField()
with self.assertRaises(Exception):
field.clean(value)
def test_invalid_type_value(self, value):
with self.assertRaises(TypeError):
api.DateField(nullable=True).validate(value)
def test_birthdayfield_valid(self, value):
bd = api.BirthDayField().run_validators(value)
result = api.DateField().to_str(bd)
self.assertEqual(value, result)
def test_invalid_date_field(self, value):
field = api.DateField()
self.assertInvalid(field, value)
def test_valid_date_field(self):
value = '17.05.2004'
field = api.DateField()
self.assertValid(field, value)
def setUp(self):
self.field = api.DateField()
self.field.field_name = 'date_field'
def test_invalid_value(self, val):
""" Test DateField INVALID values """
with self.assertRaises(ValidationError):
api.DateField(required=False, nullable=True, value=val).validate()
def test_valid_value(self, val):
""" Test DateField VALID values """
api.DateField(required=False, nullable=True, value=val).validate()
def test_datefield_valid(self, value):
df = api.DateField().run_validators(value)
result = api.DateField().to_str(df)
self.assertEqual(value, result)
def test_datefield_invalid(self, value):
self.assertRaises(ValueError, api.DateField().run_validators, value)
def test_bad_date_attribute(self, value):
attr = api.DateField(required=False, nullable=True)
self.assertFalse(attr.validate(value))
def test_valid_value(self, value):
self.assertEqual(value, api.DateField(nullable=True).validate(value))
class TestSuite(unittest.TestCase):
def setUp(self):
self.context = {'request_id': 0}
self.headers = {}
def get_response(self, request):
return api.method_handler({
"body": request,
"headers": self.headers
}, self.context)
def test_empty_request(self):
_, code = self.get_response({})
self.assertEqual(api.INVALID_REQUEST, code)
@cases([0, -1, []])
def test_bad_char_attribute(self, value):
attr = api.CharField(required=False, nullable=True)
self.assertFalse(attr.validate(value))
@cases([0, -1, {
1,
}, '0', '-1'])
def test_bad_arguments_attribute(self, value):
attr = api.ArgumentsField(required=True, nullable=True)
self.assertFalse(attr.validate(value))
@cases([0, -1, '0', 'iuejh339 dl93', []])
def test_bad_email_attribute(self, value):
attr = api.EmailField(required=False, nullable=True)
self.assertFalse(attr.validate(value))
@cases(['737473dh321', 0, -1, '790000323732'])
def test_bad_phone_attribute(self, value):
attr = api.PhoneField(required=False, nullable=True)
self.assertFalse(attr.validate(value))
@cases([
'01.', 12122017, -1, '32.12.2017', '2017.12.31', '12.01.17',
'10.01.200', '..', [], -0.0
])
def test_bad_date_attribute(self, value):
attr = api.DateField(required=False, nullable=True)
self.assertFalse(attr.validate(value))
@cases([
'01.', 12122017, -1, '32.12.2017', '2017.12.31', '12.01.17',
'10.01.200', '..', [], -0.0, '01.01.1917', '20.12.3018'
])
def test_bad_birthday_attribute(self, value):
attr = api.BirthDayField(required=False, nullable=True)
self.assertFalse(attr.validate(value))
@cases(['1', 1.0, -1, 7, -2.0, [], -0.0])
def test_bad_gender_attribute(self, value):
attr = api.GenderField(required=False, nullable=True)
self.assertFalse(attr.validate(value))
@cases([[0], [-1], -1, 0, ' ', '[1, -1, 0]', -1.0, [1.0, 2.0, 3.0]])
def test_bad_clientids_attribute(self, value):
attr = api.ClientIDsField(required=True)
self.assertFalse(attr.validate(value))
@cases([
api.ClientIDsField(required=True),
api.GenderField(required=True, nullable=True),
api.BirthDayField(required=True, nullable=True),
api.DateField(required=True, nullable=True),
api.PhoneField(required=True, nullable=True),
api.EmailField(required=True, nullable=True),
api.ArgumentsField(required=True, nullable=True),
api.CharField(required=True, nullable=True)
])
def test_required_attributes(self, value):
self.assertFalse(value.validate(None))
@cases([
api.ClientIDsField(required=True),
api.GenderField(required=True, nullable=False),
api.BirthDayField(required=True, nullable=False),
api.DateField(required=True, nullable=False),
api.PhoneField(required=True, nullable=False),
api.EmailField(required=True, nullable=False),
api.ArgumentsField(required=True, nullable=False),
api.CharField(required=True, nullable=False)
])
def test_nullable_attributes(self, value):
self.assertFalse(value.validate(''))
@cases([{
"account": "horns&hoofs",
"login": "******",
"method": "online_score",
"token": "",
"arguments": {}
}, {
"account": "ой",
"login": "******",
"method": "online_score",
"token": "sdd",
"arguments": {}
}, {
"account": "horns&hoofs",
"login": "******",
"method": "online_score",
"token": "ой",
"arguments": {}
}, {
"account": "",
"login": "******",
"method": "online_score",
"token": "",
"arguments": {}
}, {
"account": "horns&hoofs",
"login": "******",
"method": "online_score",
"token": "",
"arguments": {}
}, {
"account": "horns&hoofs",
"login": "******",
"method": "online_score",
"token": "",
"arguments": {}
}])
def test_bad_auth(self, request):
request = api.set_attributes(api.MethodRequest, request)
self.assertFalse(api.check_auth(request))
@cases([{
'test_class': api.MethodRequest,
'values': {
"account": "Ой",
"login": "",
"method": "метод",
"token": "что-то",
"arguments": {
'аргумент': 'значение'
}
}
}, {
'test_class': api.ClientsInterestsRequest,
'values': {
'date': '20.07.2017',
'client_ids': [1, 2, 3, 4]
}
}, {
'test_class': api.OnlineScoreRequest,
'values': {
'first_name': 'имя',
'last_name': 'фамилия',
'gender': 1,
'phone': '79175002040',
'birthday': '01.01.1990',
'email': 'имя@domain.com'
}
}])
def test_set_attributes(self, kwargs):
filled_obj = api.set_attributes(kwargs['test_class'], kwargs['values'])
for attr, value in kwargs['values'].items():
self.assertEqual(filled_obj.__dict__[attr].__dict__['value'],
value)
def test_invalid_value(self, value):
with self.assertRaises(ValueError):
print(api.DateField(nullable=False).validate(value))
def setUpClass(cls):
cls.field = api.DateField()
def test_date_field(self):
field = api.DateField()
self.assertEqual(
field.clean('12.12.1954'), api.datetime(1954, 12, 12, 0, 0)
)
def test_valid_birthdate(self, value):
self.assertIsInstance(api.DateField().valid_value(value),
datetime.datetime)
