def _pre_setup(self):
super(BaseTestCase, self)._pre_setup()
cache.clear()
# Override django-cache-machine caching.base.TIMEOUT because it's
# computed too early, before settings_test.py is imported.
caching.base.TIMEOUT = settings.CACHE_COUNT_TIMEOUT
translation.trans_real.deactivate()
# Django fails to clear this cache.
translation.trans_real._translations = {}
translation.trans_real.activate(settings.LANGUAGE_CODE)
# Make sure the "templates" list in a response is properly updated,
# even though we're using Jinja2 and not the default django template
# engine.
global JINJA_INSTRUMENTED
if not JINJA_INSTRUMENTED:
import jinja2
old_render = jinja2.Template.render
def instrumented_render(self, *args, **kwargs):
context = dict(*args, **kwargs)
test.signals.template_rendered.send(
sender=self, template=self, context=context)
return old_render(self, *args, **kwargs)
jinja2.Template.render = instrumented_render
JINJA_INSTRUMENTED = True
# Reset the prefixer.
default_prefixer()
self.client = self.client_class()
def test_diffable_one_binary_diff(self):
self.helper.extract()
self.change(self.helper.left.dest, 'asd')
cache.clear()
self.helper.select('main.js')
self.helper.left.selected['binary'] = True
assert self.helper.is_binary()
def setUp(self):
from django.core.cache import cache
super(PlaceholderCacheTestCase, self).setUp()
cache.clear()
self.page = create_page(
'en test page', 'nav_playground.html', 'en', published=True)
# Now create and publish as 'de' title
create_title('de', "de test page", self.page)
self.page.publish('de')
self.placeholder = self.page.placeholders.filter(slot="body")[0]
plugin_pool.register_plugin(VaryCacheOnPlugin)
add_plugin(self.placeholder, 'TextPlugin', 'en', body='English')
add_plugin(self.placeholder, 'TextPlugin', 'de', body='Deutsch')
add_plugin(self.placeholder, 'VaryCacheOnPlugin', 'en')
add_plugin(self.placeholder, 'VaryCacheOnPlugin', 'de')
self.en_request = self.get_request('/en/')
self.en_request.current_page = Page.objects.get(pk=self.page.pk)
self.en_us_request = self.get_request('/en/')
self.en_us_request.META['HTTP_COUNTRY_CODE'] = 'US'
self.en_uk_request = self.get_request('/en/')
self.en_uk_request.META['HTTP_COUNTRY_CODE'] = 'UK'
self.de_request = self.get_request('/de/')
self.de_request.current_page = Page.objects.get(pk=self.page.pk)
def test_cached_show_placeholder_sekizai(self):
from django.core.cache import cache
cache.clear()
from cms.test_utils import project
User = get_user_model()
template_dir = os.path.join(os.path.dirname(project.__file__), 'templates', 'alt_plugin_templates',
'show_placeholder')
page = create_page('Test', 'col_two.html', 'en')
placeholder = page.placeholders.all()[0]
add_plugin(placeholder, TextPlugin, 'en', body='HIDDEN')
request = RequestFactory().get('/')
request.user = User()
request.current_page = page
with SettingsOverride(TEMPLATE_DIRS=[template_dir]):
template = Template(
"{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}")
context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
output = template.render(context)
self.assertIn('JAVASCRIPT', output)
context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
output = template.render(context)
self.assertIn('JAVASCRIPT', output)
def setUp(self):
self.email = '*****@*****.**'
self.pw = 'xyz'
self.username = '******'
self.client = Client()
# clear the cache so ratelimiting won't affect these tests
cache.clear()
def setUp(self):
cache.clear()
self.user = utils.create_user()
self.user2 = utils.create_user()
self.category = utils.create_category()
self.topic = utils.create_topic(self.category, user=self.user)
self.topic2 = utils.create_topic(self.category, user=self.user2)
self.topic3 = utils.create_topic(self.category, user=self.user2)
self.poll = TopicPoll.objects.create(topic=self.topic, choice_limit=1)
self.poll_multi = TopicPoll.objects.create(topic=self.topic2, choice_limit=2)
self.poll_choice = TopicPollChoice.objects.create(poll=self.poll, description="op1")
self.poll_choice2 = TopicPollChoice.objects.create(poll=self.poll, description="op2")
self.poll_vote = TopicPollVote.objects.create(user=self.user, choice=self.poll_choice)
self.poll_vote2 = TopicPollVote.objects.create(user=self.user2, choice=self.poll_choice)
self.poll_multi_choice = TopicPollChoice.objects.create(poll=self.poll_multi, description="op1")
self.poll_multi_choice2 = TopicPollChoice.objects.create(poll=self.poll_multi, description="op2")
self.poll_multi_choice3 = TopicPollChoice.objects.create(poll=self.poll_multi, description="op3")
self.poll_multi_vote = TopicPollVote.objects.create(user=self.user, choice=self.poll_multi_choice)
self.poll_multi_vote2 = TopicPollVote.objects.create(user=self.user, choice=self.poll_multi_choice2)
self.poll_multi_vote3 = TopicPollVote.objects.create(user=self.user2, choice=self.poll_multi_choice)
def setUp(self):
cache.clear()
self.user = utils.create_user()
self.category = utils.create_category()
self.topic = utils.create_topic(category=self.category, user=self.user)
self.poll = TopicPoll.objects.create(topic=self.topic)
def setUp(self):
super(BlocklistTest, self).setUp()
self.fx4_url = reverse('blocklist', args=[3, amo.FIREFOX.guid, '4.0'])
self.fx2_url = reverse('blocklist', args=[2, amo.FIREFOX.guid, '2.0'])
self.mobile_url = reverse('blocklist', args=[2, amo.MOBILE.guid, '.9'])
cache.clear()
self.details = BlocklistDetail.objects.create()
def setUp(self):
cache.clear()
self.user = utils.create_user()
self.user2 = utils.create_user()
self.category = utils.create_category()
self.topic = utils.create_topic(self.category, user=self.user)
self.topic2 = utils.create_topic(self.category, user=self.user2)
def test_my_reviews_delete_link(self):
review = Review.objects.filter(reply_to=None)[0]
review.user_id = 999
review.save()
cache.clear()
slug = Addon.objects.get(id=review.addon_id).slug
delete_url = reverse("addons.reviews.delete", args=[slug, review.pk])
def _get_reviews(username, password):
self.client.login(username=username, password=password)
r = self.client.get(reverse("users.profile", args=[999]))
doc = pq(r.content)("#reviews")
return doc("#review-218207 .item-actions a.delete-review")
# Admins get the Delete Review link.
r = _get_reviews(username="******", password="******")
eq_(r.length, 1)
eq_(r.attr("href"), delete_url)
# Editors get the Delete Review link.
r = _get_reviews(username="******", password="******")
eq_(r.length, 1)
eq_(r.attr("href"), delete_url)
# Author gets the Delete Review link.
r = _get_reviews(username="******", password="******")
eq_(r.length, 1)
eq_(r.attr("href"), delete_url)
# Other user does not get the Delete Review link.
r = _get_reviews(username="******", password="******")
eq_(r.length, 0)
def test_edit_buttons(self):
"""Ensure admin/user edit buttons are shown."""
def get_links(id):
"""Grab profile, return edit links."""
url = reverse("users.profile", args=[id])
r = self.client.get(url)
return pq(r.content)("#profile-actions a")
# Anonymous user.
links = get_links(self.user.id)
eq_(links.length, 1)
eq_(links.eq(0).attr("href"), reverse("users.abuse", args=[self.user.id]))
# Non-admin, someone else's profile.
self.client.login(username="******", password="******")
links = get_links(9945)
eq_(links.length, 1)
eq_(links.eq(0).attr("href"), reverse("users.abuse", args=[9945]))
# Non-admin, own profile.
links = get_links(self.user.id)
eq_(links.length, 1)
eq_(links.eq(0).attr("href"), reverse("users.edit"))
# Admin, someone else's profile.
admingroup = Group(rules="Users:Edit")
admingroup.save()
GroupUser.objects.create(group=admingroup, user=self.user)
cache.clear()
# Admin, own profile.
links = get_links(self.user.id)
eq_(links.length, 2)
eq_(links.eq(0).attr("href"), reverse("users.edit"))
def setUp(self):
super().setUp()
self.username = '******'
self.password = '******'
self.user = User.objects.create_superuser(username=self.username, email='', password=self.password)
self.browser = webdriver.Firefox()
cache.clear()
def test_index_page_feed_reader(self):
# clear the cache of the empty feed we have for other tests
cache.clear()
url = reverse('homepage')
try:
response = self.client.get(url)
finally:
cache.clear()
self.assertEqual(response.status_code, 200)
content = response.content
if isinstance(content, six.binary_type):
content = content.decode('utf-8')
# because I know what's in test_rss20.xml I can
# check for it here
import feedparser
assert settings.L10N_FEED_URL.startswith('file:///')
parsed = feedparser.parse(settings.L10N_FEED_URL)
entries = list(parsed.entries)
first = entries[0]
# because the titles are truncated in the template
# we need to do the same here
from django.template.defaultfilters import truncatewords
self.assertIn(truncatewords(first['title'], 8), content)
self.assertIn('href="%s"' % first['link'], content)
second = parsed.entries[1]
self.assertIn(truncatewords(second['title'], 8), content)
self.assertIn('href="%s"' % second['link'], content)
def _pre_setup(self):
super(TestCase, self)._pre_setup()
# XXX See if we can remove this when we switch to Django 1.8.
# Some crud from the migration system gets stuck here and we have to
# kick it loose manually.
from mkt.webapps.models import AddonUser
UserProfile.addonuser_set.related.model = AddonUser
# Clean the slate.
cache.clear()
post_request_task._discard_tasks()
trans_real.deactivate()
trans_real._translations = {} # Django fails to clear this cache.
trans_real.activate(settings.LANGUAGE_CODE)
self.mock_browser_id()
global JINJA_INSTRUMENTED
if not JINJA_INSTRUMENTED:
import jinja2
old_render = jinja2.Template.render
def instrumented_render(self, *args, **kwargs):
context = dict(*args, **kwargs)
test.signals.template_rendered.send(sender=self, template=self,
context=context)
return old_render(self, *args, **kwargs)
jinja2.Template.render = instrumented_render
JINJA_INSTRUMENTED = True
def test_data_caching(self):
cache.clear()
key = pypi.cache_key('django')
package = pypi.Package('django')
self.assertIsNone(cache.get(key))
self.assertEqual(package.data(), self.test_data)
self.assertEqual(cache.get(key), self.package.data())
def handle(self, *args, **options):
try:
assert settings.CACHES
cache.clear()
self.stdout.write("Your cache has been cleared\n")
except AttributeError:
raise CommandError("You have no cache configured!\n")
def test_menu_nodes(self):
"""
Tests if all categories are present in the menu
"""
posts = self.get_posts()
pages = self.get_pages()
self.reload_urlconf()
for lang in ('en', 'it'):
with smart_override(lang):
request = self.get_page_request(pages[1], self.user, pages[1].get_absolute_url(lang))
nodes = menu_pool.get_nodes(request)
nodes_url = set([node.url for node in nodes])
cats_url = set([cat.get_absolute_url() for cat in self.cats if cat.has_translation(lang)])
self.assertTrue(cats_url.issubset(nodes_url))
cache.clear()
posts[0].categories.clear()
for lang in ('en', 'it'):
with smart_override(lang):
request = self.get_page_request(pages[1], self.user, pages[1].get_absolute_url(lang))
nodes = menu_pool.get_nodes(request)
nodes_url = set([node.url for node in nodes])
self.assertFalse(posts[0].get_absolute_url(lang) in nodes_url)
self.assertTrue(posts[1].get_absolute_url(lang) in nodes_url)
def test_num_placeholder_queries(self):
page3 = PlaceholderFieldTestPage.objects.create()
placeholder1 = Placeholder.objects.create_for_object(page3, 'field_slot1')
item1 = RawHtmlTestItem.objects.create_for_placeholder(placeholder1, html='<b>Item1!</b>', sort_order=1)
item2 = RawHtmlTestItem.objects.create_for_placeholder(placeholder1, html='<b>Item2!</b>', sort_order=2)
appsettings.FLUENT_CONTENTS_CACHE_OUTPUT = True
appsettings.FLUENT_CONTENTS_CACHE_PLACEHOLDER_OUTPUT = True
cache.clear()
# First time:
# - fetch ContentItem
# - fetch RawHtmlTestItem
with self.assertNumQueries(2) as ctx:
self._render("""{% load fluent_contents_tags %}{% render_placeholder placeholder1 %}""", {'placeholder1': placeholder1})
#pprint(ctx.captured_queries)
# Second time
with self.assertNumQueries(0) as ctx:
self._render("""{% load fluent_contents_tags %}{% render_placeholder placeholder1 %}""", {'placeholder1': placeholder1})
#pprint(ctx.captured_queries)
# Using page_placeholder
with self.assertNumQueries(0) as ctx:
self._render("""{% load fluent_contents_tags %}{% page_placeholder 'field_slot1' %}""", {'page': page3})
#pprint(ctx.captured_queries)
# Using page_placeholder, use fallback
with self.assertNumQueries(0) as ctx:
self._render("""{% load fluent_contents_tags %}{% page_placeholder 'field_slot1' fallback=True %}""", {'page': page3})
def test_edit_buttons(self):
"""Ensure admin/user edit buttons are shown."""
def get_links(id):
"""Grab profile, return edit links."""
url = reverse('users.profile', args=[id])
r = self.client.get(url)
return PyQuery(r.content)('p.editprofile a')
# Anonymous user.
links = get_links(self.user.id)
eq_(links.length, 0)
# Non-admin, someone else's profile.
self.client.login(username='******', password='******')
links = get_links(9945)
eq_(links.length, 0)
# Non-admin, own profile.
links = get_links(self.user.id)
eq_(links.length, 1)
eq_(links.eq(0).attr('href'), reverse('users.edit'))
# Admin, someone else's profile.
admingroup = Group(rules='Admin:EditAnyUser')
admingroup.save()
GroupUser.objects.create(group=admingroup, user=self.user_profile)
cache.clear()
def test_memcache_goes_bye_bye(self):
self.file_viewer.extract()
res = self.client.get(self.files_redirect(binary))
url = res['Location'][len(settings.STATIC_URL) - 1:]
cache.clear()
res = self.client.get(url)
eq_(res.status_code, 403)
def tearDownClass(cls):
# Remove temporal directory
shutil.rmtree(cls.tmp_dir, ignore_errors=True)
# deployers
catalogue.wgt_deployer = cls.old_catalogue_deployer
showcase.wgt_deployer = cls.old_deployer
# Restore previous language configuration
from django.conf import settings
settings.LANGUAGES = cls.old_LANGUAGES
settings.LANGUAGE_CODE = cls.old_LANGUAGE_CODE
settings.DEFAULT_LANGUAGE = cls.old_DEFAULT_LANGUAGE
# Restore old index dir
settings.WIRECLOUD_INDEX_DIR = cls.old_index_dir
# Clear cache
from django.core.cache import cache
cache.clear()
# Unmock network requests
cls.network.unmock_requests()
super(WirecloudTestCase, cls).tearDownClass()
def test_fetch_user_name(self, rget, rlogging):
cache.clear()
def mocked_get(url, **options):
if '/v2/users/99999' in url:
return Response(VOUCHED_FOR)
if 'peterbe' in url:
return Response(VOUCHED_FOR_USERS)
raise NotImplementedError(url)
rget.side_effect = mocked_get
url = reverse('comments:user_name')
response = self.client.get(url)
eq_(response.status_code, 200)
structure = json.loads(response.content)
eq_(structure['name'], '')
peterbe = User.objects.create_user(
username='******', password='******'
)
assert self.client.login(username='******', password='******')
response = self.client.get(url)
eq_(response.status_code, 200)
structure = json.loads(response.content)
eq_(structure['name'], '')
peterbe.email = '*****@*****.**'
peterbe.save()
response = self.client.get(url)
eq_(response.status_code, 200)
structure = json.loads(response.content)
eq_(structure['name'], 'Peter Bengtsson')
def clearcache (request):
cache.clear()
return render (request, 'base.html', dict (
content = mark_safe ('<h1>Cache cleared</h1>'),
request=request,
))
def setUpDefaultDatabaseAndClearCache():
cache.clear()
postUser()
login()
postBuilding()
postLocation()
postLocation(location_name="test_location_2")
postFingerprint()
postFingerprint(timestamp=curTime(1))
postFingerprint(scans=[
{
"base_station": {
'bssid': "BSSID_OF_TEST_BASE_STATION_1",
'ssid': "SSID_OF_TEST_NETWORK_1",
'frequency': 2246,
},
'level': -80
},
{
"base_station": {
'bssid': "BSSID_OF_TEST_BASE_STATION_2",
'ssid': "SSID_OF_TEST_NETWORK_1",
'frequency': 2246,
},
'level': -55
},
{
"base_station": {# belongs to the neighbour - barely visible!
'bssid': "BSSID_OF_TEST_BASE_STATION_X",
'ssid': "SSID_OF_TEST_NETWORK_X",
'frequency': 3387,
},
'level': -99
},
], location_url="http://testserver/api/locations/2/")
def clear_cache(request):
if request.method == 'POST':
cache.clear()
return redirect('dashboard')
else:
return render_to_response('cpanel/clear_cache.html', {},
context_instance=RequestContext(request))
def test_ordering_purchased(self):
# Generate two apps to ensure sure those are also listed.
for x in xrange(1, 3):
app = Webapp.objects.create(name='f%s' % x, guid='f%s' % x)
Installed.objects.create(addon=app, user=self.user)
for app in self.apps.values():
for contribution in app.contribution_set.all():
contribution.update(created=datetime.now()
+ timedelta(days=app.id))
# Purchase an app on behalf of a different user, which shouldn't
# affect the ordering of my purchases. Right?
clouserw = UserProfile.objects.get(email='*****@*****.**')
self.make_contribution(self.apps['t3'], '1.00', amo.CONTRIB_PURCHASE,
5, user=clouserw)
self.apps['t3'].addonpurchase_set.get(user=clouserw).update(
created=datetime.now() + timedelta(days=999))
# Now check the order of my purchased apps.
default = ['t4', 't3', 't2', 't1', 'f1', 'f2']
eq_(self.get_order(''), default)
eq_(self.get_order('purchased'), default)
self.apps['t2'].contribution_set.all()[0].update(
created=datetime.now() + timedelta(days=999))
cache.clear()
eq_(self.get_order('purchased'), ['t2', 't4', 't3', 't1', 'f1', 'f2'])
def test_anonymous_participants(self):
contest = Contest.objects.get()
contest.controller_name = \
"oioioi.participants.tests.AnonymousContestController"
contest.save()
u1 = User.objects.get(pk=1001)
self._register(u1, anonymous=False, possible=True)
u2 = User.objects.get(pk=1002)
self._register(u2, anonymous=True, possible=True)
contest = Contest.objects.get()
url = reverse('default_ranking', kwargs={'contest_id': contest.id})
self.client.login(username='******')
with fake_time(datetime(2015, 8, 5, tzinfo=utc)):
response = self.client.get(url)
self.assertNotIn('>test_user</a>', response.content)
self.assertIn('>Test User</a>', response.content)
self.assertIn('>test_user2</a>', response.content)
self.assertNotIn('>Test User 2</a>', response.content)
# Edit contest registration
self._register(u2, anonymous=False, possible=True)
# To see the changes in the ranking we have to clear the cache
cache.clear()
self.client.login(username='******')
response = self.client.get(url)
self.assertNotIn('>test_user2</a>', response.content)
self.assertIn('>Test User 2</a>', response.content)
def _get_json(self, source):
cache.clear()
req = RequestFactory().get('/')
resp = views.mozid_data_view(req, source)
eq_(resp['content-type'], 'application/json')
eq_(resp['access-control-allow-origin'], '*')
return json.loads(resp.content)
def setUp(self):
"""Set up this test case."""
super(DiffViewerFileAttachmentTests, self).setUp()
# The diff viewer's caching breaks the result of these tests,
# so be sure we clear before each one.
cache.clear()
def fake_time(timestamp):
"""A context manager which causes all requests having the specified
timestamp, regardless of the real wall clock time."""
cache.clear()
FakeTimeMiddleware._fake_timestamp.value = timestamp
yield
del FakeTimeMiddleware._fake_timestamp.value
def configuration_post_save(sender, **kwargs):
import repanier.cms_toolbar
from repanier.models.bankaccount import BankAccount
from repanier.models.producer import Producer
from repanier.models.customer import Customer
config = kwargs["instance"]
if config.id is not None:
repanier.apps.REPANIER_SETTINGS_CONFIG = config
repanier.apps.REPANIER_SETTINGS_TEST_MODE = config.test_mode
site = Site.objects.get_current()
if site is not None:
site.name = config.group_name
site.domain = settings.ALLOWED_HOSTS[0]
site.save()
repanier.apps.REPANIER_SETTINGS_GROUP_NAME = config.group_name
if config.name == PERMANENCE_NAME_PERMANENCE:
repanier.apps.REPANIER_SETTINGS_PERMANENCE_NAME = _("Permanence")
repanier.apps.REPANIER_SETTINGS_PERMANENCES_NAME = _("Permanences")
repanier.apps.REPANIER_SETTINGS_PERMANENCE_ON_NAME = _(
"Permanence on ")
elif config.name == PERMANENCE_NAME_CLOSURE:
repanier.apps.REPANIER_SETTINGS_PERMANENCE_NAME = _("Closure")
repanier.apps.REPANIER_SETTINGS_PERMANENCES_NAME = _("Closures")
repanier.apps.REPANIER_SETTINGS_PERMANENCE_ON_NAME = _(
"Closure on ")
elif config.name == PERMANENCE_NAME_DELIVERY:
repanier.apps.REPANIER_SETTINGS_PERMANENCE_NAME = _("Delivery")
repanier.apps.REPANIER_SETTINGS_PERMANENCES_NAME = _("Deliveries")
repanier.apps.REPANIER_SETTINGS_PERMANENCE_ON_NAME = _(
"Delivery on ")
elif config.name == PERMANENCE_NAME_ORDER:
repanier.apps.REPANIER_SETTINGS_PERMANENCE_NAME = _("Order")
repanier.apps.REPANIER_SETTINGS_PERMANENCES_NAME = _("Orders")
repanier.apps.REPANIER_SETTINGS_PERMANENCE_ON_NAME = _("Order on ")
elif config.name == PERMANENCE_NAME_OPENING:
repanier.apps.REPANIER_SETTINGS_PERMANENCE_NAME = _("Opening")
repanier.apps.REPANIER_SETTINGS_PERMANENCES_NAME = _("Openings")
repanier.apps.REPANIER_SETTINGS_PERMANENCE_ON_NAME = _(
"Opening on ")
else:
repanier.apps.REPANIER_SETTINGS_PERMANENCE_NAME = _("Distribution")
repanier.apps.REPANIER_SETTINGS_PERMANENCES_NAME = _(
"Distributions")
repanier.apps.REPANIER_SETTINGS_PERMANENCE_ON_NAME = _(
"Distribution on ")
repanier.apps.REPANIER_SETTINGS_MAX_WEEK_WO_PARTICIPATION = config.max_week_wo_participation
repanier.apps.REPANIER_SETTINGS_SEND_OPENING_MAIL_TO_CUSTOMER = config.send_opening_mail_to_customer
repanier.apps.REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_CUSTOMER = config.send_order_mail_to_customer
repanier.apps.REPANIER_SETTINGS_SEND_CANCEL_ORDER_MAIL_TO_CUSTOMER = config.send_cancel_order_mail_to_customer
repanier.apps.REPANIER_SETTINGS_SEND_ABSTRACT_ORDER_MAIL_TO_CUSTOMER = config.send_abstract_order_mail_to_customer
repanier.apps.REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_PRODUCER = config.send_order_mail_to_producer
repanier.apps.REPANIER_SETTINGS_SEND_ABSTRACT_ORDER_MAIL_TO_PRODUCER = config.send_abstract_order_mail_to_producer
repanier.apps.REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_BOARD = config.send_order_mail_to_board
repanier.apps.REPANIER_SETTINGS_SEND_INVOICE_MAIL_TO_CUSTOMER = config.send_invoice_mail_to_customer
repanier.apps.REPANIER_SETTINGS_SEND_INVOICE_MAIL_TO_PRODUCER = config.send_invoice_mail_to_producer
repanier.apps.REPANIER_SETTINGS_INVOICE = config.invoice
repanier.apps.REPANIER_SETTINGS_CLOSE_WO_SENDING = config.close_wo_sending
repanier.apps.REPANIER_SETTINGS_DISPLAY_ANONYMOUS_ORDER_FORM = config.display_anonymous_order_form
repanier.apps.REPANIER_SETTINGS_DISPLAY_PRODUCER_ON_ORDER_FORM = config.display_producer_on_order_form
repanier.apps.REPANIER_SETTINGS_DISPLAY_WHO_IS_WHO = config.display_who_is_who
if config.bank_account is not None and len(
config.bank_account.strip()) == 0:
repanier.apps.REPANIER_SETTINGS_BANK_ACCOUNT = None
else:
repanier.apps.REPANIER_SETTINGS_BANK_ACCOUNT = config.bank_account
if config.vat_id is not None and len(config.vat_id.strip()) == 0:
repanier.apps.REPANIER_SETTINGS_VAT_ID = None
else:
repanier.apps.REPANIER_SETTINGS_VAT_ID = config.vat_id
repanier.apps.REPANIER_SETTINGS_PAGE_BREAK_ON_CUSTOMER_CHECK = config.page_break_on_customer_check
repanier.apps.REPANIER_SETTINGS_SMS_GATEWAY_MAIL = config.sms_gateway_mail
repanier.apps.REPANIER_SETTINGS_CUSTOMERS_MUST_CONFIRM_ORDERS = config.customers_must_confirm_orders
repanier.apps.REPANIER_SETTINGS_MEMBERSHIP_FEE = config.membership_fee
repanier.apps.REPANIER_SETTINGS_MEMBERSHIP_FEE_DURATION = config.membership_fee_duration
if config.currency == CURRENCY_LOC:
repanier.apps.REPANIER_SETTINGS_CURRENCY_DISPLAY = u'✿'
repanier.apps.REPANIER_SETTINGS_AFTER_AMOUNT = False
repanier.apps.REPANIER_SETTINGS_CURRENCY_XLSX = u'_ ✿ * #,##0.00_ ;_ ✿ * -#,##0.00_ ;_ ✿ * "-"??_ ;_ @_ '
elif config.currency == CURRENCY_CHF:
repanier.apps.REPANIER_SETTINGS_CURRENCY_DISPLAY = 'Fr.'
repanier.apps.REPANIER_SETTINGS_AFTER_AMOUNT = False
repanier.apps.REPANIER_SETTINGS_CURRENCY_XLSX = '_ Fr\. * #,##0.00_ ;_ Fr\. * -#,##0.00_ ;_ Fr\. * "-"??_ ;_ @_ '
else:
repanier.apps.REPANIER_SETTINGS_CURRENCY_DISPLAY = u'€'
repanier.apps.REPANIER_SETTINGS_AFTER_AMOUNT = True
repanier.apps.REPANIER_SETTINGS_CURRENCY_XLSX = u'_ € * #,##0.00_ ;_ € * -#,##0.00_ ;_ € * "-"??_ ;_ @_ '
if config.home_site is not None and len(config.home_site.strip()) == 0:
repanier.apps.REPANIER_SETTINGS_HOME_SITE = "/"
else:
repanier.apps.REPANIER_SETTINGS_HOME_SITE = config.home_site
repanier.apps.REPANIER_SETTINGS_TRANSPORT = config.transport
repanier.apps.REPANIER_SETTINGS_MIN_TRANSPORT = config.min_transport
bank_account = BankAccount.objects.filter(
operation_status=BANK_LATEST_TOTAL).order_by('?').first()
if bank_account is None:
# If not latest total exists, create it with operation date before all movements
bank_account = BankAccount.objects.all().order_by(
"operation_date").first()
if bank_account is None:
BankAccount.objects.create(
operation_status=BANK_LATEST_TOTAL,
operation_date=timezone.now().date())
else:
if bank_account.producer is None and bank_account.customer is None:
bank_account.operation_status = BANK_LATEST_TOTAL
bank_account.save(update_fields=['operation_status'])
else:
BankAccount.objects.create(
operation_status=BANK_LATEST_TOTAL,
operation_date=bank_account.operation_date +
datetime.timedelta(days=-1))
producer_buyinggroup = Producer.objects.filter(
represent_this_buyinggroup=True).order_by('?').first()
if producer_buyinggroup is None:
producer_buyinggroup = Producer.objects.create(
short_profile_name="z-%s" %
repanier.apps.REPANIER_SETTINGS_GROUP_NAME,
long_profile_name=repanier.apps.REPANIER_SETTINGS_GROUP_NAME,
represent_this_buyinggroup=True)
if producer_buyinggroup is not None:
membership_fee_product = Product.objects.filter(
order_unit=PRODUCT_ORDER_UNIT_MEMBERSHIP_FEE,
is_active=True).order_by('?').first()
if membership_fee_product is None:
membership_fee_product = Product.objects.create(
producer_id=producer_buyinggroup.id,
order_unit=PRODUCT_ORDER_UNIT_MEMBERSHIP_FEE,
vat_level=VAT_100)
cur_language = translation.get_language()
for language in settings.PARLER_LANGUAGES[settings.SITE_ID]:
language_code = language["code"]
translation.activate(language_code)
membership_fee_product.set_current_language(language_code)
membership_fee_product.long_name = "%s" % (_("Membership fee"))
membership_fee_product.save()
translation.activate(cur_language)
repanier.apps.REPANIER_SETTINGS_GROUP_PRODUCER_ID = producer_buyinggroup.id
customer_buyinggroup = Customer.objects.filter(
represent_this_buyinggroup=True).order_by('?').first()
if customer_buyinggroup is None:
user = User.objects.create_user(
username="******" % repanier.apps.REPANIER_SETTINGS_GROUP_NAME,
email="%s%s" %
(repanier.apps.REPANIER_SETTINGS_GROUP_NAME,
settings.DJANGO_SETTINGS_ALLOWED_MAIL_EXTENSION),
password=uuid.uuid1().hex,
first_name=EMPTY_STRING,
last_name=repanier.apps.REPANIER_SETTINGS_GROUP_NAME)
customer_buyinggroup = Customer.objects.create(
user=user,
short_basket_name="z-%s" %
repanier.apps.REPANIER_SETTINGS_GROUP_NAME,
long_basket_name=repanier.apps.REPANIER_SETTINGS_GROUP_NAME,
phone1='0499/96.64.32',
represent_this_buyinggroup=True)
repanier.apps.REPANIER_SETTINGS_GROUP_CUSTOMER_ID = customer_buyinggroup.id
menu_pool.clear()
toolbar_pool.unregister(repanier.cms_toolbar.RepanierToolbar)
toolbar_pool.register(repanier.cms_toolbar.RepanierToolbar)
cache.clear()
def setUp(self):
super(DisableRateLimitTest, self).setUp()
cache.clear()
self.view = FakeApiView()
def tearDown(self):
os.remove(self.image)
cache.clear()
def test4(request):
from django.core.cache import cache
cache.clear()
return HttpResponse("清除完毕")
def _pre_setup(self):
cache.clear()
ProjectOption.objects.clear_cache()
Option.objects.clear_cache()
super(BaseTestCase, self)._pre_setup()
def flush_cache(request):
cache.clear()
invalidate_all()
messages.success(request, "cache successful flushed!")
return redirect(resolve_url("productdb_config:status"))
def setUp(self):
"""
Reset the cache so that no throttles will be active
"""
cache.clear()
self.factory = APIRequestFactory()
def tearDown(self):
# make sure every test has a clean slate for k8s mocking
cache.clear()
def clear_cache(request):
cache.clear()
return redirect('dashboard')
def model_change_handler(sender, instance, **kwargs):
# Model changed, invalidate cache. Next view will be a lengthy recalculation to re-populate our cache.
cache.clear()
def setUp(self):
self.base_url = '%s://%s' % (self.protocol, self.domain)
cache.clear()
# Create an object for sitemap content.
TestModel.objects.create(name='Test Object')
self.i18n_model = I18nTestModel.objects.create(name='Test Object')
def setUp(self):
self.result = self.get_result()
cache.clear()
def tearDown(self):
self.f.close()
cache.clear()
def _sitesettings_post_save(sender, instance, **kwargs):
# Privacy settings may have changed.
cache.clear()
def handle(self, *args, **kwargs):
cache.clear()
self.stdout.write('Cache has been cleared!\n')
def clear_cache():
cache.clear()
def _pre_setup(self):
cache.clear()
trans_real.deactivate()
trans_real._translations = {} # Django fails to clear this cache.
trans_real.activate(settings.LANGUAGE_CODE)
super(TestCase, self)._pre_setup()
def setUp(self):
cache.clear()
self.user = utils.create_user()
self.category = utils.create_category()
self.topic = utils.create_topic(category=self.category, user=self.user)
self.comment = utils.create_comment(user=self.user, topic=self.topic)
def clear_cache():
'''
Clear cache (local memory) for each test to prevent using cached settings.
'''
cache.clear()
def clear_cache(*args, **kwargs):
cache.clear()
def setUp(self):
self.base_url = '%s://%s' % (self.protocol, self.domain)
cache.clear()
def tearDown(self):
super(WebAPITokenAuthBackendTests, self).tearDown()
cache.clear()
def get(self, request, format=None):
from django.core.cache import cache
cache.clear()
init_cache()
return Response('Cache has been cleared')
def clear_cache(self):
# clear cache between every test case to avoid config option cache
# issue which cause test failed
cache.clear()
def tearDown(self):
cache.clear()
def delete_favorite_by_id_favorite(id_user_request, id_favorite_request):
cache.clear() # Clear cache khi dich lai.
return VocabularyFavorite.objects.filter(id=id_favorite_request,
user_id=id_user_request).delete()
def setUp(self):
cache.clear()
super(IssuerTests, self).setUp()
def handle(self, *args, **options):
log.warning(
"This does not clear your browsers chache. For JSON this might be relevant."
)
cache.clear()
def tearDown(self):
super(BaseTestCase,self).setUp()
cache.clear()
def setUp(self):
cache.clear()
