def test_spec_dict_type(self):
DynamicField.validate_spec(
{'a': dict},
{'a': {
'this': 'that'
}},
) # no errors
class DynamicModel(Model):
attrs = DynamicField(
spec={
'datetimey': datetime,
'datey': date,
'floaty': float,
'inty': int,
'stry': six.text_type,
'timey': time,
'nesty': {
'level2': six.text_type
}
})
@classmethod
def check(cls, **kwargs):
# Disable the checks on MySQL so that checks tests don't fail
if not (connection.is_mariadb and connection.mysql_version >=
(10, 0, 1)):
return []
return super(DynamicModel, cls).check(**kwargs)
def __unicode__(self):
return ",".join('{}:{}'.format(key, value)
for key, value in six.iteritems(self.attrs))
class DynamicModel(Model):
attrs = DynamicField(
spec={
"datetimey": datetime,
"datey": date,
"floaty": float,
"inty": int,
"stry": str,
"timey": time,
"nesty": {
"level2": str
},
})
@classmethod
def check(cls, **kwargs):
# Disable the checks on MySQL so that checks tests don't fail
if not (connection_is_mariadb(connection)
and connection.mysql_version >= (10, 0, 1)):
return []
return super().check(**kwargs)
def __unicode__(self):
return ",".join("{}:{}".format(key, value)
for key, value in self.attrs.items())
class SpeclessDynamicModel(Model):
attrs = DynamicField()
@classmethod
def check(cls, **kwargs):
# Disable the checks on MySQL so that checks tests don't fail
if not connection.mysql_is_mariadb:
return []
return super().check(**kwargs)
def __str__(self): # pragma: no cover
return ",".join(f"{key}:{value}" for key, value in self.attrs.items())
class SpeclessDynamicModel(Model):
attrs = DynamicField()
@classmethod
def check(cls, **kwargs):
# Disable the checks on MySQL so that checks tests don't fail
if not (connection_is_mariadb(connection)
and connection.mysql_version >= (10, 0, 1)):
return []
return super().check(**kwargs)
def __unicode__(self):
return ",".join(f"{key}:{value}" for key, value in self.attrs.items())
class DynamicModel(Model):
attrs = DynamicField(
spec={
"datetimey": dt.datetime,
"datey": dt.date,
"floaty": float,
"inty": int,
"stry": str,
"timey": dt.time,
"nesty": {
"level2": str
},
})
@classmethod
def check(cls, **kwargs):
# Disable the checks on MySQL so that checks tests don't fail
if not connection.mysql_is_mariadb:
return []
return super().check(**kwargs)
def __str__(self): # pragma: no cover
return ",".join(f"{key}:{value}" for key, value in self.attrs.items())
def test_spec_dict_type(self):
DynamicField.validate_spec({"a": dict}, {"a": {
"this": "that"
}}) # no errors
def test_deconstruct_spec(self):
field = DynamicField(spec={'this': int, 'that': float})
name, path, args, kwargs = field.deconstruct()
assert path == 'django_mysql.models.DynamicField'
DynamicField(*args, **kwargs)
def test_formfield(self):
model_field = DynamicField()
form_field = model_field.formfield()
self.assertIsNone(form_field)
def test_mariadb_dyncol_value(self):
value = mariadb_dyncol.pack({'foo': 'bar'})
result = DynamicField().to_python(value)
assert result == {'foo': 'bar'}
def test_pass_through(self):
value = {'foo': 'bar'}
result = DynamicField().to_python(value)
assert result == {'foo': 'bar'}
class InvalidDynamicModel1(TemporaryModel):
field = DynamicField(spec=['woops', 'a', 'list'])
class InvalidDynamicModel3(TemporaryModel):
field = DynamicField(spec={'bad': list})
class InvalidDynamicModel1(TemporaryModel):
field = DynamicField(spec=["woops", "a", "list"])
def test_int_equivalent_to_long(self):
from __builtin__ import long # make source lintable on Python 3
DynamicField.validate_spec({'a': long}, {'a': int(9001)}) # no errors
def test_deconstruct_spec(self):
field = DynamicField(spec={"this": int, "that": float})
name, path, args, kwargs = field.deconstruct()
assert path == "django_mysql.models.DynamicField"
DynamicField(*args, **kwargs)
def test_pass_through(self):
value = {"foo": "bar"}
result = DynamicField().to_python(value)
assert result == {"foo": "bar"}
def test_json(self):
value = str(json.dumps({"foo": "bar"}))
result = DynamicField().to_python(value)
assert result == {"foo": "bar"}
def test_mariadb_dyncol_value(self):
value = mariadb_dyncol.pack({"foo": "bar"})
result = DynamicField().to_python(value)
assert result == {"foo": "bar"}
class InvalidDynamicModel4(TemporaryModel):
field = DynamicField(spec={"l1": {"bad": tuple}})
class DumbTransform(Transform):
"""
Used to test existing transform behaviour. Really dumb, returns the string
'dumb' always.
"""
lookup_name = 'dumb'
output_field = CharField()
def as_sql(self, compiler, connection):
lhs, params = compiler.compile(self.lhs)
return "%s", ['dumb']
DynamicField.register_lookup(DumbTransform)
class QueryTests(DynColTestCase):
def setUp(self):
super(QueryTests, self).setUp()
self.objs = [
DynamicModel(attrs={'a': 'b'}),
DynamicModel(attrs={'a': 'b', 'c': 'd'}),
DynamicModel(attrs={'c': 'd'}),
DynamicModel(attrs={}),
DynamicModel(attrs={
'datetimey': datetime(2001, 1, 4, 14, 15, 16),
'datey': date(2001, 1, 4),
'floaty': 128.5,
class DumbTransform(Transform):
"""
Used to test existing transform behaviour - by default in Django there are
no transforms on BinaryField.
Really dumb, returns the string 'dumb' always
"""
lookup_name = 'dumb'
output_field = CharField()
def as_sql(self, compiler, connection):
lhs, params = compiler.compile(self.lhs)
return "%s", ['dumb']
DynamicField.register_lookup(DumbTransform)
class QueryTests(DynColTestCase):
def setUp(self):
super(QueryTests, self).setUp()
self.objs = [
DynamicModel(attrs={'a': 'b'}),
DynamicModel(attrs={'a': 'b', 'c': 'd'}),
DynamicModel(attrs={'c': 'd'}),
DynamicModel(attrs={}),
DynamicModel(attrs={
'datetimey': datetime(2001, 1, 4, 14, 15, 16),
'datey': date(2001, 1, 4),
'floaty': 128.5,
class ValidDynamicModel3(TemporaryModel):
field = DynamicField()
def test_int_equivalent_to_long(self):
from __builtin__ import long # make source lintable on Python 3
DynamicField.validate_spec({'a': long}, {'a': int(9001)}) # no errors
class InvalidDynamicModel2(TemporaryModel):
field = DynamicField(spec={
2.0: six.text_type,
})
def test_deconstruct(self):
field = DynamicField()
name, path, args, kwargs = field.deconstruct()
DynamicField(*args, **kwargs)
class InvalidDynamicModel4(TemporaryModel):
field = DynamicField(spec={
'l1': {
'bad': tuple,
},
})
def test_deconstruct_spec(self):
field = DynamicField(spec={'this': int, 'that': float})
name, path, args, kwargs = field.deconstruct()
assert path == 'django_mysql.models.DynamicField'
DynamicField(*args, **kwargs)
def test_json(self):
value = six.text_type(json.dumps({'foo': 'bar'}))
result = DynamicField().to_python(value)
assert result == {'foo': 'bar'}
def test_formfield(self):
model_field = DynamicField()
form_field = model_field.formfield()
self.assertIsNone(form_field)
def test_deconstruct(self):
field = DynamicField()
name, path, args, kwargs = field.deconstruct()
DynamicField(*args, **kwargs)
def test_spec_dict_type(self):
DynamicField.validate_spec(
{'a': dict},
{'a': {'this': 'that'}}
) # no errors
def test_makemigrations(self):
field = DynamicField(spec={'a': 'beta'})
statement, imports = MigrationWriter.serialize(field)
# 'spec' should not appear since that would trigger needless ALTERs
assert statement == "django_mysql.models.DynamicField()"
class InvalidDynamicModel2(TemporaryModel):
field = DynamicField(spec={
2.0: str,
})
def test_spec_empty(self):
DynamicField.validate_spec({}, {}) # no errors
def test_deconstruct_blank(self):
field = DynamicField(blank=False)
name, path, args, kwargs = field.deconstruct()
assert kwargs["blank"] is False
DynamicField(*args, **kwargs)
