desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'TimeFields can parse dates in the default format'
| def test_timeField(self):
| f = forms.TimeField()
self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
result = f.clean('13:30:05')
self.assertEqual(result, time(13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:05')
result = f.clean('13:30')
self.assertEqual(result, time(13, 30, 0))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:00')
|
'Localized TimeFields in a non-localized environment act as unlocalized widgets'
| def test_localized_timeField(self):
| f = forms.TimeField()
self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
result = f.clean('13:30:05')
self.assertEqual(result, time(13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:05')
result = f.clean('13:30')
self.assertEqual(result, time(13, 30, 0))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:00')
|
'TimeFields with manually specified input formats can accept those formats'
| def test_timeField_with_inputformat(self):
| f = forms.TimeField(input_formats=['%I:%M:%S %p', '%I:%M %p'])
self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
result = f.clean('1:30:05 PM')
self.assertEqual(result, time(13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:05')
result = f.clean('1:30 PM')
self.assertEqual(result, time(13, 30, 0))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:00')
|
'Localized TimeFields with manually specified input formats can accept those formats'
| def test_localized_timeField_with_inputformat(self):
| f = forms.TimeField(input_formats=['%I:%M:%S %p', '%I:%M %p'], localize=True)
self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
result = f.clean('1:30:05 PM')
self.assertEqual(result, time(13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:05')
result = f.clean('1:30 PM')
self.assertEqual(result, time(13, 30, 0))
text = f.widget._format_value(result)
self.assertEqual(text, '13:30:00')
|
'DateFields can parse dates in the default format'
| def test_dateField(self):
| f = forms.DateField()
self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
self.assertEqual(f.clean('2010-12-21'), date(2010, 12, 21))
result = f.clean('21.12.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('21.12.10')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'Localized DateFields act as unlocalized widgets'
| def test_localized_dateField(self):
| f = forms.DateField(localize=True)
self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
result = f.clean('21.12.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('21.12.10')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'DateFields with manually specified input formats can accept those formats'
| def test_dateField_with_inputformat(self):
| f = forms.DateField(input_formats=['%m.%d.%Y', '%m-%d-%Y'])
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
result = f.clean('12.21.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('12-21-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'Localized DateFields with manually specified input formats can accept those formats'
| def test_localized_dateField_with_inputformat(self):
| f = forms.DateField(input_formats=['%m.%d.%Y', '%m-%d-%Y'], localize=True)
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
result = f.clean('12.21.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('12-21-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'DateFields can parse dates in the default format'
| def test_dateField(self):
| f = forms.DateField()
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
result = f.clean('21.12.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('21-12-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'Localized DateFields act as unlocalized widgets'
| def test_localized_dateField(self):
| f = forms.DateField(localize=True)
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
result = f.clean('21.12.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('21-12-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'DateFields with manually specified input formats can accept those formats'
| def test_dateField_with_inputformat(self):
| f = forms.DateField(input_formats=['%m.%d.%Y', '%m-%d-%Y'])
self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
result = f.clean('12.21.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('12-21-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'Localized DateFields with manually specified input formats can accept those formats'
| def test_localized_dateField_with_inputformat(self):
| f = forms.DateField(input_formats=['%m.%d.%Y', '%m-%d-%Y'], localize=True)
self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
result = f.clean('12.21.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
result = f.clean('12-21-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010')
|
'DateFields can parse dates in the default format'
| def test_dateField(self):
| f = forms.DateField()
self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
result = f.clean('2010-12-21')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
result = f.clean('12/21/2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
|
'Localized DateFields in a non-localized environment act as unlocalized widgets'
| def test_localized_dateField(self):
| f = forms.DateField()
self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
result = f.clean('2010-12-21')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
result = f.clean('12/21/2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
|
'DateFields with manually specified input formats can accept those formats'
| def test_dateField_with_inputformat(self):
| f = forms.DateField(input_formats=['%d.%m.%Y', '%d-%m-%Y'])
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
result = f.clean('21.12.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
result = f.clean('21-12-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
|
'Localized DateFields with manually specified input formats can accept those formats'
| def test_localized_dateField_with_inputformat(self):
| f = forms.DateField(input_formats=['%d.%m.%Y', '%d-%m-%Y'], localize=True)
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
result = f.clean('21.12.2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
result = f.clean('21-12-2010')
self.assertEqual(result, date(2010, 12, 21))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21')
|
'DateTimeFields can parse dates in the default format'
| def test_dateTimeField(self):
| f = forms.DateTimeField()
self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
self.assertEqual(f.clean('2010-12-21 13:30:05'), datetime(2010, 12, 21, 13, 30, 5))
result = f.clean('21.12.2010 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:05')
result = f.clean('21.12.2010 13:30')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:00')
|
'Localized DateTimeFields act as unlocalized widgets'
| def test_localized_dateTimeField(self):
| f = forms.DateTimeField(localize=True)
self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
result = f.clean('21.12.2010 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:05')
result = f.clean('21.12.2010 13:30')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:00')
|
'DateTimeFields with manually specified input formats can accept those formats'
| def test_dateTimeField_with_inputformat(self):
| f = forms.DateTimeField(input_formats=['%H.%M.%S %m.%d.%Y', '%H.%M %m-%d-%Y'])
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05 13:30:05')
self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
result = f.clean('13.30.05 12.21.2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:05')
result = f.clean('13.30 12-21-2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:00')
|
'Localized DateTimeFields with manually specified input formats can accept those formats'
| def test_localized_dateTimeField_with_inputformat(self):
| f = forms.DateTimeField(input_formats=['%H.%M.%S %m.%d.%Y', '%H.%M %m-%d-%Y'], localize=True)
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
result = f.clean('13.30.05 12.21.2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:05')
result = f.clean('13.30 12-21-2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '21.12.2010 13:30:00')
|
'DateTimeFields can parse dates in the default format'
| def test_dateTimeField(self):
| f = forms.DateTimeField()
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
result = f.clean('1:30:05 PM 21/12/2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:05 PM 21/12/2010')
result = f.clean('1:30 PM 21-12-2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:00 PM 21/12/2010')
|
'Localized DateTimeFields act as unlocalized widgets'
| def test_localized_dateTimeField(self):
| f = forms.DateTimeField(localize=True)
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
result = f.clean('1:30:05 PM 21/12/2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:05 PM 21/12/2010')
result = f.clean('1:30 PM 21-12-2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:00 PM 21/12/2010')
|
'DateTimeFields with manually specified input formats can accept those formats'
| def test_dateTimeField_with_inputformat(self):
| f = forms.DateTimeField(input_formats=['%m.%d.%Y %H:%M:%S', '%m-%d-%Y %H:%M'])
self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
result = f.clean('12.21.2010 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:05 PM 21/12/2010')
result = f.clean('12-21-2010 13:30')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:00 PM 21/12/2010')
|
'Localized DateTimeFields with manually specified input formats can accept those formats'
| def test_localized_dateTimeField_with_inputformat(self):
| f = forms.DateTimeField(input_formats=['%m.%d.%Y %H:%M:%S', '%m-%d-%Y %H:%M'], localize=True)
self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
result = f.clean('12.21.2010 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:05 PM 21/12/2010')
result = f.clean('12-21-2010 13:30')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '01:30:00 PM 21/12/2010')
|
'DateTimeFields can parse dates in the default format'
| def test_dateTimeField(self):
| f = forms.DateTimeField()
self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
result = f.clean('2010-12-21 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:05')
result = f.clean('12/21/2010 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:05')
|
'Localized DateTimeFields in a non-localized environment act as unlocalized widgets'
| def test_localized_dateTimeField(self):
| f = forms.DateTimeField()
self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
result = f.clean('2010-12-21 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:05')
result = f.clean('12/21/2010 13:30:05')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:05')
|
'DateTimeFields with manually specified input formats can accept those formats'
| def test_dateTimeField_with_inputformat(self):
| f = forms.DateTimeField(input_formats=['%I:%M:%S %p %d.%m.%Y', '%I:%M %p %d-%m-%Y'])
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
result = f.clean('1:30:05 PM 21.12.2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:05')
result = f.clean('1:30 PM 21-12-2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:00')
|
'Localized DateTimeFields with manually specified input formats can accept those formats'
| def test_localized_dateTimeField_with_inputformat(self):
| f = forms.DateTimeField(input_formats=['%I:%M:%S %p %d.%m.%Y', '%I:%M %p %d-%m-%Y'], localize=True)
self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
result = f.clean('1:30:05 PM 21.12.2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30, 5))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:05')
result = f.clean('1:30 PM 21-12-2010')
self.assertEqual(result, datetime(2010, 12, 21, 13, 30))
text = f.widget._format_value(result)
self.assertEqual(text, '2010-12-21 13:30:00')
|
'Returns the paths for any external backend packages.'
| def _ext_backend_paths(self):
| paths = []
first_package_re = re.compile(u'(^[^\\.]+)\\.')
for backend in settings.DATABASES.values():
result = first_package_re.findall(backend[u'ENGINE'])
if (result and (result != u'django')):
backend_pkg = __import__(result[0])
backend_dir = os.path.dirname(backend_pkg.__file__)
paths.append(os.path.dirname(backend_dir))
return paths
|
'Utility assertion: assert that the given stream is empty'
| def assertNoOutput(self, stream):
| self.assertEqual(len(stream), 0, (u"Stream should be empty: actually contains '%s'" % stream))
|
'Utility assertion: assert that the given message exists in the output'
| def assertOutput(self, stream, msg):
| stream = force_text(stream)
self.assertTrue((msg in stream), (u"'%s' does not match actual output text '%s'" % (msg, stream)))
|
'Utility assertion: assert that the given message doesn\'t exist in the output'
| def assertNotInOutput(self, stream, msg):
| stream = force_text(stream)
self.assertFalse((msg in stream), (u"'%s' matches actual output text '%s'" % (msg, stream)))
|
'no settings: django-admin builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'settings are not configured')
|
'no settings: django-admin builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'no settings: django-admin builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'default: django-admin builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'settings are not configured')
|
'default: django-admin builtin commands succeed if settings are provided as argument'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'default: django-admin builtin commands succeed if settings are provided in the environment'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'default: django-admin builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'default: django-admin builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'default: django-admin can\'t execute user commands if it isn\'t provided settings'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'default: django-admin can execute user commands if settings are provided as argument'
| def test_custom_command_with_settings(self):
| args = [u'noargs_command', u'--settings=regressiontests.settings']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'default: django-admin can execute user commands if settings are provided in environment'
| def test_custom_command_with_environment(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'fulldefault: django-admin builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'settings are not configured')
|
'fulldefault: django-admin builtin commands succeed if a settings file is provided'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'fulldefault: django-admin builtin commands succeed if the environment contains settings'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'fulldefault: django-admin builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'fulldefault: django-admin builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'fulldefault: django-admin can\'t execute user commands unless settings are provided'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'fulldefault: django-admin can execute user commands if settings are provided as argument'
| def test_custom_command_with_settings(self):
| args = [u'noargs_command', u'--settings=regressiontests.settings']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'fulldefault: django-admin can execute user commands if settings are provided in environment'
| def test_custom_command_with_environment(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'minimal: django-admin builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'settings are not configured')
|
'minimal: django-admin builtin commands fail if settings are provided as argument'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'App with label admin_scripts could not be found')
|
'minimal: django-admin builtin commands fail if settings are provided in the environment'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.assertNoOutput(out)
self.assertOutput(err, u'App with label admin_scripts could not be found')
|
'minimal: django-admin builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'minimal: django-admin builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'minimal: django-admin can\'t execute user commands unless settings are provided'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'minimal: django-admin can\'t execute user commands, even if settings are provided as argument'
| def test_custom_command_with_settings(self):
| args = [u'noargs_command', u'--settings=regressiontests.settings']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'minimal: django-admin can\'t execute user commands, even if settings are provided in environment'
| def test_custom_command_with_environment(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'alternate: django-admin builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'settings are not configured')
|
'alternate: django-admin builtin commands succeed if settings are provided as argument'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.alternate_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'alternate: django-admin builtin commands succeed if settings are provided in the environment'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'regressiontests.alternate_settings')
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'alternate: django-admin builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'alternate: django-admin builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'alternate: django-admin can\'t execute user commands unless settings are provided'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'alternate: django-admin can execute user commands if settings are provided as argument'
| def test_custom_command_with_settings(self):
| args = [u'noargs_command', u'--settings=regressiontests.alternate_settings']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'alternate: django-admin can execute user commands if settings are provided in environment'
| def test_custom_command_with_environment(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args, u'regressiontests.alternate_settings')
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'alternate: django-admin builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'settings are not configured')
|
'alternate: django-admin builtin commands succeed if settings are provided as argument'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.alternate_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'alternate: django-admin builtin commands succeed if settings are provided in the environment'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'regressiontests.alternate_settings')
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'alternate: django-admin builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'alternate: django-admin builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'alternate: django-admin can\'t execute user commands unless settings are provided'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'alternate: django-admin can execute user commands if settings are provided as argument'
| def test_custom_command_with_settings(self):
| args = [u'noargs_command', u'--settings=regressiontests.alternate_settings']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'alternate: django-admin can execute user commands if settings are provided in environment'
| def test_custom_command_with_environment(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args, u'regressiontests.alternate_settings')
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'directory: startapp creates the correct directory'
| def test_setup_environ(self):
| args = [u'startapp', u'settings_test']
app_path = os.path.join(test_dir, u'settings_test')
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.addCleanup(shutil.rmtree, app_path)
self.assertNoOutput(err)
self.assertTrue(os.path.exists(app_path))
|
'directory: startapp creates the correct directory with a custom template'
| def test_setup_environ_custom_template(self):
| template_path = os.path.join(test_dir, u'admin_scripts', u'custom_templates', u'app_template')
args = [u'startapp', u'--template', template_path, u'custom_settings_test']
app_path = os.path.join(test_dir, u'custom_settings_test')
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.addCleanup(shutil.rmtree, app_path)
self.assertNoOutput(err)
self.assertTrue(os.path.exists(app_path))
self.assertTrue(os.path.exists(os.path.join(app_path, u'api.py')))
|
'directory: django-admin builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u'settings are not configured')
|
'directory: django-admin builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'directory: django-admin builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'directory: django-admin can\'t execute user commands unless settings are provided'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Unknown command: 'noargs_command'")
|
'directory: django-admin builtin commands succeed if settings are provided as argument'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.settings', u'admin_scripts']
(out, err) = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'directory: django-admin builtin commands succeed if settings are provided in the environment'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_django_admin(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'no settings: manage.py builtin commands fail with an error when no settings provided'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'regressiontests.settings'")
|
'no settings: manage.py builtin commands fail if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'no settings: manage.py builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'default: manage.py builtin commands succeed when default settings are appropriate'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'default: manage.py builtin commands succeed if settings are provided as argument'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.settings', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'default: manage.py builtin commands succeed if settings are provided in the environment'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'default: manage.py builtin commands succeed if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'default: manage.py builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'default: manage.py can execute user commands when default settings are appropriate'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'default: manage.py can execute user commands when settings are provided as argument'
| def test_custom_command_with_settings(self):
| args = [u'noargs_command', u'--settings=regressiontests.settings']
(out, err) = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'default: manage.py can execute user commands when settings are provided in environment'
| def test_custom_command_with_environment(self):
| args = [u'noargs_command']
(out, err) = self.run_manage(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
'fulldefault: manage.py builtin commands succeed when default settings are appropriate'
| def test_builtin_command(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'fulldefault: manage.py builtin commands succeed if settings are provided as argument'
| def test_builtin_with_settings(self):
| args = [u'sqlall', u'--settings=regressiontests.settings', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'fulldefault: manage.py builtin commands succeed if settings are provided in the environment'
| def test_builtin_with_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args, u'regressiontests.settings')
self.assertNoOutput(err)
self.assertOutput(out, u'CREATE TABLE')
|
'fulldefault: manage.py builtin commands succeed if settings file (from argument) doesn\'t exist'
| def test_builtin_with_bad_settings(self):
| args = [u'sqlall', u'--settings=bad_settings', u'admin_scripts']
(out, err) = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'fulldefault: manage.py builtin commands fail if settings file (from environment) doesn\'t exist'
| def test_builtin_with_bad_environment(self):
| args = [u'sqlall', u'admin_scripts']
(out, err) = self.run_manage(args, u'bad_settings')
self.assertNoOutput(out)
self.assertOutput(err, u"Could not import settings 'bad_settings'")
|
'fulldefault: manage.py can execute user commands when default settings are appropriate'
| def test_custom_command(self):
| args = [u'noargs_command']
(out, err) = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, u'EXECUTE:NoArgsCommand')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.