def with_graph_store(*args, **kw): @patch('plural.store.Signature') @patch('plural.store.init_repository') def setup(context, init_repository, Signature): context.store = PluralStore(*args, **kw) context.init_repository = init_repository context.Signature = Signature return scenario(setup)
def with_hexastore(name, **kw): if not os.path.exists(sandbox.path): os.makedirs(sandbox.path) def create_store(context): context.store_path = sandbox.join(name) context.store = GitGraph(os.path.relpath(context.store_path), **kw) def destroy_store(context): if os.path.isdir(context.store_path): shutil.rmtree(context.store_path) return scenario(create_store, destroy_store)
from collections import deque from application.config.core import db from application.config.db_config import DBConfig from application.web import application from sure import scenario def before_each_test(context): DBConfig().handle_existing_database() context.web = application context.http = context.web.test_client() context.session = db.session context.objects = deque() def after_each_test(context): # certainly there is a more elegant way to do this # extensive documentation on db engine and sessionmaker # however it seems to require a major architecture refactor for obj in list(context.objects): context.session.delete(obj) context.session.commit() web_test = scenario(before_each_test, after_each_test)
InvalidColumnName, EngineNotSpecified, InvalidQueryModifier, MultipleEnginesSpecified, ) metadata = MetaData() def reset_db(context): engine = get_or_create_engine('mysql://root@localhost/chemist') metadata.drop_all(engine) metadata.create_all(engine) clean_db = scenario(reset_db, reset_db) class User(Model): table = db.Table( 'md_user', metadata, db.Column('id', db.Integer, primary_key=True), db.Column('github_id', db.Integer, nullable=False, unique=True), db.Column('github_token', db.String(256), nullable=True), db.Column('gravatar_id', db.String(40), nullable=False, unique=True), db.Column('username', db.String(80), nullable=False, unique=True), db.Column('email', db.String(100), nullable=False, unique=True), db.Column('created_at', db.DateTime, default=datetime.now), db.Column('updated_at', db.DateTime, default=datetime.now)) class DummyUserModel(Model):
from os.path import relpath from .base import LOCAL_FILE def prepare(context): context.project_path = LOCAL_FILE('sandbox_mixed') context.theme_path = LOCAL_FILE('sandbox_mixed/simpletheme') context.output_path = LOCAL_FILE('sandbox_mixed/output') def cleanup(context): if os.path.exists(context.output_path): shutil.rmtree(context.output_path) fs_test = scenario([prepare], [cleanup]) sort_files = lambda x: "{0}{1}".format(len(relpath(x).split(os.sep)), x) filter_html = lambda files: [i for i in files if i.endswith('.html')] @fs_test def test_first_level_file(context): "The first level file should have the assets pointing to the right path" project = Project.discover(context.project_path) theme = Theme.load_from_path(context.theme_path) destination = Generator(project, theme) generated = sorted(filter_html(destination.persist(context.output_path)), key=lambda x: len(x.split(os.sep))) generated.should.have.length_of(2)
# -*- coding: utf-8 -*- from __future__ import unicode_literals from repocket import configure from sure import scenario def prepare_redis(context): context.pool = configure.connection_pool( hostname='localhost', port=6379 ) context.connection = context.pool.get_connection() sweep_redis(context) def sweep_redis(context): context.connection.flushall() clean_slate = scenario([prepare_redis], [sweep_redis])
def reset_redis_database(context): context.redis = get_redis_connection() context.redis.flushall() def session_url(*ctx_args, **ctx_kw): def contextual(func): @functools.wraps(func) def wrapper(*args, **kw): with server.test_request_context(*ctx_args, **ctx_kw): return func(*args, **kw) return api_test(wrapper) return contextual api_test = scenario( [ turn_on_api_client, reset_redis_database, reset_sql_database, ], [ turn_off_api_client, reset_redis_database, reset_sql_database, ] )
def prepare_storage(context): target = settings.OLDSPEAK_DATADIR if os.path.isdir(target): shutil.rmtree(target) os.makedirs(target) def cleanup_storage(context): # utcnow = datetime.utcnow() # shutil.copytree(settings.OLDSPEAK_DATADIR, '_'.join((settings.OLDSPEAK_DATADIR, utcnow.isoformat()))) pass storage_scenario = scenario([prepare_storage], [cleanup_storage]) web_scenario = scenario([prepare_storage, prepare_sql, prepare_server], [cleanup_server, cleanup_sql, cleanup_storage]) sql_scenario = scenario(prepare_sql, cleanup_sql) api_admin_scenario = scenario( [prepare_sql, prepare_server, prepare_admin_scenario], [cleanup_server, cleanup_sql]) api_user_scenario = scenario( [prepare_sql, prepare_server, prepare_subscriber_scenario], [cleanup_server, cleanup_sql]) def cookies(response): return "".join(response.headers.getlist('Set-Cookie'))
from sure import scenario from os.path import relpath from .base import LOCAL_FILE def prepare(context): context.project_path = LOCAL_FILE('sandbox_simple') context.output_path = LOCAL_FILE('output') def cleanup(context): if os.path.exists(context.output_path): shutil.rmtree(context.output_path) fs_test = scenario([prepare], [cleanup]) sort_files = lambda x: (len(relpath(x).split(os.sep)), x) @fs_test def test_generate_files(context): "Markment should find files and generate them" project = Project.discover(context.project_path) theme = Theme.load_by_name('touch-of-pink') destination = Generator(project, theme) generated = sorted(destination.persist(context.output_path), key=sort_files) generated.should.be.a(list) map(relpath, generated).should.equal(map(relpath, [ LOCAL_FILE('output/index.html'), LOCAL_FILE('output/assets/style.css'),
return handler def nodes_from_call(handler): nodes = [] for call in handler.call_args_list: nodes.append(call[0][-1].__class__) return nodes def clear_events(context): Events.release_all() event_test = scenario(clear_events, clear_events) class FakeConnection(object): def __init__(self): self.output = [] self.on = create_connection_events() def send(self, data): self.output.append(data) class FakeXMLStream(object): """Fake XMLStream that is used for testing extensions that send nodes to the server. """
#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import unicode_literals from sure import scenario from datetime import date from freezegun import freeze_time from lunch.models import Person, WeeklyGroup def cleanup(context): for Model in [Person, WeeklyGroup]: Model.objects.all().delete() clean_test_db = scenario(cleanup, cleanup) @clean_test_db def test_groups_can_be_created_randomly(context): ("Groups should be created from a certain number") # Given there are 4 people in the databse people_going = [ Person.objects.create(name='Unaiz', email='*****@*****.**').id, Person.objects.create(name='Sean', email='*****@*****.**').id, Person.objects.create(name='Jordan', email='*****@*****.**').id, Person.objects.create(name='Jim', email='*****@*****.**').id, ] # When I create groups randomly groups = WeeklyGroup.generate_random(people_going, total_groups=2)
#!/usr/bin/env python # -*- coding: utf-8 -*- # from __future__ import unicode_literals from sure import scenario from lineup import JSONRedisBackend from threading import RLock test_lock = RLock() def prepare_redis(context): context.backend = JSONRedisBackend() context.redis = context.backend.redis context.redis.flushall() test_lock.acquire() def unlock(context): test_lock.release() redis_test = scenario([prepare_redis], [unlock])
from sure import scenario from flask_app.web import application from flask_app.models import metadata, engine from flask_app.managers import UserManager def prepare_db(context): set_default_uri('sqlite:///:memory:') metadata.drop_all(engine) metadata.create_all(engine) def prepare_user_manager(context): context.users = UserManager() def prepare_api(context): context.http = application.test_client() with_temp_database = scenario(prepare_db) with_user_manager = scenario([prepare_db, prepare_user_manager]) web_test = scenario([prepare_db, prepare_user_manager, prepare_api])
# <redisgpg - filesystem for humans> # Copyright (C) <2013> Gabriel Falcão <*****@*****.**> # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from __future__ import unicode_literals from os.path import dirname, abspath, join LOCAL_FILE = lambda *path: join(abspath(dirname(__file__)), *path) from sure import scenario from redisgpg import GPGRedis def prepare(context): context.redis = GPGRedis(gpg_home=LOCAL_FILE('keys'), gpg_email='*****@*****.**') specification = scenario([prepare], [])
"public_repos": 2, "public_gists": 1, "followers": 20, "following": 0, "created_at": "2008-01-14T04:33:35Z", "updated_at": "2008-01-14T04:33:35Z", "total_private_repos": 100, "owned_private_repos": 100, "private_gists": 81, "disk_usage": 10000, "collaborators": 8, "plan": { "name": "Medium", "space": 400, "private_repos": 20, "collaborators": 0 } })) context.headers = { 'Content-Type': 'application/json', 'Authorization': 'Bearer: {0}'.format(context.user.carpentry_token) } def disable_httpretty(context): httpretty.disable() safe_db = scenario(prepare_redis, sweep_redis) api = scenario([prepare_redis, prepare_http_client], [sweep_redis, disable_httpretty])
#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import unicode_literals from sure import scenario from datetime import date from freezegun import freeze_time from lunch.models import Person, WeeklyGroup def cleanup(context): for Model in [Person, WeeklyGroup]: Model.objects.all().delete() clean_test_db = scenario(cleanup, cleanup) @clean_test_db def test_groups_can_be_created_randomly(context): ("Groups should be created from a certain number") # Given there are 4 people in the databse people_going = [ Person.objects.create(name='Unaiz', email='*****@*****.**').id, Person.objects.create(name='Sean', email='*****@*****.**').id, Person.objects.create(name='Jordan', email='*****@*****.**').id, Person.objects.create(name='Jim', email='*****@*****.**').id, ] # When I create groups randomly groups = WeeklyGroup.generate_random(people_going, total_groups=2) # Then there should be 2 groups
import os import sleepyhollow from sure import scenario def prepare_server(context): context.port = int(os.environ['TEST_SERVER_PORT']) def route_to(path): params = context.port, path.lstrip('/') return 'http://127.0.0.1:%d/%s' % params context.route_to = route_to def clear_server(context): pass server_test_case = scenario(prepare_server, clear_server) def qt_version_check(min_version): def wrapper(func): if sleepyhollow.QT_VERSION >= min_version: return func else: return lambda: None return wrapper
from chemist import context as chemist_context Postgresql = testing.postgresql.PostgresqlFactory(cache_initialized_db=True) def reset_db(context): context.postgresql = Postgresql() metadata = chemist_context.set_default_uri(context.postgresql.url()) metadata.create_all() def cleanup_db(context): context.postgresql.stop() clean_db = scenario(reset_db, cleanup_db) class User(Model): table = db.Table('md_user', metadata, db.Column('id', db.Integer, primary_key=True), db.Column('github_id', db.Integer, nullable=False, unique=True), db.Column('github_token', db.String(256), nullable=True), db.Column('gravatar_id', db.String(40), nullable=False, unique=True), db.Column('username', db.String(80), nullable=False, unique=True), db.Column('email', db.String(100), nullable=False, unique=True), db.Column('created_at', db.DateTime, default=datetime.now), db.Column('updated_at', db.DateTime, default=datetime.now)) class DummyUserModel(Model):
import os import sleepyhollow from sure import scenario def prepare_server(context): context.port = int(os.environ["TEST_SERVER_PORT"]) def route_to(path): params = context.port, path.lstrip("/") return "http://127.0.0.1:%d/%s" % params context.route_to = route_to def clear_server(context): pass server_test_case = scenario(prepare_server, clear_server) def qt_version_check(min_version): def wrapper(func): if sleepyhollow.QT_VERSION >= min_version: return func else: return lambda: None return wrapper
from plant import Node from p4rr0t007.web import Application def prepare_app(context): context.node = Node(__file__) context.app = Application(context.node) @context.app.route('/html') def html(): return context.app.template_response('index.html') @context.app.route('/text') def text(): return context.app.text_response('text') @context.app.route('/json') def json(): return context.app.json_response({ 'name': 'p4rr0t007' }) @context.app.route('/error') def error(): raise IOError('emulating a 500') context.http = context.app.test_client() web_scenario = scenario(prepare_app)
# -*- coding: utf-8 -*- from __future__ import unicode_literals from repocket import configure from sure import scenario def prepare_redis(context): context.pool = configure.connection_pool(hostname='localhost', port=6379) context.connection = context.pool.get_connection() sweep_redis(context) def sweep_redis(context): context.connection.flushall() clean_slate = scenario([prepare_redis], [sweep_redis])