示例#1
0
 def test(self):
     Y = list_of_fields(TestModelY)
     X = list_of_fields(TestModelX)
     A = list_of_fields(TestModelA)
     B = list_of_fields(TestModelB)
     C = list_of_fields(TestModelC)
     D = list_of_fields(TestModelD)
     E = list_of_fields(TestModelE)
     self.assertFalse(field_sample_values(X[0]))
     self.assertEqual(field_sample_values(Y[1]), [2, 3, 5, 7, 11, 13])
     self.assertEqual(field_sample_values(Y[2]), ['MMa', 'XXa', 'azz'])
     self.assertEqual(field_sample_values(X[1]),
                      [x * x * x for x in range(10)])
     self.assertEqual(field_sample_values(E[3]), [1000000009, 1000003, 101])
     self.assertEqual(field_sample_values(D[1]),
                      [x * x * x for x in range(10)])
     self.assertEqual(field_sample_values(C[1]),
                      ['Hello I am C', 'MUHAHAHAHAHA', 'CCCC', '^_^'])
     self.assertEqual(field_sample_values(B[1]),
                      ['Hello Universe', 'Hello Parallel Universe!'])
     self.assertEqual(field_sample_values(A[1]),
                      ['Hello World', 'Hello Africa', 'axxx!!'])
     self.assertEqual(field_sample_values(A[2]),
                      ['Hello Second Field', 'field 2'])
     a = TestModelX(field1X=12)
     b = TestModelX(field1X=15)
     a.save()
     b.save()
     self.assertEqual((field_sample_values(models.ForeignKey(TestModelX))),
                      ([a, b]))
     fld = models.ManyToManyField(TestModelX)
     self.assertTrue(all([x in [a, b]
                          for x in field_sample_values(fld)[0]]))
     vals = [int(x) for x in field_sample_values(list_of_fields(CycleF)[2])]
     self.assertEqual(vals, range(4000, 5000))
示例#2
0
 def test(self):
     self.assertTrue(all(isinstance(*x)
                         for x in zip(list_of_fields(TestModel1),
                                      [models.AutoField, models.CharField,
                                       models.IntegerField,
                                       models.ForeignKey])))
     self.assertTrue(all([isinstance(*x)
                          for x in zip(list_of_fields(TestModel0),
                                       [models.AutoField,
                                        models.BooleanField,
                                        models.EmailField])]))
     self.assertTrue(all([isinstance(*x)
                          for x in zip(list_of_fields(TestModelE),
                                       [models.AutoField,
                                        models.OneToOneField,
                                        models.ForeignKey,
                                        models.IntegerField,
                                        models.ManyToManyField])]))
示例#3
0
 def test(self):
     c = CycleC(c='3.14159')
     c.save()
     d = CycleD(d=53, dc=c)
     d.save()
     b = CycleB(b=1000000009, bc=c)
     b.save()
     e = CycleE(e=17, ec=c, ed=d)
     e.save()
     a = CycleA(a=999, ab=b, ae=e)
     a.save()
     f = CycleF(f=123, fd=d)
     f.save()
     recompute(CycleD, list_of_fields(CycleD)[2])
     recompute(CycleC, list_of_fields(CycleC)[1])
     recompute(CycleC, list_of_fields(CycleC)[3])
     self.assertTrue(CycleD.objects.all()[0].df)
     self.assertTrue(CycleC.objects.all()[0].ca)
     self.assertTrue(CycleC.objects.all()[0].cc.all())
示例#4
0
 def test(self):
     constraint = unique_items(('fieldA', 'fieldD',))
     model = TestModelFieldsTwo(fieldA='A', fieldD=5, fieldB=10,
                                fieldC='Winner', fieldE=True, fieldF=6,
                                fieldG='Mathematics', fieldH=False)
     model.save()
     fields = list_of_fields(TestModelFields)
     self.assertFalse(constraint([('fieldA', 'A'), ('fieldD', 5)],
                                 TestModelFieldsTwo, fields[5]))
     self.assertTrue(constraint([('fieldA', 'A')],
                                TestModelFields, fields[5]))
     self.assertFalse(constraint([('fieldA', 'A'), ('fieldD', 5)],
                                 TestModelFieldsTwo, fields[5]))
     self.assertTrue(constraint([('fieldA', 'A'), ('fieldD', 3)],
                                TestModelFieldsTwo, fields[5]))
     self.assertTrue(constraint([('fieldA', 'A')],
                                TestModelFieldsTwo, fields[5]))
     self.assertTrue(constraint([('fieldA', 'A'), ('fieldD', 3)],
                                TestModelFieldsTwo, fields[5]))
