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])
