def setUp(self): app = Flask(__name__) app.debug = False app.config['CACHE_TYPE'] = 'simple' self.cache = Cache() self.cache.init_app(app) self.app = app
def configure_extensions(app): print ' [LOAD] PostgreSQL extension' app.db = PostgreSQL(app) print ' [LOAD] Cache extension' app.cache = Cache(app) print ' [LOAD] Authentication extension' app.auth = Auth(app) print ' [LOAD] Amazon S3 extension' app.s3 = S3Connection(app.config['AWS_ACCESS_KEY_ID'], app.config['AWS_SECRET_ACCESS_KEY'])
from flaskext.cache import Cache from flaskext.uploads import UploadSet, IMAGES, configure_uploads from blinker import Namespace import setting import sys app = Flask(__name__) app.config.from_object(setting) app.debug = True toolbar = DebugToolbarExtension(app) mail = Mail(app) babel = Babel(app) cache = Cache(app) #db = SQLAlchemy(app) principals = Principal(app) login_manager = LoginManager() login_manager.setup_app(app) userimage = UploadSet('userimage', IMAGES) configure_uploads(app, (userimage)) # setting # fix issue of unicode reload(sys) sys.setdefaultencoding("utf-8") # fix issue of forerign_keys problem for SQLite #db.session.execute('PRAGMA foreign_keys=ON;') class SQLiteForeignKeysListener(PoolListener):
class ProxyFixupHelper(object): def __init__(self, app): self.app = app def __call__(self, environ, start_response): # Only perform this fixup if the current remote host is localhost. if environ['REMOTE_ADDR'] == '127.0.0.1': host = environ.get('HTTP_X_REAL_IP', False) if host: environ['REMOTE_ADDR'] = host return self.app(environ, start_response) # Flask Extensions babel = Babel() cache = Cache() # SQL ORM Missive: # # Don't use models to automatically generate schemas. After iterating several # times with SQLAlchemy (and nearly every other ORM from frameworks both long # since dead and still trendy), to get a schema "just right" requires # entirely too much fiddling in the ORM. My hard earned lesson: SQL is the # right dialect to describe your database's structure (read: do not use an # ORM to generate DDL). Other than portability, what's the advantage of # describing your schema in SQLAlchemy? # # For as fantastic as SQLAlchemy is, using SQLAlchemy to generate schema is # the equivalent of giving yourself a lobotomy while in the middle of # attempting to write a Pulitzer Prize article. Why handicap yourself? Use # SQLAlchemy for what it excels at: generating efficient SQL based on
class CacheTestCase(unittest.TestCase): def setUp(self): app = Flask(__name__) app.debug = False app.config['CACHE_TYPE'] = 'simple' self.cache = Cache() self.cache.init_app(app) self.app = app def tearDown(self): self.app = None self.cache = None self.tc = None def test_00_set(self): self.cache.set('hi', 'hello') assert self.cache.get('hi') == 'hello' def test_01_add(self): self.cache.add('hi', 'hello') assert self.cache.get('hi') == 'hello' self.cache.add('hi', 'foobar') assert self.cache.get('hi') == 'hello' def test_02_delete(self): self.cache.set('hi', 'hello') self.cache.delete('hi') assert self.cache.get('hi') is None def test_03_cached_view(self): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data time.sleep(2) rv = tc.get('/') assert the_time == rv.data time.sleep(5) rv = tc.get('/') assert the_time != rv.data def test_04_cached_view_unless(self): @self.app.route('/a') @self.cache.cached(5, unless=lambda: True) def non_cached_view(): return str(time.time()) @self.app.route('/b') @self.cache.cached(5, unless=lambda: False) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/a') the_time = rv.data time.sleep(1) rv = tc.get('/a') assert the_time != rv.data rv = tc.get('/b') the_time = rv.data time.sleep(1) rv = tc.get('/b') assert the_time == rv.data def test_05_cached_function(self): with self.app.test_request_context(): @self.cache.cached(2, key_prefix='MyBits') def get_random_bits(): return [random.randrange(0, 2) for i in range(50)] my_list = get_random_bits() his_list = get_random_bits() assert my_list == his_list time.sleep(4) his_list = get_random_bits() assert my_list != his_list def test_06_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a+b+random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result result2 = big_foo(5, 3) assert result2 != result time.sleep(4) assert big_foo(5, 2) != result assert big_foo(5, 3) == result2 time.sleep(1) assert big_foo(5, 3) != result2 def test_07_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a+b+random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result assert big_foo(5, 2) == result assert big_foo(5, 3) != result self.cache.delete_memoized('big_foo') assert big_foo(5, 2) != result def test_08_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return a+b+random.randrange(0, 100000) result_a = big_foo(5, 1) result_b = big_foo(5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) == result_b self.cache.delete_memoized('big_foo', 5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) != result_b def test_09_args_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return sum(a)+sum(b)+random.randrange(0, 100000) result_a = big_foo([5,3,2], [1]) result_b = big_foo([3,3], [3,1]) assert big_foo([5,3,2], [1]) == result_a assert big_foo([3,3], [3,1]) == result_b self.cache.delete_memoized('big_foo', [5,3,2], [1]) assert big_foo([5,3,2], [1]) != result_a assert big_foo([3,3], [3,1]) == result_b def test_10_kwargs_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b=None): return a+sum(b.values())+random.randrange(0, 100000) result_a = big_foo(1, dict(one=1,two=2)) result_b = big_foo(5, dict(three=3,four=4)) assert big_foo(1, dict(one=1,two=2)) == result_a assert big_foo(5, dict(three=3,four=4)) == result_b self.cache.delete_memoized('big_foo', 1, dict(one=1,two=2)) assert big_foo(1, dict(one=1,two=2)) != result_a assert big_foo(5, dict(three=3,four=4)) == result_b def test_11_cache_key_property(self): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data with self.app.test_request_context(): cache_data = self.cache.get(cached_view.make_cache_key()) assert the_time == cache_data def test_12_make_cache_key_function_property(self): @self.app.route('/<foo>/<bar>') @self.cache.memoize(5) def cached_view(foo, bar): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get('/a/b') the_time = rv.data cache_key = cached_view.make_cache_key(foo=u"a", bar=u"b") cache_data = self.cache.get(cache_key) assert the_time == cache_data different_key = cached_view.make_cache_key(foo=u"b", bar=u"a") different_data = self.cache.get(different_key) assert the_time != different_data def test_13_cache_timeout_property(self): @self.app.route('/') @self.cache.memoize(5) def cached_view1(): return str(time.time()) @self.app.route('/<foo>/<bar>') @self.cache.memoize(10) def cached_view2(foo, bar): return str(time.time()) assert hasattr(cached_view1, "cache_timeout") assert hasattr(cached_view2, "cache_timeout") assert cached_view1.cache_timeout == 5 assert cached_view2.cache_timeout == 10 # test that this is a read-write property cached_view1.cache_timeout = 2 cached_view2.cache_timeout = 3 assert cached_view1.cache_timeout == 2 assert cached_view2.cache_timeout == 3 tc = self.app.test_client() rv1 = tc.get('/') time1 = rv1.data time.sleep(1) rv2 = tc.get('/a/b') time2 = rv2.data # VIEW1 # it's been 1 second, cache is still active assert time1 == tc.get('/').data time.sleep(2) # it's been 3 seconds, cache is not still active assert time1 != tc.get('/').data # VIEW2 # it's been 2 seconds, cache is still active assert time2 == tc.get('/a/b').data time.sleep(2) # it's been 4 seconds, cache is not still active assert time2 != tc.get('/a/b').data
class CacheTestCase(unittest.TestCase): def setUp(self): app = Flask(__name__) app.debug = False app.config['CACHE_TYPE'] = 'simple' self.cache = Cache() self.cache.init_app(app) self.app = app def tearDown(self): self.app = None self.cache = None self.tc = None def test_00_set(self): self.cache.set('hi', 'hello') assert self.cache.get('hi') == 'hello' def test_01_add(self): self.cache.add('hi', 'hello') assert self.cache.get('hi') == 'hello' self.cache.add('hi', 'foobar') assert self.cache.get('hi') == 'hello' def test_02_delete(self): self.cache.set('hi', 'hello') self.cache.delete('hi') assert self.cache.get('hi') is None def test_03_cached_view(self): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data time.sleep(2) rv = tc.get('/') assert the_time == rv.data time.sleep(5) rv = tc.get('/') assert the_time != rv.data def test_04_cached_view_unless(self): @self.app.route('/a') @self.cache.cached(5, unless=lambda: True) def non_cached_view(): return str(time.time()) @self.app.route('/b') @self.cache.cached(5, unless=lambda: False) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/a') the_time = rv.data time.sleep(1) rv = tc.get('/a') assert the_time != rv.data rv = tc.get('/b') the_time = rv.data time.sleep(1) rv = tc.get('/b') assert the_time == rv.data def test_05_cached_function(self): with self.app.test_request_context(): @self.cache.cached(2, key_prefix='MyBits') def get_random_bits(): return [random.randrange(0, 2) for i in range(50)] my_list = get_random_bits() his_list = get_random_bits() assert my_list == his_list time.sleep(4) his_list = get_random_bits() assert my_list != his_list def test_06_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a+b+random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result result2 = big_foo(5, 3) assert result2 != result time.sleep(4) assert big_foo(5, 2) != result assert big_foo(5, 3) == result2 time.sleep(1) assert big_foo(5, 3) != result2 def test_07_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a+b+random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result self.cache.delete_memoized('big_foo') assert big_foo(5, 2) != result
import uuid from difflib import HtmlDiff from subprocess import Popen, PIPE from opster import command from flask import Flask, redirect from flaskext.cache import Cache from jinja2 import Template app = Flask(__name__) app.config["TESTING"] = False app.config["CACHE_TYPE"] = "memcached" app.config["CACHE_MEMCACHED_SERVERS"] = ["127.0.0.1:11211"] cache = Cache() cache.init_app(app) TOKEN_NO_FILE = str(uuid.uuid4()) TOKEN_NO_SERVER = str(uuid.uuid4()) def get_watch_data(diff_servers, diff_files): """Retrieve the contents of the files in diff_files from the servers in diff_servers. :param diff_servers: A list of host names where to look for the files. :param diff_files: A list of filenames to retrieve. :returns: A dictionary of {diff_server: {diff_file: contents}} """ username = app.config.get("SSH_USERNAME") watch_data = dict()
def test_18_dict_config_initapp(self): cache = Cache() cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) assert cache.config['CACHE_TYPE'] == 'simple'
def test_17_dict_config(self): cache = Cache(config={'CACHE_TYPE': 'simple'}) cache.init_app(self.app) assert cache.config['CACHE_TYPE'] == 'simple'
def create_app_ext(flask_config_file=None, flask_config_dict=None, moin_config_class=None, warn_default=True, **kwargs): """ Factory for moin wsgi apps @param flask_config_file: a flask config file name (may have a MOINCFG class), if not given, a config pointed to by MOINCFG env var will be loaded (if possible). @param flask_config_dict: a dict used to update flask config (applied after flask_config_file was loaded [if given]) @param moin_config_class: if you give this, it'll be instantiated as app.cfg, otherwise it'll use MOINCFG from flask config. If that also is not there, it'll use the DefaultConfig built into MoinMoin. @oaram warn_default: emit a warning if moin falls back to its builtin default config (maybe user forgot to specify MOINCFG?) @param **kwargs: if you give additional key/values here, they'll get patched into the moin configuration class (before it instance is created) """ clock = Clock() clock.start('create_app total') app = Flask('MoinMoin') clock.start('create_app load config') if flask_config_file: app.config.from_pyfile(flask_config_file) else: app.config.from_envvar('MOINCFG', silent=True) if flask_config_dict: app.config.update(flask_config_dict) Config = moin_config_class if not Config: Config = app.config.get('MOINCFG') if not Config: if warn_default: logging.warning("using builtin default configuration") from MoinMoin.config.default import DefaultConfig as Config for key, value in kwargs.iteritems(): setattr(Config, key, value) if Config.secrets is None: # reuse the secret configured for flask (which is required for sessions) Config.secrets = app.config.get('SECRET_KEY') app.cfg = Config() clock.stop('create_app load config') clock.start('create_app register') # register converters from werkzeug.routing import PathConverter app.url_map.converters['itemname'] = PathConverter # register modules, before/after request functions from MoinMoin.apps.frontend import frontend frontend.before_request(before_wiki) frontend.after_request(after_wiki) app.register_module(frontend) from MoinMoin.apps.admin import admin admin.before_request(before_wiki) admin.after_request(after_wiki) app.register_module(admin, url_prefix='/+admin') from MoinMoin.apps.feed import feed feed.before_request(before_wiki) feed.after_request(after_wiki) app.register_module(feed, url_prefix='/+feed') from MoinMoin.apps.misc import misc misc.before_request(before_wiki) misc.after_request(after_wiki) app.register_module(misc, url_prefix='/+misc') from MoinMoin.apps.serve import serve app.register_module(serve, url_prefix='/+serve') clock.stop('create_app register') clock.start('create_app flask-cache') cache = Cache() cache.init_app(app) app.cache = cache clock.stop('create_app flask-cache') # init storage clock.start('create_app init backends') app.unprotected_storage, app.storage = init_backends(app) clock.stop('create_app init backends') clock.start('create_app index rebuild') if app.cfg.index_rebuild: app.unprotected_storage.index_rebuild() # XXX run this from a script clock.stop('create_app index rebuild') clock.start('create_app load/save xml') import_export_xml(app) clock.stop('create_app load/save xml') clock.start('create_app flask-babel') i18n_init(app) clock.stop('create_app flask-babel') # configure templates clock.start('create_app flask-themes') setup_themes(app) if app.cfg.template_dirs: app.jinja_env.loader = ChoiceLoader([ FileSystemLoader(app.cfg.template_dirs), app.jinja_env.loader, ]) app.error_handlers[403] = themed_error clock.stop('create_app flask-themes') clock.stop('create_app total') del clock return app
def test_19_dict_config_both(self): cache = Cache(config={'CACHE_TYPE': 'null'}) cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) assert cache.config['CACHE_TYPE'] == 'simple'
class CacheTestCase(unittest.TestCase): def setUp(self): app = Flask(__name__) app.debug = False app.config["CACHE_TYPE"] = "simple" self.cache = Cache() self.cache.init_app(app) self.app = app def tearDown(self): self.app = None self.cache = None self.tc = None def test_00_set(self): self.cache.set("hi", "hello") assert self.cache.get("hi") == "hello" def test_01_add(self): self.cache.add("hi", "hello") assert self.cache.get("hi") == "hello" self.cache.add("hi", "foobar") assert self.cache.get("hi") == "hello" def test_02_delete(self): self.cache.set("hi", "hello") self.cache.delete("hi") assert self.cache.get("hi") is None def test_03_cached_view(self): @self.app.route("/") @self.cache.cached(5) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get("/") the_time = rv.data time.sleep(2) rv = tc.get("/") assert the_time == rv.data time.sleep(5) rv = tc.get("/") assert the_time != rv.data def test_04_cached_view_unless(self): @self.app.route("/a") @self.cache.cached(5, unless=lambda: True) def non_cached_view(): return str(time.time()) @self.app.route("/b") @self.cache.cached(5, unless=lambda: False) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get("/a") the_time = rv.data time.sleep(1) rv = tc.get("/a") assert the_time != rv.data rv = tc.get("/b") the_time = rv.data time.sleep(1) rv = tc.get("/b") assert the_time == rv.data def test_05_cached_function(self): with self.app.test_request_context(): @self.cache.cached(2, key_prefix="MyBits") def get_random_bits(): return [random.randrange(0, 2) for i in range(50)] my_list = get_random_bits() his_list = get_random_bits() assert my_list == his_list time.sleep(4) his_list = get_random_bits() assert my_list != his_list def test_06_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a + b + random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result result2 = big_foo(5, 3) assert result2 != result time.sleep(4) assert big_foo(5, 2) != result assert big_foo(5, 3) == result2 time.sleep(1) assert big_foo(5, 3) != result2 def test_07_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a + b + random.randrange(0, 100000) result = big_foo(5, 2) result2 = big_foo(5, 3) time.sleep(1) assert big_foo(5, 2) == result assert big_foo(5, 2) == result assert big_foo(5, 3) != result assert big_foo(5, 3) == result2 self.cache.delete_memoized("big_foo") assert big_foo(5, 2) != result assert big_foo(5, 3) != result2 def test_08_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return a + b + random.randrange(0, 100000) result_a = big_foo(5, 1) result_b = big_foo(5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) == result_b self.cache.delete_memoized("big_foo", 5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) != result_b def test_09_args_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return sum(a) + sum(b) + random.randrange(0, 100000) result_a = big_foo([5, 3, 2], [1]) result_b = big_foo([3, 3], [3, 1]) assert big_foo([5, 3, 2], [1]) == result_a assert big_foo([3, 3], [3, 1]) == result_b self.cache.delete_memoized("big_foo", [5, 3, 2], [1]) assert big_foo([5, 3, 2], [1]) != result_a assert big_foo([3, 3], [3, 1]) == result_b def test_10_kwargs_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b=None): return a + sum(b.values()) + random.randrange(0, 100000) result_a = big_foo(1, dict(one=1, two=2)) result_b = big_foo(5, dict(three=3, four=4)) assert big_foo(1, dict(one=1, two=2)) == result_a assert big_foo(5, dict(three=3, four=4)) == result_b self.cache.delete_memoized("big_foo", 1, dict(one=1, two=2)) assert big_foo(1, dict(one=1, two=2)) != result_a assert big_foo(5, dict(three=3, four=4)) == result_b def test_11_cache_key_property(self): @self.app.route("/") @self.cache.cached(5) def cached_view(): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get("/") the_time = rv.data with self.app.test_request_context(): cache_data = self.cache.get(cached_view.make_cache_key()) assert the_time == cache_data def test_12_make_cache_key_function_property(self): @self.app.route("/<foo>/<bar>") @self.cache.memoize(5) def cached_view(foo, bar): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get("/a/b") the_time = rv.data cache_key = cached_view.make_cache_key(cached_view.uncached, foo=u"a", bar=u"b") cache_data = self.cache.get(cache_key) assert the_time == cache_data different_key = cached_view.make_cache_key(cached_view.uncached, foo=u"b", bar=u"a") different_data = self.cache.get(different_key) assert the_time != different_data def test_13_cache_timeout_property(self): @self.app.route("/") @self.cache.memoize(5) def cached_view1(): return str(time.time()) @self.app.route("/<foo>/<bar>") @self.cache.memoize(10) def cached_view2(foo, bar): return str(time.time()) assert hasattr(cached_view1, "cache_timeout") assert hasattr(cached_view2, "cache_timeout") assert cached_view1.cache_timeout == 5 assert cached_view2.cache_timeout == 10 # test that this is a read-write property cached_view1.cache_timeout = 2 cached_view2.cache_timeout = 3 assert cached_view1.cache_timeout == 2 assert cached_view2.cache_timeout == 3 tc = self.app.test_client() rv1 = tc.get("/") time1 = rv1.data time.sleep(1) rv2 = tc.get("/a/b") time2 = rv2.data # VIEW1 # it's been 1 second, cache is still active assert time1 == tc.get("/").data time.sleep(2) # it's been 3 seconds, cache is not still active assert time1 != tc.get("/").data # VIEW2 # it's been 2 seconds, cache is still active assert time2 == tc.get("/a/b").data time.sleep(2) # it's been 4 seconds, cache is not still active assert time2 != tc.get("/a/b").data def test_14_memoized_multiple_arg_kwarg_calls(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b, c=[1, 1], d=[1, 1]): return sum(a) + sum(b) + sum(c) + sum(d) + random.randrange(0, 100000) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert big_foo([5, 3, 2], [1], d=[3, 3], c=[3, 3]) == result_a assert big_foo(b=[1], a=[5, 3, 2], c=[3, 3], d=[3, 3]) == result_a assert big_foo([5, 3, 2], [1], [3, 3], [3, 3]) == result_a def test_15_memoize_multiple_arg_kwarg_delete(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b, c=[1, 1], d=[1, 1]): return sum(a) + sum(b) + sum(c) + sum(d) + random.randrange(0, 100000) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) self.cache.delete_memoized("big_foo", [5, 3, 2], [1], [3, 3], [3, 3]) result_b = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], b=[1], c=[3, 3], d=[3, 3]) result_b = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], [1], c=[3, 3], d=[3, 3]) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], b=[1], c=[3, 3], d=[3, 3]) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], [1], c=[3, 3], d=[3, 3]) result_b = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized("big_foo", [5, 3, 2], [1], [3, 3], [3, 3]) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b def test_16_memoize_kwargs_to_args(self): with self.app.test_request_context(): def big_foo(a, b, c=None, d=None): return sum(a) + sum(b) + random.randrange(0, 100000) expected = (1, 2, "foo", "bar") args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 1, 2, "foo", "bar") assert args == expected args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 2, "foo", "bar", a=1) assert args == expected args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, a=1, b=2, c="foo", d="bar") assert args == expected args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, d="bar", b=2, a=1, c="foo") assert args == expected args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 1, 2, d="bar", c="foo") assert args == expected
class CacheTestCase(unittest.TestCase): def setUp(self): app = Flask(__name__) app.debug = False app.config['CACHE_TYPE'] = 'simple' self.cache = Cache() self.cache.init_app(app) self.app = app def tearDown(self): self.app = None self.cache = None self.tc = None def test_00_set(self): self.cache.set('hi', 'hello') assert self.cache.get('hi') == 'hello' def test_01_add(self): self.cache.add('hi', 'hello') assert self.cache.get('hi') == 'hello' self.cache.add('hi', 'foobar') assert self.cache.get('hi') == 'hello' def test_02_delete(self): self.cache.set('hi', 'hello') self.cache.delete('hi') assert self.cache.get('hi') is None def test_03_cached_view(self): with self.app.test_request_context(): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data time.sleep(2) rv = tc.get('/') assert the_time == rv.data time.sleep(5) rv = tc.get('/') assert the_time != rv.data def test_04_cached_view_unless(self): with self.app.test_request_context(): @self.app.route('/a') @self.cache.cached(5, unless=lambda: True) def non_cached_view(): return str(time.time()) @self.app.route('/b') @self.cache.cached(5, unless=lambda: False) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/a') the_time = rv.data time.sleep(1) rv = tc.get('/a') assert the_time != rv.data rv = tc.get('/b') the_time = rv.data time.sleep(1) rv = tc.get('/b') assert the_time == rv.data def test_05_cached_function(self): with self.app.test_request_context(): @self.cache.cached(2, key_prefix='MyBits') def get_random_bits(): return [random.randrange(0, 2) for i in range(50)] my_list = get_random_bits() his_list = get_random_bits() assert my_list == his_list time.sleep(4) his_list = get_random_bits() assert my_list != his_list def test_06_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a + b + random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result result2 = big_foo(5, 3) assert result2 != result time.sleep(4) assert big_foo(5, 2) != result assert big_foo(5, 3) == result2 time.sleep(1) assert big_foo(5, 3) != result2 def test_07_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a + b + random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result assert big_foo(5, 2) == result assert big_foo(5, 3) != result self.cache.delete_memoized('big_foo') assert big_foo(5, 2) != result def test_08_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return a + b + random.randrange(0, 100000) result_a = big_foo(5, 1) result_b = big_foo(5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) == result_b self.cache.delete_memoized('big_foo', 5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) != result_b def test_09_args_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return sum(a) + sum(b) + random.randrange(0, 100000) result_a = big_foo([5, 3, 2], [1]) result_b = big_foo([3, 3], [3, 1]) assert big_foo([5, 3, 2], [1]) == result_a assert big_foo([3, 3], [3, 1]) == result_b self.cache.delete_memoized('big_foo', [5, 3, 2], [1]) assert big_foo([5, 3, 2], [1]) != result_a assert big_foo([3, 3], [3, 1]) == result_b def test_10_kwargs_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b=None): return a + sum(b.values()) + random.randrange(0, 100000) result_a = big_foo(1, dict(one=1, two=2)) result_b = big_foo(5, dict(three=3, four=4)) assert big_foo(1, dict(one=1, two=2)) == result_a assert big_foo(5, dict(three=3, four=4)) == result_b self.cache.delete_memoized('big_foo', 1, dict(one=1, two=2)) assert big_foo(1, dict(one=1, two=2)) != result_a assert big_foo(5, dict(three=3, four=4)) == result_b def test_11_cache_key_property(self): with self.app.test_request_context(): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) assert hasattr(cached_view, "cache_key") assert isinstance(cached_view.cache_key, basestring) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data cache_data = self.cache.get(cached_view.cache_key) assert the_time == cache_data def test_12_make_cache_key_function_property(self): with self.app.test_request_context(): @self.app.route('/<foo>/<bar>') @self.cache.memoize(5) def cached_view(foo, bar): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get('/a/b') the_time = rv.data cache_key = cached_view.make_cache_key(foo=u"a", bar=u"b") cache_data = self.cache.get(cache_key) assert the_time == cache_data different_key = cached_view.make_cache_key(foo=u"b", bar=u"a") different_data = self.cache.get(different_key) assert the_time != different_data def test_13_cache_timeout_property(self): with self.app.test_request_context(): @self.app.route('/') @self.cache.memoize(5) def cached_view1(): return str(time.time()) @self.app.route('/<foo>/<bar>') @self.cache.memoize(10) def cached_view2(foo, bar): return str(time.time()) assert hasattr(cached_view1, "cache_timeout") assert hasattr(cached_view2, "cache_timeout") assert cached_view1.cache_timeout == 5 assert cached_view2.cache_timeout == 10 # test that this is a read-write property cached_view1.cache_timeout = 2 cached_view2.cache_timeout = 3 assert cached_view1.cache_timeout == 2 assert cached_view2.cache_timeout == 3 tc = self.app.test_client() rv1 = tc.get('/') time1 = rv1.data time.sleep(1) rv2 = tc.get('/a/b') time2 = rv2.data # VIEW1 # it's been 1 second, cache is still active assert time1 == tc.get('/').data time.sleep(2) # it's been 3 seconds, cache is not still active assert time1 != tc.get('/').data # VIEW2 # it's been 2 seconds, cache is still active assert time2 == tc.get('/a/b').data time.sleep(2) # it's been 4 seconds, cache is not still active assert time2 != tc.get('/a/b').data
def create_app_ext(flask_config_file=None, flask_config_dict=None, moin_config_class=None, warn_default=True, **kwargs ): """ Factory for moin wsgi apps :param flask_config_file: a flask config file name (may have a MOINCFG class), if not given, a config pointed to by MOINCFG env var will be loaded (if possible). :param flask_config_dict: a dict used to update flask config (applied after flask_config_file was loaded [if given]) :param moin_config_class: if you give this, it'll be instantiated as app.cfg, otherwise it'll use MOINCFG from flask config. If that also is not there, it'll use the DefaultConfig built into MoinMoin. :param warn_default: emit a warning if moin falls back to its builtin default config (maybe user forgot to specify MOINCFG?) :param kwargs: if you give additional keyword args, the keys/values will get patched into the moin configuration class (before its instance is created) """ clock = Clock() clock.start('create_app total') app = Flask('MoinMoin') clock.start('create_app load config') if flask_config_file: app.config.from_pyfile(flask_config_file) else: if not app.config.from_envvar('MOINCFG', silent=True): # no MOINCFG env variable set, try stuff in cwd: from os import path flask_config_file = path.abspath('wikiconfig_local.py') if not path.exists(flask_config_file): flask_config_file = path.abspath('wikiconfig.py') if not path.exists(flask_config_file): flask_config_file = None if flask_config_file: app.config.from_pyfile(flask_config_file) if flask_config_dict: app.config.update(flask_config_dict) Config = moin_config_class if not Config: Config = app.config.get('MOINCFG') if not Config: if warn_default: logging.warning("using builtin default configuration") from MoinMoin.config.default import DefaultConfig as Config for key, value in kwargs.iteritems(): setattr(Config, key, value) if Config.secrets is None: # reuse the secret configured for flask (which is required for sessions) Config.secrets = app.config.get('SECRET_KEY') app.cfg = Config() clock.stop('create_app load config') clock.start('create_app register') # register converters from werkzeug.routing import PathConverter app.url_map.converters['itemname'] = PathConverter # register modules, before/after request functions from MoinMoin.apps.frontend import frontend frontend.before_request(before_wiki) frontend.teardown_request(teardown_wiki) app.register_blueprint(frontend) from MoinMoin.apps.admin import admin admin.before_request(before_wiki) admin.teardown_request(teardown_wiki) app.register_blueprint(admin, url_prefix='/+admin') from MoinMoin.apps.feed import feed feed.before_request(before_wiki) feed.teardown_request(teardown_wiki) app.register_blueprint(feed, url_prefix='/+feed') from MoinMoin.apps.misc import misc misc.before_request(before_wiki) misc.teardown_request(teardown_wiki) app.register_blueprint(misc, url_prefix='/+misc') from MoinMoin.apps.serve import serve app.register_blueprint(serve, url_prefix='/+serve') clock.stop('create_app register') clock.start('create_app flask-cache') cache = Cache() cache.init_app(app) app.cache = cache clock.stop('create_app flask-cache') # init storage clock.start('create_app init backends') init_backends(app) clock.stop('create_app init backends') clock.start('create_app flask-babel') i18n_init(app) clock.stop('create_app flask-babel') # configure templates clock.start('create_app flask-themes') setup_themes(app) if app.cfg.template_dirs: app.jinja_env.loader = ChoiceLoader([ FileSystemLoader(app.cfg.template_dirs), app.jinja_env.loader, ]) app.register_error_handler(403, themed_error) clock.stop('create_app flask-themes') clock.stop('create_app total') del clock return app