示例#5
0
 def test(self):
     generate_test_data('tests.models', 10)
     length = len(list_of_models(mdls))
     visited = dict(zip(list_of_models(mdls), length * [False]))
     pairs = []
     data_base = dict([(mdl, list(mdl.objects.all()))
                       for mdl in list_of_models(mdls)])
     generated_data = data_base.values()
     nodes = 0
     edges = 0
     for list_model in generated_data:
         for model in list_model:
             visited[model.__class__] = True
             fields = list_of_fields(model.__class__)
             nodes += 1
             for field in fields:
                 if (not is_auto_field(field) and
                    not is_reverse_related(field)):
                     val = getattr(model, field.name)
                     if is_related(field):
                         if 'ManyToMany' in relation_type(field):
                             r = data_base[field.rel.to]
                             self.assertTrue(list(val.all()))
                             self.assertTrue(all([x in r for
                                                  x in list(val.all())]))
                         else:
                             r = data_base[field.rel.to]
                             self.assertTrue(val in r)
                         edges += 1
                     else:
                         this_model = field.model
                         while (this_model != Model and not
                                (hasattr(this_model, 'TestData') and
                                 hasattr(this_model.TestData, field.name))
                                and not os.path.exists(
                                 '%s/TestTemplates/sample__%s__%s' %
                                 (this_model._meta.app_label,
                                  this_model.__name__, field.name))):
                             this_model = this_model.__base__
                         if this_model == Model:
                             self.assertEqual(model.__class__,
                                              AllFieldsModel)
                             sample_values = field_sample_values(field)
                             if val.__class__ == unicode:
                                 val = str(val)
                             self.assertTrue(val.__class__ in
                                             map(lambda val: val.__class__,
                                                 sample_values))
                         elif (field.__class__.__name__ == 'DecimalField' or
                               field.__class__.__name__ == 'FloatField'):
                             sample_values = map(float,
                                                 field_sample_values(field))
                             val = float(val)
                             self.assertTrue(any(abs(val - fld_value) < 1e-5
                                                 for fld_value in
                                                 sample_values))
                         else:
                             sample_values = map(str,
                                                 field_sample_values(field))
                             val = str(val)
                             self.assertTrue(val in sample_values)
             if model.__class__ == TestModelFields:
                 pr = (model.fieldC, model.fieldA)
                 self.assertFalse(pr in pairs)
                 pairs.append(pr)
                 self.assertTrue((model.fieldB < 50)
                                 or (model.fieldD / 2 % 2 == 1))
     self.assertTrue(all(visited.values()),
                     "Not all the models with sample data are generated.")
