def test_sync_print(self, get_tags):
get_tags.side_effect = self._get_tags
io = StringIO()
call_command('syncnextcloudreleases',
'--oldest-supported=11.0.0',
'--print',
stdout=io)
expected = '\n'.join([
'12.0.5',
'12.0.4',
'12.0.3',
'12.0.2',
'12.0.1',
'12.0.0',
'11.0.7',
'11.0.6',
'11.0.5',
'11.0.4',
'11.0.3',
'11.0.2',
'11.0.1',
'11.0.0',
]) + '\n'
self.assertEquals(0, NextcloudRelease.objects.count())
io.seek(0)
self.assertEquals(expected, io.read())
def test_sync_print(self, get_tags):
get_tags.side_effect = self._get_tags
io = StringIO()
call_command('syncnextcloudreleases', '--oldest-supported=11.0.0',
'--print', stdout=io)
expected = '\n'.join([
'12.0.5',
'12.0.4',
'12.0.3',
'12.0.2',
'12.0.1',
'12.0.0',
'11.0.7',
'11.0.6',
'11.0.5',
'11.0.4',
'11.0.3',
'11.0.2',
'11.0.1',
'11.0.0',
]) + '\n'
self.assertEquals(0, NextcloudRelease.objects.count())
io.seek(0)
self.assertEquals(expected, io.read())
def test_logging(self):
output = StringIO()
logging_view = decorate(log("Got a request", out=output), string_view)
self.assertEqual("Hello World", logging_view(self.get_req))
output.seek(0)
self.assertEqual("Got a request\n", output.read())
def test_logging(self):
output = StringIO()
logging_view = decorate(log("Got a request", out=output), string_view)
self.assertEqual("Hello World", logging_view(self.get_req))
output.seek(0)
self.assertEqual("Got a request\n", output.read())
def test_figure(self):
# http://stackoverflow.com/a/2473445/1694979
imgfile = StringIO(
'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,'
'\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
imgfile.name = 'test_img_file.gif'
self.q.figure.save('image', ContentFile(imgfile.read()))
self.assertIsInstance(self.q.figure, ImageFieldFile)
def import_from_file(self, csv_file):
"""
csv_file should be encoded in utf-8
"""
if PY3:
csv_file = StringIO(csv_file.read().decode('utf-8'))
reader = csv.DictReader(csv_file)
for row in reader:
self.import_row(row)
def test_figure(self):
# http://stackoverflow.com/a/2473445/1694979
imgfile = StringIO(
'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,'
'\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
imgfile.name = 'test_img_file.gif'
self.q.figure.save('image', ContentFile(imgfile.read()))
self.assertIsInstance(self.q.figure, ImageFieldFile)
def import_from_file(self, csv_file):
"""
csv_file should be encoded in utf-8
"""
if PY3:
csv_file = StringIO(csv_file.read().decode('utf-8'))
reader = csv.DictReader(csv_file)
for row in reader:
self.import_row(row)
def test_obtain_token_command_should_produce_valid_token(monkeypatch, user):
output = StringIO()
monkeypatch.setattr(settings, "DEBUG", True)
call_command('obtain_token', str(user.pk), stdout=output)
output.seek(0)
printed_token = output.read()
payload = JSONWebTokenAuthentication.jwt_decode_token(
printed_token.strip().encode())
assert payload['user_id'] == user.pk
def test_invalid_tenant_user_model_format(self):
stream = StringIO()
handler = logging.StreamHandler(stream)
logger.addHandler(handler)
with self.settings(TENANCY_TENANT_MODEL='invalid'):
pass
logger.removeHandler(handler)
stream.seek(0)
self.assertIn(
"TENANCY_TENANT_MODEL must be of the form 'app_label.model_name'",
stream.read())
def test_image_in_question(self):
imgfile = StringIO(
'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,'
'\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
imgfile.name = 'test_img_file.gif'
self.question1.figure.save('image', ContentFile(imgfile.read()))
response = self.client.get('/tq1/take/')
self.assertContains(response, '<img src=')
self.assertContains(response, 'alt="' + str(self.question1.content))
def load_fixtures(fixtures):
stream = StringIO()
error_stream = StringIO()
call_command(
"loaddata",
*fixtures,
**{"stdout": stream, "stderr": error_stream, "ignore": True, "database": DEFAULT_DB_ALIAS, "verbosity": 1}
)
stream.seek(0)
result = stream.read()
return int(re.match(r"Installed\s([0-9]+)\s.*", result).groups()[0])
class DebugSQLTextTestResult(unittest.TextTestResult):
def __init__(self, stream, descriptions, verbosity):
self.logger = logging.getLogger('django.db.backends')
self.logger.setLevel(logging.DEBUG)
super(DebugSQLTextTestResult, self).__init__(stream, descriptions,
verbosity)
def startTest(self, test):
self.debug_sql_stream = StringIO()
self.handler = logging.StreamHandler(self.debug_sql_stream)
self.logger.addHandler(self.handler)
super(DebugSQLTextTestResult, self).startTest(test)
def stopTest(self, test):
super(DebugSQLTextTestResult, self).stopTest(test)
self.logger.removeHandler(self.handler)
if self.showAll:
self.debug_sql_stream.seek(0)
self.stream.write(self.debug_sql_stream.read())
self.stream.writeln(self.separator2)
def addError(self, test, err):
super(DebugSQLTextTestResult, self).addError(test, err)
self.debug_sql_stream.seek(0)
self.errors[-1] = self.errors[-1] + (self.debug_sql_stream.read(), )
def addFailure(self, test, err):
super(DebugSQLTextTestResult, self).addFailure(test, err)
self.debug_sql_stream.seek(0)
self.failures[-1] = self.failures[-1] + (
self.debug_sql_stream.read(), )
def printErrorList(self, flavour, errors):
for test, err, sql_debug in errors:
self.stream.writeln(self.separator1)
self.stream.writeln("%s: %s" %
(flavour, self.getDescription(test)))
self.stream.writeln(self.separator2)
self.stream.writeln("%s" % err)
self.stream.writeln(self.separator2)
self.stream.writeln("%s" % sql_debug)
def test_invalid_tenant_user_model_format(self):
stream = StringIO()
handler = logging.StreamHandler(stream)
logger.addHandler(handler)
with self.settings(TENANCY_TENANT_MODEL='invalid'):
pass
logger.removeHandler(handler)
stream.seek(0)
self.assertIn(
"TENANCY_TENANT_MODEL must be of the form 'app_label.model_name'",
stream.read()
)
def test_image_in_question(self):
imgfile = StringIO(
'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,'
'\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
imgfile.name = 'test_img_file.gif'
self.question1.figure.save('image', ContentFile(imgfile.read()))
response = self.client.get('/tq1/take/')
self.assertContains(response, '<img src=')
self.assertContains(response,
'alt="' + str(self.question1.content))
def load_fixtures(fixtures):
stream = StringIO()
error_stream = StringIO()
call_command('loaddata', *fixtures, **{
'stdout': stream,
'stderr': error_stream,
'ignore': True,
'database': DEFAULT_DB_ALIAS,
'verbosity': 1
})
stream.seek(0)
result = stream.read()
return int(re.match(r'Installed\s([0-9]+)\s.*', result).groups()[0])
def load_fixtures(fixtures):
stream = StringIO()
error_stream = StringIO()
call_command('loaddata', *fixtures, **{
'stdout': stream,
'stderr': error_stream,
'ignore': True,
'database': DEFAULT_DB_ALIAS,
'verbosity': 1
})
stream.seek(0)
result = stream.read()
return int(re.match(r'Installed\s([0-9]+)\s.*', result).groups()[0])
class DebugSQLTextTestResult(unittest.TextTestResult):
def __init__(self, stream, descriptions, verbosity):
self.logger = logging.getLogger('django.db.backends')
self.logger.setLevel(logging.DEBUG)
super(DebugSQLTextTestResult, self).__init__(stream, descriptions, verbosity)
def startTest(self, test):
self.debug_sql_stream = StringIO()
self.handler = logging.StreamHandler(self.debug_sql_stream)
self.logger.addHandler(self.handler)
super(DebugSQLTextTestResult, self).startTest(test)
def stopTest(self, test):
super(DebugSQLTextTestResult, self).stopTest(test)
self.logger.removeHandler(self.handler)
if self.showAll:
self.debug_sql_stream.seek(0)
self.stream.write(self.debug_sql_stream.read())
self.stream.writeln(self.separator2)
def addError(self, test, err):
super(DebugSQLTextTestResult, self).addError(test, err)
self.debug_sql_stream.seek(0)
self.errors[-1] = self.errors[-1] + (self.debug_sql_stream.read(),)
def addFailure(self, test, err):
super(DebugSQLTextTestResult, self).addFailure(test, err)
self.debug_sql_stream.seek(0)
self.failures[-1] = self.failures[-1] + (self.debug_sql_stream.read(),)
def printErrorList(self, flavour, errors):
for test, err, sql_debug in errors:
self.stream.writeln(self.separator1)
self.stream.writeln("%s: %s" % (flavour, self.getDescription(test)))
self.stream.writeln(self.separator2)
self.stream.writeln("%s" % err)
self.stream.writeln(self.separator2)
self.stream.writeln("%s" % sql_debug)
class InvalidModelTestCase(unittest.TestCase):
"""Import an appliation with invalid models and test the exceptions."""
def setUp(self):
# Make sure sys.stdout is not a tty so that we get errors without
# coloring attached (makes matching the results easier). We restore
# sys.stderr afterwards.
self.old_stdout = sys.stdout
self.stdout = StringIO()
sys.stdout = self.stdout
# This test adds dummy applications to the app cache. These
# need to be removed in order to prevent bad interactions
# with the flush operation in other tests.
self.old_app_models = copy.deepcopy(cache.app_models)
self.old_app_store = copy.deepcopy(cache.app_store)
def tearDown(self):
cache.app_models = self.old_app_models
cache.app_store = self.old_app_store
cache._get_models_cache = {}
sys.stdout = self.old_stdout
# Technically, this isn't an override -- TEST_SWAPPED_MODEL must be
# set to *something* in order for the test to work. However, it's
# easier to set this up as an override than to require every developer
# to specify a value in their test settings.
@override_settings(
TEST_SWAPPED_MODEL='invalid_models.ReplacementModel',
TEST_SWAPPED_MODEL_BAD_VALUE='not-a-model',
TEST_SWAPPED_MODEL_BAD_MODEL='not_an_app.Target',
)
def test_invalid_models(self):
try:
module = load_app("modeltests.invalid_models.invalid_models")
except Exception:
self.fail('Unable to load invalid model module')
get_validation_errors(self.stdout, module)
self.stdout.seek(0)
error_log = self.stdout.read()
actual = error_log.split('\n')
expected = module.model_errors.split('\n')
unexpected = [err for err in actual if err not in expected]
missing = [err for err in expected if err not in actual]
self.assertFalse(unexpected, "Unexpected Errors: " + '\n'.join(unexpected))
self.assertFalse(missing, "Missing Errors: " + '\n'.join(missing))
class InvalidModelTestCase(unittest.TestCase):
"""Import an appliation with invalid models and test the exceptions."""
def setUp(self):
# Make sure sys.stdout is not a tty so that we get errors without
# coloring attached (makes matching the results easier). We restore
# sys.stderr afterwards.
self.old_stdout = sys.stdout
self.stdout = StringIO()
sys.stdout = self.stdout
# This test adds dummy applications to the app cache. These
# need to be removed in order to prevent bad interactions
# with the flush operation in other tests.
self.old_app_models = copy.deepcopy(cache.app_models)
self.old_app_store = copy.deepcopy(cache.app_store)
def tearDown(self):
cache.app_models = self.old_app_models
cache.app_store = self.old_app_store
cache._get_models_cache = {}
sys.stdout = self.old_stdout
# Technically, this isn't an override -- TEST_SWAPPED_MODEL must be
# set to *something* in order for the test to work. However, it's
# easier to set this up as an override than to require every developer
# to specify a value in their test settings.
@override_settings(
TEST_SWAPPED_MODEL='invalid_models.Target',
TEST_SWAPPED_MODEL_BAD_VALUE='not-a-model',
TEST_SWAPPED_MODEL_BAD_MODEL='not_an_app.Target',
)
def test_invalid_models(self):
try:
module = load_app("modeltests.invalid_models.invalid_models")
except Exception:
self.fail('Unable to load invalid model module')
get_validation_errors(self.stdout, module)
self.stdout.seek(0)
error_log = self.stdout.read()
actual = error_log.split('\n')
expected = module.model_errors.split('\n')
unexpected = [err for err in actual if err not in expected]
missing = [err for err in expected if err not in actual]
self.assertFalse(unexpected,
"Unexpected Errors: " + '\n'.join(unexpected))
self.assertFalse(missing, "Missing Errors: " + '\n'.join(missing))
def webhook_pull(request, remote='origin'):
if request.method == 'POST':
try:
log = Git().pull(remote)
s = StringIO()
call_command('sync_waliki', stdout=s)
s.seek(0)
r = {'pull': log, 'sync': s.read()}
status_code = 200
except Exception as e:
r = {'error': text_type(e)}
status_code = 500
return HttpResponse(json.dumps(r), status=status_code,
content_type="application/json")
return HttpResponse("POST to %s" % reverse("waliki_webhook_pull", args=(remote,)))
def validate(self, app_config=None, display_num_errors=False):
"""
Validates the given app, raising CommandError for any errors.
If app_config is None, then this will validate all installed apps.
"""
from django.core.management.validation import get_validation_errors
s = StringIO()
num_errors = get_validation_errors(s, app_config)
if num_errors:
s.seek(0)
error_text = s.read()
raise CommandError("One or more models did not validate:\n%s" % error_text)
if display_num_errors:
self.stdout.write("%s error%s found" % (num_errors, '' if num_errors == 1 else 's'))
def validate(self, app=None, display_num_errors=False):
"""
Validates the given app, raising CommandError for any errors.
If app is None, then this will validate all installed apps.
"""
from django.core.management.validation import get_validation_errors
s = StringIO()
num_errors = get_validation_errors(s, app)
if num_errors:
s.seek(0)
error_text = s.read()
raise CommandError("One or more models did not validate:\n%s" % error_text)
if display_num_errors:
self.stdout.write("%s error%s found" % (num_errors, '' if num_errors == 1 else 's'))
def webhook_pull(request, remote='origin'):
if request.method == 'POST':
try:
log = Git().pull(remote)
s = StringIO()
call_command('sync_waliki', stdout=s)
s.seek(0)
r = {'pull': log, 'sync': s.read()}
status_code = 200
except Exception as e:
r = {'error': text_type(e)}
status_code = 500
return HttpResponse(json.dumps(r), status=status_code,
content_type="application/json")
return HttpResponse("POST to %s" % reverse("waliki_webhook_pull", args=(remote,)))
class InvalidModelTestCase(unittest.TestCase):
"""Import an appliation with invalid models and test the exceptions."""
def setUp(self):
# Make sure sys.stdout is not a tty so that we get errors without
# coloring attached (makes matching the results easier). We restore
# sys.stderr afterwards.
self.old_stdout = sys.stdout
self.stdout = StringIO()
sys.stdout = self.stdout
# This test adds dummy applications to the app cache. These
# need to be removed in order to prevent bad interactions
# with the flush operation in other tests.
self.old_app_models = copy.deepcopy(cache.app_models)
self.old_app_store = copy.deepcopy(cache.app_store)
def tearDown(self):
cache.app_models = self.old_app_models
cache.app_store = self.old_app_store
cache._get_models_cache = {}
sys.stdout = self.old_stdout
def test_invalid_models(self):
try:
module = load_app("modeltests.invalid_models.invalid_models")
except Exception:
self.fail('Unable to load invalid model module')
count = get_validation_errors(self.stdout, module)
self.stdout.seek(0)
error_log = self.stdout.read()
actual = error_log.split('\n')
expected = module.model_errors.split('\n')
unexpected = [err for err in actual if err not in expected]
missing = [err for err in expected if err not in actual]
self.assertFalse(unexpected, "Unexpected Errors: " + '\n'.join(unexpected))
self.assertFalse(missing, "Missing Errors: " + '\n'.join(missing))
class BufferedFile(File):
def __init__(self, file_object, mode, name=None):
self.file_object = file_object
self.mode = mode
if 'b' in mode:
self.stream = BytesIO()
else:
self.stream = StringIO()
self.stream_size = 0
def close(self):
self.file_object.close()
self.stream.close()
def read(self, size=None):
if size is None:
size = -1
if size == -1 or size > self.stream_size:
while True:
position = self.stream.tell()
chunk = self._get_file_object_chunk()
if chunk:
self.stream_size += len(chunk)
self.stream.write(chunk)
self.stream.seek(position)
if self.stream_size >= size and size != -1:
break
else:
break
if size:
read_size = min(size, self.stream_size)
self.stream_size -= read_size
else:
read_size = None
return self.stream.read(read_size)
class InvalidModelTestCase(unittest.TestCase):
"""Import an appliation with invalid models and test the exceptions."""
def setUp(self):
# Make sure sys.stdout is not a tty so that we get errors without
# coloring attached (makes matching the results easier). We restore
# sys.stderr afterwards.
self.old_stdout = sys.stdout
self.stdout = StringIO()
sys.stdout = self.stdout
def tearDown(self):
sys.stdout = self.old_stdout
# Technically, this isn't an override -- TEST_SWAPPED_MODEL must be
# set to *something* in order for the test to work. However, it's
# easier to set this up as an override than to require every developer
# to specify a value in their test settings.
@override_settings(
INSTALLED_APPS=['invalid_models_tests.invalid_models'],
TEST_SWAPPED_MODEL='invalid_models.ReplacementModel',
TEST_SWAPPED_MODEL_BAD_VALUE='not-a-model',
TEST_SWAPPED_MODEL_BAD_MODEL='not_an_app.Target',
)
def test_invalid_models(self):
app_config = apps.get_app_config("invalid_models")
get_validation_errors(self.stdout, app_config)
self.stdout.seek(0)
error_log = self.stdout.read()
actual = error_log.split('\n')
expected = app_config.models_module.model_errors.split('\n')
unexpected = [err for err in actual if err not in expected]
missing = [err for err in expected if err not in actual]
self.assertFalse(unexpected, "Unexpected Errors: " + '\n'.join(unexpected))
self.assertFalse(missing, "Missing Errors: " + '\n'.join(missing))
import collections
def test_superuser_creation_prompt(self):
stdout = StringIO()
call_command('createtenant', 'tenant', stdout=stdout, interactive=True)
stdout.seek(0)
self.assertNotIn('Superuser created successfully.', stdout.read())
Tenant.objects.get(name='tenant').delete()
def test_superuser_creation_cancelled_prompt(self):
stdout = StringIO()
call_command('createtenant', 'tenant', stdout=stdout, interactive=True)
stdout.seek(0)
self.assertNotIn('Superuser created successfully.', stdout.read())
Tenant.objects.get(name='tenant').delete()
