def _tests_1_7(self):
"""
Fire up the Django test suite developed for version 1.7 and up
"""
INSTALLED_APPS, settings_test = self.get_custom_settings()
settings.configure(
DEBUG=True,
DATABASES=self.get_database(),
MIDDLEWARE_CLASSES=(
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
),
INSTALLED_APPS=self.INSTALLED_APPS + INSTALLED_APPS + self.apps,
**settings_test
)
try:
# Django <= 1.8
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
except ImportError:
# Django >= 1.8
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
import django
django.setup()
failures = test_runner.run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def setup():
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'
}
}
INSTALLED_APPS = [
'django.contrib.auth',
'django.contrib.contenttypes',
'compat',
'compat.tests.test_app',
]
if django.VERSION < (1, 7):
INSTALLED_APPS.append('compat.tests')
MIDDLEWARE_CLASSES = []
if django.VERSION < (1, 7):
MIDDLEWARE_CLASSES.append('django.middleware.transaction.TransactionMiddleware')
from django.conf import settings
if not settings.configured:
settings.configure(
INSTALLED_APPS=INSTALLED_APPS,
DATABASES=DATABASES,
ROOT_URLCONF='compat.tests.urls',
MIDDLEWARE_CLASSES = MIDDLEWARE_CLASSES, )
def main():
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
if not settings.configured:
settings.configure(
INSTALLED_APPS=('django.contrib.auth', 'django.contrib.contenttypes', APP_NAME),
DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3'}},
ROOT_URLCONF = 'sitetree.tests',
MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES, # Prevents Django 1.7 warning.
TEMPLATE_CONTEXT_PROCESSORS=tuple(global_settings.TEMPLATE_CONTEXT_PROCESSORS) + (
'django.core.context_processors.request',
)
)
try: # Django 1.7 +
from django import setup
setup()
except ImportError:
pass
from django.test.utils import get_runner
runner = get_runner(settings)()
failures = runner.run_tests((APP_NAME,))
sys.exit(failures)
def main():
# Dynamically configure the Django settings with the minimum necessary to
# get Django running tests
settings.configure(
INSTALLED_APPS=[
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.admin',
'django.contrib.sessions',
'django_enumfield',
'django_enumfield.tests',
],
# Django replaces this, but it still wants it. *shrugs*
DATABASE_ENGINE='django.db.backends.sqlite3',
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
}
},
MEDIA_ROOT='/tmp/django_enums/',
MEDIA_PATH='/media/',
ROOT_URLCONF='django_enumfield.tests.urls',
DEBUG=True,
TEMPLATE_DEBUG=True,
)
from django.test.utils import get_runner
test_runner = get_runner(settings)(verbosity=2, interactive=True)
failures = test_runner.run_tests(['django_enumfield'])
sys.exit(failures)
def _tests(self):
settings.configure(
DEBUG = True,
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
SHIBBOLETH_LOGIN_URL = 'https://your_domain.edu/Shibboleth.sso/Login',
SHIBBOLETH_LOGOUT_URL = 'https://your_domain.edu/Shibboleth.sso/Logout',
LOGIN_URL = '/shib/login/',
INSTALLED_APPS = self.INSTALLED_APPS + self.apps,
ROOT_URLCONF = 'shib.urls',
)
try:
django.setup()
except AttributeError:
#before django 1.6 this was not necessary
pass
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def pytest_configure():
global _SETTINGS
try:
import django
from django.conf import settings
settings.configure(POOL_OF_RAMOS=POOL_OF_RAMOS)
django.setup()
_SETTINGS = settings
except ImportError:
try:
import os
os.environ.setdefault('SIMPLE_SETTINGS', 'conftest')
from simple_settings import settings
settings.configure(POOL_OF_RAMOS=POOL_OF_RAMOS)
_SETTINGS = settings
except ImportError:
import ramos
ramos.configure(pools=POOL_OF_RAMOS)
def runtests():
settings.configure(
# App-specific setttings here
)
# settings must be configured for this import to work
from django.test.runner import DiscoverRunner
DiscoverRunner(interactive=False, failfast=False).run_tests(['django_auth_lti'])
def main():
from django.conf import settings
settings.configure(
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'
}
},
INSTALLED_APPS = [
'cache_tagging.django_cache_tagging',
],
MIDDLEWARE_CLASSES = [
'cache_tagging.django_cache_tagging.middleware.TransactionMiddleware',
],
TEST_RUNNER = 'django.test.simple.DjangoTestSuiteRunner',
TEMPLATE_DIRS = [],
DEBUG = True,
TEMPLATE_DEBUG = True,
ROOT_URLCONF = 'runtests',
)
from cache_tagging.django_cache_tagging import autodiscover
autodiscover()
# Run the test suite, including the extra validation tests.
from django.test.utils import get_runner
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=False, failfast=False)
failures = test_runner.run_tests(['django_cache_tagging'])
sys.exit(failures)
def __init__(self, commands, verbose=False, **kwargs):
self._commands = commands
self._parser = argparse.ArgumentParser()
self._verbose = verbose
if not settings.configured:
settings.configure()
self._templates_dir = "%s/templates" % os.path.dirname(__file__)
def run(self):
import django
from django.conf import settings
from django.core.management import call_command
settings.configure(
DATABASES={
'default': {
'NAME': ':memory:',
'ENGINE': 'django.db.backends.sqlite3',
},
},
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'emailengine',
'emailengine.tests',
),
TEMPLATES=[
{
'BACKEND': 'django.template.backends.django.DjangoTemplates', # noqa: E501
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages', # noqa: E501
'django.template.context_processors.request',
],
},
},
],
),
django.setup()
call_command('test', 'emailengine')
def run(self):
from django.conf import settings
settings.configure(DATABASES={'default': {'NAME': ':memory:',
'ENGINE': 'django.db.backends.sqlite3'}},
INSTALLED_APPS=('jsonfield',))
from django.core.management import call_command
call_command('test', 'jsonfield')
def django_email_backend(request):
from django.conf import settings
logger.debug('django_email_backend...')
settings.configure(EMAIL_BACKEND='django.core.mail.backends.filebased.EmailBackend',
EMAIL_FILE_PATH='tmp-emails')
from django.core.mail import get_connection
return get_connection()
def _new_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
settings.configure(
DEBUG=True,
DATABASES={
"default": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": os.path.join(self.DIRNAME, "database.db"),
"USER": "",
"PASSWORD": "",
"HOST": "",
"PORT": "",
}
},
INSTALLED_APPS=self.INSTALLED_APPS + self.apps,
FACEBOOK_REALTIME_VERIFY_TOKEN="EJEgWVcZCyx7NNoKT83xbxrKPy0sQPYZBZCkEZAm31PPoOoHojlTHPhGgZDAA",
ROOT_URLCONF="urlstest",
)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def setup_fake_django():
from django.conf import settings
import os
settings.configure(
TEMPLATE_LOADERS=('django.template.loaders.filesystem.Loader',),
TEMPLATE_DIRS=(os.path.join(os.path.dirname(__file__), '..', 'templates'),),
)
def pytest_configure():
import django
from django.conf import settings
settings.configure(
DEBUG_PROPAGATE_EXCEPTIONS=True,
DATABASES={"default": {"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"}},
SITE_ID=1,
SECRET_KEY="not very secret in tests",
USE_I18N=True,
USE_L10N=True,
STATIC_URL="/static/",
ROOT_URLCONF="tests.urls",
TEMPLATE_LOADERS=(
"django.template.loaders.filesystem.Loader",
"django.template.loaders.app_directories.Loader",
),
MIDDLEWARE_CLASSES=(
"django.middleware.common.CommonMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
),
INSTALLED_APPS=(
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.sites",
"django.contrib.messages",
"django.contrib.staticfiles",
"tests",
),
PASSWORD_HASHERS=("django.contrib.auth.hashers.MD5PasswordHasher",),
)
try:
import oauth_provider # NOQA
import oauth2 # NOQA
except ImportError:
pass
else:
settings.INSTALLED_APPS += ("oauth_provider",)
try:
if django.VERSION >= (1, 8):
# django-oauth2-provider does not support Django1.8
raise ImportError
import provider # NOQA
except ImportError:
pass
else:
settings.INSTALLED_APPS += ("provider", "provider.oauth2")
try:
import django
django.setup()
except AttributeError:
pass
def InitializeTemplates(self):
if not settings.configured:
settings.configure(DEBUG=False, TEMPLATE_DEBUG=False,
TEMPLATE_DIRS=(os.path.abspath(os.path.join(os.path.dirname(__file__),'..','templates')),
self.results_dir,
os.path.join(self.results_dir,"templates"))
)
def main():
current_dir = os.path.dirname(__file__)
app_name = os.path.basename(current_dir)
sys.path.insert(0, os.path.join(current_dir, '..'))
if not settings.configured:
settings.configure(
INSTALLED_APPS=('django.contrib.auth', 'django.contrib.contenttypes', app_name),
DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3'}},
MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES, # Prevents Django 1.7 warning.
ROOT_URLCONF='sitemessage.tests',
STATIC_URL='static/'
)
try: # Django 1.7 +
from django import setup
setup()
except ImportError:
pass
from django.test.utils import get_runner
runner = get_runner(settings)()
failures = runner.run_tests((app_name,))
sys.exit(failures)
def runtests():
if not settings.configured:
# Configure test environment
settings.configure(
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'
}
},
SITE_ID=1,
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'password_session',
),
AUTHENTICATION_BACKENDS = (
'django.contrib.auth.backends.ModelBackend',
),
MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'password_session.middleware.CheckPasswordHash',
),
ROOT_URLCONF = 'password_session.tests.test_urls',
LANGUAGES = (
('en', 'English'),
),
)
failures = call_command('test', 'password_session', interactive=False, failfast=False, verbosity=2)
sys.exit(bool(failures))
def _tests(self):
settings.configure(
DEBUG=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
INSTALLED_APPS=self.INSTALLED_APPS + self.apps,
MIDDLEWARE_CLASSES=self.MIDDLEWARE_CLASSES,
ROOT_URLCONF='helpdesk.tests.urls',
STATIC_URL='/static/',
TEMPLATES=self.TEMPLATES
)
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
django.setup()
failures = test_runner.run_tests(self.apps)
if failures:
sys.exit(failures)
def main():
# Dynamically configure the Django settings with the minimum necessary to
# get Django running tests
settings.configure(
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.admin',
'django.contrib.sessions',
'zerorpc_api',
),
# Django replaces this, but it still wants it. *shrugs*
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': '/tmp/django_login.db',
}
},
MEDIA_ROOT = '/tmp/django_test_media/',
ROOT_URLCONF = '',
DEBUG = True,
TEMPLATE_DEBUG = True,
STRIPE_TEST_SECRET_API_KEY = 'SECRET_API_KEY',
STRIPE_TEST_PUBLIC_API_KEY = 'PUBLIC_API_KEY',
)
#call_command('syncdb')
# Fire off the tests
call_command('test', 'zerorpc_api')
def main():
settings.configure(
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
}
},
ROOT_URLCONF='acme_challenge.urls',
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'acme_challenge',)
)
django.setup()
try:
# Django <= 1.8
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
except ImportError:
# Django >= 1.8
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(['acme_challenge'])
if failures:
sys.exit(failures)
def establish_settings():
'''Sets up the Django settings (in lieu of DJANGO_SETTINGS_MODULE)'''
defaults = dict(
INSTALLED_APPS = ['baseboard', ],
CACHE_BACKEND = "dummy://",
DATABASE_ENGINE = "sqlite3",
DATABASE_NAME = ":memory:",
TEST_DATABASE_CHARSET = 'utf8',
TEST_DATABASE_COLLATION = 'utf8_unicode_ci',
ROOT_URLCONF = 'baseboard.urls',
BASEBOARD_CREDENTIALS = {
'https://foo.basecamphq.com/': ('username1', 'password1')
},
)
import os
__previous_settings_module = os.environ['DJANGO_SETTINGS_MODULE']
os.environ['DJANGO_SETTINGS_MODULE'] = ''
from django.conf import settings
try:
settings.configure(**defaults)
except RuntimeError:
for key, value in defaults.items():
__overriden_settings[key] = value
setattr(settings, key, value)
def pytest_configure():
settings.configure(
ROOT_URLCONF = 'conftest',
MIDDLEWARE_CLASSES = [
'conftest.InjectTestUser'
],
)
def setup(cls, options=None, args=None, **kwargs):
"""Adds Django initialisation
.. warning::
The Django system can only be initialised once, so you can
only ever setup one class that uses DjangoApp as a base. In
practice, subsequent calls to setup will simply ignore the
Django configuration step, ignoring any debug setting and
template directory locations.
This restriction may be removed in future versions as this
area of Django appears to be evolving."""
super(DjangoApp, cls).setup(options, args, **kwargs)
if options:
cls.debug = options.debug
dsettings = cls.settings.setdefault('DjangoApp', {})
template_urls = dsettings.setdefault('template_dirs', ['templates'])
template_paths = []
for t in template_urls:
template_paths.append(cls.resolve_setup_path(t))
if not DjangoApp.configured:
settings.configure(
DEBUG=cls.debug, TEMPLATE_DEBUG=cls.debug,
TEMPLATE_DIRS=template_paths)
django.setup()
DjangoApp.configured = True
else:
logging.warning("DjangoApp: setup ignored for %s" % cls.__name__)
cls.template_dirs = template_paths
def pytest_configure(config):
where_am_i = os.path.dirname(os.path.abspath(__file__))
if not settings.configured:
settings.configure(
DATABASE_ENGINE='sqlite3',
DATABASES={
'default': {
'NAME': ':memory:',
'ENGINE': 'django.db.backends.sqlite3',
'TEST_NAME': ':memory:',
},
},
DATABASE_NAME=':memory:',
TEST_DATABASE_NAME=':memory:',
INSTALLED_APPS=INSTALLED_APPS,
ROOT_URLCONF='',
DEBUG=False,
SITE_ID=1,
BROKER_HOST="localhost",
BROKER_PORT=5672,
BROKER_USER="******",
BROKER_PASSWORD="******",
BROKER_VHOST="/",
SENTRY_ALLOW_ORIGIN='*',
CELERY_ALWAYS_EAGER=True,
TEMPLATE_DEBUG=True,
TEMPLATE_DIRS=[os.path.join(where_am_i, 'tests', 'contrib', 'django', 'templates')],
ALLOWED_HOSTS=['*'],
)
def run_tests(self):
from django.conf import settings
db_engine = os.environ.get('DJANGO_DB_ENGINE', 'sqlite')
if db_engine == 'mysql':
db_settings = {
'ENGINE': 'django.db.backends.mysql',
'NAME': os.environ['DJANGO_DB_NAME'],
'USER': os.environ['DJANGO_DB_USER'],
}
elif db_engine == 'postgres':
db_settings = {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': os.environ['DJANGO_DB_NAME'],
'USER': os.environ['DJANGO_DB_USER'],
}
elif db_engine == 'sqlite':
db_settings = {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
}
else:
raise ValueError("Unknown DB engine: %s" % db_engine)
# Common settings.
settings.configure(
DEBUG=True,
DATABASES={'default': db_settings},
CACHES={'default': {'BACKEND': 'django.core.cache.backends.dummy.DummyCache'}},
INSTALLED_APPS=self.APPS)
import django
import pytest
django.setup()
sys.exit(pytest.main(["tests/"]))
def runtests():
parser = optparse.OptionParser()
parser.add_option('--verbosity', dest='verbosity', default='1')
parser.add_option('--coverage', dest='coverage', default='2')
parser.add_option('--DATABASE_ENGINE', dest='DATABASE_ENGINE',
default='sqlite3')
parser.add_option('--DATABASE_NAME', dest='DATABASE_NAME', default='')
parser.add_option('--DATABASE_USER', dest='DATABASE_USER', default='')
parser.add_option('--DATABASE_PASSWORD', dest='DATABASE_PASSWORD',
default='')
parser.add_option('--DATABASE_HOST', dest='DATABASE_HOST', default='')
parser.add_option('--DATABASE_PORT', dest='DATABASE_PORT', default='')
options, args = parser.parse_args()
dboptions = {}
if options.DATABASE_ENGINE == 'mysql':
dboptions = {
"init_command": "SET storage_engine=INNODB,"
"character_set_connection=utf8,"
"collation_connection=utf8_unicode_ci"}
if not options.DATABASE_NAME and options.DATABASE_ENGINE != 'sqlite3':
options.DATABASE_NAME = 'treebeard'
if not settings.configured:
settings.configure(
DATABASE_ENGINE=options.DATABASE_ENGINE,
DATABASE_NAME=options.DATABASE_NAME,
DATABASE_USER=options.DATABASE_USER,
DATABASE_PASSWORD=options.DATABASE_PASSWORD,
DATABASE_HOST=options.DATABASE_HOST,
DATABASE_PORT=options.DATABASE_PORT,
DATABASE_OPTIONS=dboptions,
INSTALLED_APPS=[
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'treebeard',
'treebeard.tests'])
covlevel = int(options.coverage)
if covlevel:
current_dir = os.path.dirname(os.path.abspath(__file__))
if covlevel == 2:
branch = True
else:
branch = False
cov = coverage.coverage(branch=branch,
include=[current_dir + '/treebeard/*.py'],
omit=[current_dir + '/treebeard/numconv.py',
current_dir + '/treebeard/tests/*'])
cov.load()
cov.start()
if not args:
args = ['tests']
call_command('test', verbosity=options.verbosity, *args)
if covlevel:
cov.stop()
cov.save()
def configure_settings():
"""
Configures settings for manage.py and for run_tests.py.
"""
if not settings.configured:
# Determine the database settings depending on if a test_db var is set in CI mode or not
test_db = os.environ.get('DB', None)
if test_db is None:
db_config = {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'ambition_test',
'USER': '******',
'PASSWORD': '',
'HOST': 'db',
'TEST': {
'CHARSET': 'UTF8',
}
}
elif test_db == 'postgres':
db_config = {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'USER': '******',
'NAME': 'activatable_model',
}
elif test_db == 'sqlite':
db_config = {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': 'activatable_model',
}
else:
raise RuntimeError('Unsupported test DB {0}'.format(test_db))
travis_ci = os.environ.get('TRAVIS_CI', None)
if travis_ci:
db_config.update(
{
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'USER': '******',
'NAME': 'activatable_model',
}
)
settings.configure(
TEST_RUNNER='django_nose.NoseTestSuiteRunner',
NOSE_ARGS=['--nocapture', '--nologcapture', '--verbosity=1'],
MIDDLEWARE_CLASSES={},
DATABASES={
'default': db_config,
},
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'activatable_model',
'activatable_model.tests',
),
ROOT_URLCONF='activatable_model.urls',
DEBUG=False,
)
def runtests():
test_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, test_dir)
settings.configure(
DEBUG=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
}
},
INSTALLED_APPS=('django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'gargoyle',
'experiments',),
ROOT_URLCONF='experiments.urls',
)
from django.test.utils import get_runner
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, failfast=False)
failures = test_runner.run_tests(['experiments.tests', ])
sys.exit(bool(failures))
def create_project():
# Put mezzanine.conf in INSTALLED_APPS so call_command can find
# our command,
settings.configure()
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + ['mezzanine.bin']
argv = sys.argv[:1] + ['mezzanine_project'] + sys.argv[1:]
management.execute_from_command_line(argv)
import django.dispatch
djshutdown = django.dispatch.Signal()
djshutdown.send('system')
sys.exit(0)
signal.signal(signal.SIGINT, sigint_handler)
settings.configure(
DEBUG=True,
SECRET_KEY='CD8FF4C1-7E6C-4E45-922D-C796271F2345',
ROOT_URLCONF=sys.modules[__name__],
SETTINGS_MODULE=
'', # Added to avoid a KeyError during shutdown on the bad template test.
TEMPLATES=[
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'APP_DIRS': True,
'DIRS': [
os.path.join(os.path.dirname(__file__), 'templates'),
]
},
])
def home(request):
title = 'hello'
content = 'Django-Django-Test'
template = loader.get_template('hello.html')
context = {
'title': title,