示例#6
0
 def test(self):
     fields = list_of_fields(AllFieldsModel)
     present_types = list(map(lambda field: field.__class__, fields))
     field_types = [BigIntegerField, BooleanField, CharField,
                    CommaSeparatedIntegerField, DateField, DateTimeField,
                    DecimalField, DurationField, EmailField, FloatField,
                    GenericIPAddressField, IntegerField, NullBooleanField,
                    PositiveIntegerField, PositiveSmallIntegerField,
                    SmallIntegerField, TextField, TimeField, BinaryField,
                    FileField, ImageField, FilePathField, SlugField,
                    URLField, UUIDField]
     self.assertFalse(set(field_types) - set(present_types),
                      "All types should be present." +
                      str(set(field_types) - set(present_types)))
     for field in fields:
         if isinstance(field, FileField) or isinstance(field, ImageField):
             path = os.path.join(settings.MEDIA_ROOT, field.upload_to)
             files = next((filenames for dirpath, dirnames, filenames in
                          os.walk(path) if dirpath == path), None)
             files = list(map(lambda file: os.path.join(path, file), files))
         sample_siz = 10
         values = generate_random_values(field, sample_siz)
         self.assertLessEqual(len(values), sample_siz)
         self.assertGreaterEqual(len(values), 1)
         for val in values:
             if isinstance(field, IntegerField):
                 self.assertTrue(isinstance(val, int), val)
             if isinstance(field, EmailField):
                 self.assertTrue(isinstance(val, str), val)
                 email_reg = r'^\w+(?:\.\w+)*@(?:[A-Za-z0-9]+\.)+[A-Za-z]+$'
                 self.assertRegexpMatches(val, email_reg, val)
             if isinstance(field, BooleanField):
                 self.assertTrue(isinstance(val, bool), val)
             if isinstance(field, NullBooleanField):
                 self.assertTrue(isinstance(val, bool) or val is None, val)
             if isinstance(field, CharField):
                 self.assertTrue(isinstance(val, str), val)
                 self.assertLessEqual(len(val), field.max_length, val)
             if isinstance(field, CommaSeparatedIntegerField):
                 self.assertTrue(isinstance(val, str), val)
                 comma_sep_int_re = r'^\d{1,3}(?:,\d{3})*$'
                 self.assertRegexpMatches(val, comma_sep_int_re, val)
             if isinstance(field, DateField):
                 self.assertTrue(isinstance(val, datetime.date), val)
             if isinstance(field, DateTimeField):
                 self.assertTrue(isinstance(val, datetime.datetime), val)
             if isinstance(field, DecimalField):
                 self.assertTrue(isinstance(val, Decimal), val)
             if isinstance(field, FloatField):
                 self.assertTrue(isinstance(val, float), val)
             if isinstance(field, GenericIPAddressField):
                 self.assertTrue(isinstance(val, str), val)
                 ip_regex = r'^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$'
                 self.assertRegexpMatches(val, ip_regex, val)
             if isinstance(field, PositiveIntegerField):
                 self.assertTrue(isinstance(val, int), val)
                 self.assertLessEqual(val, 2147483647, val)
                 self.assertGreaterEqual(val, 0, val)
             if isinstance(field, PositiveSmallIntegerField):
                 self.assertTrue(isinstance(val, int), val)
                 self.assertLessEqual(val, 32767, val)
                 self.assertGreaterEqual(val, 0, val)
             if isinstance(field, SmallIntegerField):
                 self.assertTrue(isinstance(val, int), val)
                 self.assertLessEqual(val, 32767, val)
                 self.assertGreaterEqual(val, -32768, val)
             if isinstance(field, TimeField):
                 self.assertTrue(isinstance(val, datetime.time), val)
             if isinstance(field, TextField):
                 self.assertTrue(isinstance(val, str), val)
                 self.assertLessEqual(len(val), field.max_length)
                 text_re = r'^(?:(?:\w+\s?)+\.\s?)+$'
                 self.assertRegexpMatches(val, text_re, val)
             if isinstance(field, DurationField):
                 self.assertTrue(isinstance(val, datetime.timedelta), val)
             if isinstance(field, SlugField):
                 self.assertTrue(isinstance(val, str), val)
                 slug_re = r'^[a-zA-Z0-9_\-]+$'
                 self.assertRegexpMatches(val, slug_re, val)
             if isinstance(field, URLField):
                 url_re = r'^(?:http|ftp|https)://(?:[a-z0-9_\-]+\.?)+/?'
                 url_re += r'(?:/[a-z0-9_\-]+)*/?$'
                 self.assertTrue(isinstance(val, str), val)
                 self.assertRegexpMatches(val, url_re, val)
             if isinstance(field, UUIDField):
                 self.assertTrue(isinstance(val, uuid.UUID), val)
             if isinstance(field, FilePathField):
                 self.assertTrue(isinstance(val, str), val)
                 self.assertTrue(os.path.exists(val), val)
             if isinstance(field, ImageField):
                 beg = b'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a'
                 full_path = os.path.join(settings.MEDIA_ROOT, val.name)
                 img = val.file.read()
                 self.assertTrue(full_path not in files,
                                 val.name + " shouldnt't already exist")
                 self.assertTrue(os.path.exists(full_path))
                 self.assertTrue(isinstance(val, ImageFieldFile), val)
                 self.assertTrue(val.name.startswith(field.upload_to))
                 self.assertTrue(isinstance(val.field, ImageField))
                 self.assertTrue(isinstance(img, str))
                 self.assertTrue(img.startswith(beg))
                 self.assertTrue(val.name.endswith('.png'))
             if isinstance(field, FileField):
                 content = val.file.read()
                 full_path = os.path.join(settings.MEDIA_ROOT, val.name)
                 self.assertTrue(isinstance(val, FieldFile), val)
                 self.assertTrue(isinstance(val.field, FileField))
                 self.assertTrue(full_path not in files,
                                 val.name + " shouldnt't already exist")
                 self.assertTrue(os.path.exists(full_path))
                 self.assertTrue(val.name.startswith(field.upload_to))
                 self.assertTrue(isinstance(content, str))
                 if not isinstance(field, ImageField):
                     text_re = r'^(?:(?:\w+\s?)+\.\s?)+$'
                     self.assertRegexpMatches(content, text_re, content)
                     self.assertTrue(val.name.endswith('.txt'))
             if isinstance(field, BinaryField):
                 self.assertTrue(isinstance(val, buffer), val)
