def patched_redis(settings):
patch_redis(REDIS_DB_FILE)
_redis = StrictRedis(REDIS_DB_FILE)
settings.REDIS_URL = 'unix://{}'.format(_redis.socket_file)
_redis.flushall()
yield _redis
unpatch_redis()
def setUp(self):
# We create a superuser and a client with all scopes
# Then we create token with smaller scopes to test
person_content_type = ContentType.objects.get_for_model(Person)
self.person = Person.objects.create_superperson(
email='*****@*****.**', password='******')
add_permission = Permission.objects.get(
content_type=person_content_type, codename='view_person')
self.person.role.user_permissions.add(add_permission)
self.other_person = Person.objects.create(email='*****@*****.**')
self.calendar = Calendar.objects.create_calendar('calendar')
self.event = Event.objects.create(name='Test event',
start_time=timezone.now(),
end_time=timezone.now() +
timezone.timedelta(hours=4),
calendar=self.calendar)
OrganizerConfig.objects.create(event=self.event, person=self.person)
self.api_client = models.Client.objects.create_client(
'client', scopes=scopes.scopes_names)
self.redis_instance = StrictRedis()
self.redis_patcher = mock.patch('clients.tokens.get_auth_redis_client')
mock_get_auth_redis_client = self.redis_patcher.start()
mock_get_auth_redis_client.return_value = self.redis_instance
def test_not_eager(self, registry: CollectorRegistry, redis: StrictRedis):
counter = Counter(name="http_requests_total",
description="Total HTTP Requests")
registry.register(counter)
assert not registry.eager
counter.inc()
assert redis.hgetall("testing") == {}
registry.transfer()
assert redis.hgetall("testing") != {}
def test_redis_getter_setter(tmpdir):
""":type tmpdir: py.path.local"""
from cache_requests import Memoize
from redislite import StrictRedis
# LOCAL SETUP
# ------------------------------------------------------------------------
@Memoize(ex=1)
def hello():
pass
test_connection = hello.redis
test_db = tmpdir.join('test_redis.db').strpath
alt_db = tmpdir.join('test_redis_getter_setter.db').strpath
alt_connection = StrictRedis(dbfilename=alt_db)
# TEST SETUP
# ------------------------------------------------------------------------
assert test_connection.db == test_db
assert alt_connection.db == alt_db
assert test_db != alt_db
# TEST MEMOIZE REDIS SETTER
# ------------------------------------------------------------------------
hello.redis = alt_connection
assert hello.redis.db != test_db
assert hello.redis.db == alt_db
def setUp(self):
self.person = Person.objects.create_person(email='*****@*****.**')
self.scope = scopes.view_profile
self.other_scope = scopes.edit_profile
self.client = models.Client.objects.create_client(
'client', scopes=[self.scope.name, self.other_scope.name])
self.one_scope_client = models.Client.objects.create_client(
'noscope', scopes=[self.other_scope.name])
self.redis_instance = StrictRedis()
self.token = str(uuid.uuid4())
self.token_info = {
'clientId': self.client.label,
'userId': str(self.person.pk),
'scope': [self.scope.name, self.other_scope.name]
}
self.wrong_scope_token = str(uuid.uuid4())
self.wrong_scope_token_info = {
'clientId': self.one_scope_client.label,
'userId': str(self.person.pk),
'scope': [self.scope.name, self.other_scope.name]
}
self.redis_instance.set(
'{prefix}{token}:payload'.format(prefix=settings.AUTH_REDIS_PREFIX,
token=self.token),
json.dumps(self.token_info))
self.redis_instance.set(
'{prefix}{token}:payload'.format(prefix=settings.AUTH_REDIS_PREFIX,
token=self.wrong_scope_token),
json.dumps(self.wrong_scope_token_info))
self.redis_patcher = mock.patch('clients.tokens.get_auth_redis_client')
mock_get_auth_redis_client = self.redis_patcher.start()
mock_get_auth_redis_client.return_value = self.redis_instance
self.factory = APIRequestFactory()
self.token_authentifier = authentication.AccessTokenAuthentication()
def test_redis_getter_setter(tmpdir):
""":type tmpdir: py.path.local"""
from cache_requests import Session
from redislite import StrictRedis
# LOCAL SETUP
# ------------------------------------------------------------------------
request = Session()
test_db = tmpdir.join('test_redis.db').strpath
test_connection = request.cache.connection
alt_db = tmpdir.join('test_redis_getter_setter.db').strpath
alt_connection = StrictRedis(dbfilename=alt_db)
# TEST SETUP
# ------------------------------------------------------------------------
assert test_connection.db == test_db
assert alt_connection.db == alt_db
assert test_db != alt_db
# TEST SESSION CONNECTION IDENTITY WITH METHOD's REDIS HANDLE
# ------------------------------------------------------------------------
assert request.get.redis is request.cache.connection
assert request.cache.connection.db == test_db
request.post.redis = alt_connection
assert request.post.redis is request.patch.redis
assert request.post.redis is request.cache.connection
assert request.post.redis.db == alt_db
request.cache.connection = test_connection
assert request.delete.redis is request.patch.redis
assert request.delete.redis is request.cache.connection
assert request.delete.redis.db == test_db
import json
from redislite import StrictRedis
from tornado.testing import AsyncHTTPTestCase
from tornado.web import create_signed_value
from core.db.models import User
from core.session.model import Session
from core.webserver import WebServer
from core.utils.config import parse_config
app = None
config = parse_config('config/test.conf')
redis_server = StrictRedis(decode_responses=True)
config.set('redis', 'socket', redis_server.socket_file)
def end_transactions(session):
session.rollback() if session else None
def get_global_app():
global app
app = WebServer(config=config) if app is None else app
return app
class BaseAppTestCase(AsyncHTTPTestCase):
def setUp(self):
super().setUp()
self.addCleanup(end_transactions, session=self.db)
class TokenTestCase(TestCase):
def setUp(self):
self.person = Person.objects.create_person(email='*****@*****.**')
self.scope = scopes.view_profile
self.other_scope = scopes.edit_profile
self.client = models.Client.objects.create_client(
'client', scopes=[self.scope.name, self.other_scope.name])
self.one_scope_client = models.Client.objects.create_client(
'noscope', scopes=[self.other_scope.name])
self.redis_instance = StrictRedis()
self.token = str(uuid.uuid4())
self.token_info = {
'clientId': self.client.label,
'userId': str(self.person.pk),
'scope': [self.scope.name, self.other_scope.name]
}
self.wrong_scope_token = str(uuid.uuid4())
self.wrong_scope_token_info = {
'clientId': self.one_scope_client.label,
'userId': str(self.person.pk),
'scope': [self.scope.name, self.other_scope.name]
}
self.redis_instance.set(
'{prefix}{token}:payload'.format(prefix=settings.AUTH_REDIS_PREFIX,
token=self.token),
json.dumps(self.token_info))
self.redis_instance.set(
'{prefix}{token}:payload'.format(prefix=settings.AUTH_REDIS_PREFIX,
token=self.wrong_scope_token),
json.dumps(self.wrong_scope_token_info))
self.redis_patcher = mock.patch('clients.tokens.get_auth_redis_client')
mock_get_auth_redis_client = self.redis_patcher.start()
mock_get_auth_redis_client.return_value = self.redis_instance
self.factory = APIRequestFactory()
self.token_authentifier = authentication.AccessTokenAuthentication()
def tearDown(self):
self.redis_patcher.stop()
def test_cannot_authenticate_with_invalid_token(self):
request = self.factory.get('',
HTTP_AUTHORIZATION="Bearer {token}".format(
token=str(uuid.uuid4())))
with self.assertRaises(exceptions.AuthenticationFailed):
self.token_authentifier.authenticate(request=request)
def test_can_authenticate_with_token(self):
request = self.factory.get(
'', HTTP_AUTHORIZATION="Bearer {token}".format(token=self.token))
auth_user, auth_info = self.token_authentifier.authenticate(
request=request)
self.assertEqual(auth_user.type, Role.PERSON_ROLE)
self.assertEqual(auth_user.person, self.person)
self.assertEqual(auth_user.token, auth_info)
self.assertIsInstance(auth_info, tokens.AccessToken)
self.assertEqual(auth_info.client, self.client)
self.assertCountEqual(auth_info.scopes, [self.scope, self.other_scope])
def test_only_scopes_authorized_for_client_are_kept(self):
request = self.factory.get('',
HTTP_AUTHORIZATION="Bearer {token}".format(
token=self.wrong_scope_token))
auth_user, auth_info = self.token_authentifier.authenticate(
request=request)
self.assertEqual(auth_info.client, self.one_scope_client)
self.assertCountEqual(auth_info.scopes, [self.other_scope])
class ScopeTestCase(APITestCase):
def setUp(self):
# We create a superuser and a client with all scopes
# Then we create token with smaller scopes to test
person_content_type = ContentType.objects.get_for_model(Person)
self.person = Person.objects.create_superperson(
email='*****@*****.**', password='******')
add_permission = Permission.objects.get(
content_type=person_content_type, codename='view_person')
self.person.role.user_permissions.add(add_permission)
self.other_person = Person.objects.create(email='*****@*****.**')
self.calendar = Calendar.objects.create_calendar('calendar')
self.event = Event.objects.create(name='Test event',
start_time=timezone.now(),
end_time=timezone.now() +
timezone.timedelta(hours=4),
calendar=self.calendar)
OrganizerConfig.objects.create(event=self.event, person=self.person)
self.api_client = models.Client.objects.create_client(
'client', scopes=scopes.scopes_names)
self.redis_instance = StrictRedis()
self.redis_patcher = mock.patch('clients.tokens.get_auth_redis_client')
mock_get_auth_redis_client = self.redis_patcher.start()
mock_get_auth_redis_client.return_value = self.redis_instance
def tearDown(self):
self.redis_patcher.stop()
def generate_token(self, scopes_names):
self.token = str(uuid.uuid4())
self.token_info = {
'clientId': self.api_client.label,
'userId': str(self.person.pk),
'scope': scopes_names
}
self.redis_instance.set(
'{prefix}{token}:payload'.format(prefix=settings.AUTH_REDIS_PREFIX,
token=self.token),
json.dumps(self.token_info))
self.client.credentials(HTTP_AUTHORIZATION="Bearer {token}".format(
token=self.token))
def test_get_required_token(self):
self.assertEqual(scopes.get_required_scopes('people.view_person'),
[scopes.view_profile])
def test_can_view_profile_with_correct_scope(self):
self.generate_token([scopes.view_profile.name])
response = self.client.get('/legacy/people/me/')
self.assertEqual(response.status_code, 200)
def test_cannot_view_profile_without_correct_scope(self):
self.generate_token([scopes.edit_event.name])
response = self.client.get('/legacy/people/me/')
self.assertEqual(response.status_code, 403)
def test_cannot_use_global_permissions_with_token(self):
self.generate_token([scopes.view_profile.name])
response = self.client.get('/legacy/people/' +
str(self.other_person.id) + '/')
self.assertEqual(response.status_code, 403)
def test_can_edit_profile_with_correct_scope(self):
self.generate_token([scopes.edit_profile.name])
response = self.client.patch('/legacy/people/' + str(self.person.id) +
'/',
data={'email': '*****@*****.**'})
self.assertEqual(response.status_code, 200)
self.assertEqual(self.person.email, '*****@*****.**')
def test_cannot_edit_profile_without_correct_scope(self):
self.generate_token([scopes.view_profile.name])
response = self.client.patch('/legacy/people/' + str(self.person.id) +
'/',
data={'email': '*****@*****.**'})
self.assertEqual(response.status_code, 403)
def test_can_edit_own_event_with_correct_scope(self):
self.generate_token([scopes.edit_event.name])
response = self.client.patch('/legacy/events/' + str(self.event.id) +
'/',
data={'description': 'Description !'})
self.event.refresh_from_db()
self.assertEqual(response.status_code, 200)
self.assertEqual(self.event.description, 'Description !')
def test_cannot_edit_own_event_without_correct_scope(self):
self.generate_token([scopes.view_profile.name])
response = self.client.patch('/legacy/events/' + str(self.event.id) +
'/',
data={'description': 'Description !'})
self.event.refresh_from_db()
self.assertEqual(response.status_code, 403)
#pip intall redislite
from redislite import StrictRedis
from redis_collections import List
def read_temp_celsius():
with open('file/to/driver/w1_slave') as device:
for line in device:
value = line.strip().split()[-1]
if value.startswith('t='):
return float(value[2:]) / 1000.0
redis_connection = StrictRedis('')
#using wemos-d1-mini ESP8266 (wifi built in) with micropython...
import dht
import machine
print "Powering on sensor"
power_pin = machine.Pin()
power_pin.high()
print "Reading sensor"
d = dht.DHT11(machine.Pin(0))
d.measure()
print "Temp", d.temperature() * 1.8 + 32
print "Humidity", d.humidity()
def redis():
return StrictRedis(db=0)
ACCOUNT_LOGIN_ATTEMPTS_TIMEOUT = 86400
LOGIN_REDIRECT_URL = "home_question"
ACCOUNT_LOGOUT_REDIRECT_URL = 'home'
# Email Settings
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
EMAIL_HOST = 'localhost'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
redis = StrictRedis("/dev/shm/cache.rdb")
CACHES = {
'default': {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "unix://@%s" % (redis.socket_file, )
},
'select2': {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "unix://@%s" % (redis.socket_file, )
}
}
CRISPY_TEMPLATE_PACK = 'bootstrap4'
# Tell select2 which cache configuration to use:
import schedule
from time import sleep
from flask_bootstrap import Bootstrap
from collections import OrderedDict
from flask_wtf import FlaskForm
from wtforms import TextAreaField, SubmitField
from wtforms.validators import Length, ValidationError
from flask import Flask, render_template, request, url_for, Response, abort
from datetime import datetime
from redislite import StrictRedis
app = Flask(__name__, static_url_path="/static")
Bootstrap(app)
app.config["SECRET_KEY"] = settings.csrf
REDIS = os.path.join("/tmp/redis.db")
r = StrictRedis(REDIS, charset="utf-8", decode_responses=True)
r.hset("counter", "increment", 0)
def reset_redis():
r.hset("counter", "increment", 0)
schedule.every().hour.do(reset_redis)
class WebForm(FlaskForm):
""" for validation """
webabstract = TextAreaField(validators=[
Length(
def redis(tmpdir):
yield StrictRedis(str(tmpdir.join('redis.db')))
backupCount=5,
encoding='utf-8')
file_handler.setLevel(logging.INFO)
app = Flask(__name__)
app.logger.addHandler(file_handler)
try:
# noinspection PyUnresolvedReferences
from redislite import StrictRedis
# noinspection PyUnresolvedReferences
from werkzeug.contrib.cache import RedisCache
cache_file = os.path.join(os.path.dirname(__file__), 'server_cache.rdb')
cache = RedisCache(StrictRedis(cache_file))
except ImportError:
from werkzeug.contrib.cache import SimpleCache
cache = SimpleCache()
app.logger.warning(
'redislite could not be imported. Falling back to non-thread-safe caching'
)
try:
with open('message.json') as f:
secret_message = json.load(f)
except IOError:
raise RuntimeError('Use %r to create the database first. %r not found. \n'
'Shutting down...' % ('make migrate', 'message.json'))