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()
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_json(self): value = six.text_type(json.dumps({'foo': 'bar'})) result = DynamicField().to_python(value) assert result == {'foo': 'bar'}
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)