示例#7
0
 def test(self):
     fields = list_of_fields(AllFieldsModel)
     present_types = list(map(lambda field: field.__class__, fields))
     field_types = [BigIntegerField, BooleanField, CharField,
                    CommaSeparatedIntegerField, DateField, DateTimeField,
                    DecimalField, DurationField, EmailField, FloatField,
                    GenericIPAddressField, IntegerField, NullBooleanField,
                    PositiveIntegerField, PositiveSmallIntegerField,
                    SmallIntegerField, TextField, TimeField]
     self.assertFalse(set(field_types) - set(present_types),
                      "All types should be present." +
                      str(set(field_types) - set(present_types)))
     for field in fields:
         sample_siz = 10
         values = generate_random_values(field, sample_siz)
         self.assertLessEqual(len(values), sample_siz)
         self.assertGreaterEqual(len(values), 1)
         for val in values:
             if isinstance(field, IntegerField):
                 self.assertTrue(isinstance(val, int), val)
             if isinstance(field, EmailField):
                 self.assertTrue(isinstance(val, str), val)
                 email_reg = r'^\w+(?:\.\w+)*@(?:[A-Za-z0-9]+\.)+[A-Za-z]+$'
                 self.assertRegexpMatches(val, email_reg, val)
             if isinstance(field, BooleanField):
                 self.assertTrue(isinstance(val, bool), val)
             if isinstance(field, CharField):
                 self.assertTrue(isinstance(val, str), val)
                 self.assertLessEqual(len(val), field.max_length, val)
             if isinstance(field, CommaSeparatedIntegerField):
                 self.assertTrue(isinstance(val, str), val)
                 comma_sep_int_re = r'^\d{1,3}(?:,\d{3})*$'
                 self.assertRegexpMatches(val, comma_sep_int_re, val)
             if isinstance(field, DateField):
                 self.assertTrue(isinstance(val, datetime.date), val)
             if isinstance(field, DateTimeField):
                 self.assertTrue(isinstance(val, datetime.datetime), val)
             if isinstance(field, DecimalField):
                 self.assertTrue(isinstance(val, Decimal), val)
             if isinstance(field, FloatField):
                 self.assertTrue(isinstance(val, float), val)
             if isinstance(field, GenericIPAddressField):
                 self.assertTrue(isinstance(val, str), val)
                 ip_regex = r'^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$'
                 self.assertRegexpMatches(val, ip_regex, val)
             if isinstance(field, PositiveIntegerField):
                 self.assertTrue(isinstance(val, int), val)
                 self.assertLessEqual(val, 2147483647, val)
                 self.assertGreaterEqual(val, 0, val)
             if isinstance(field, PositiveSmallIntegerField):
                 self.assertTrue(isinstance(val, int), val)
                 self.assertLessEqual(val, 32767, val)
                 self.assertGreaterEqual(val, 0, val)
             if isinstance(field, SmallIntegerField):
                 self.assertTrue(isinstance(val, int), val)
                 self.assertLessEqual(val, 32767, val)
                 self.assertGreaterEqual(val, -32768, val)
             if isinstance(field, TimeField):
                 self.assertTrue(isinstance(val, datetime.time), val)
             if isinstance(field, TextField):
                 self.assertTrue(isinstance(val, str), val)
                 self.assertLessEqual(len(val), field.max_length)
                 text_re = r'^(?:(?:\w+\s?)+\.\s?)+$'
                 self.assertRegexpMatches(val, text_re, val)
             if isinstance(field, DurationField):
                 self.assertTrue(isinstance(val, datetime.timedelta), val)
             if isinstance(field, SlugField):
                 self.assertTrue(isinstance(val, str), val)
                 slug_re = r'^[a-zA-Z0-9_\-]+$'
                 self.assertRegexpMatches(val, slug_re, val)
             if isinstance(field, URLField):
                 url_re = r'^(?:http|ftp|https)://(?:[a-z0-9_\-]+\.?)+/?'
                 url_re += r'(?:/[a-z0-9_\-]+)*/?$'
                 self.assertTrue(isinstance(val, str), val)
                 self.assertRegexpMatches(val, url_re, val)
             if isinstance(field, UUIDField):
                 self.assertTrue(isinstance(val, uuid.UUID), val)
             if isinstance(field, FilePathField):
                 self.assertTrue(isinstance(val, str), val)
                 self.assertTrue(os.path.exists(val), val)