class Test_copy_dir(unittest.TestCase):
def setUp(self):
import tempfile
from pyramid.compat import NativeIO
self.dirname = tempfile.mkdtemp()
self.out = NativeIO()
self.fixturetuple = ('pyramid.tests.test_scaffolds',
'fixture_scaffold')
def tearDown(self):
import shutil
shutil.rmtree(self.dirname, ignore_errors=True)
self.out.close()
def _callFUT(self, *arg, **kw):
kw['out_'] = self.out
from pyramid.scaffolds.copydir import copy_dir
return copy_dir(*arg, **kw)
def test_copy_source_as_pkg_resource(self):
vars = {'package':'mypackage'}
self._callFUT(self.fixturetuple,
self.dirname,
vars,
1, False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Creating %s/mypackage/' % self.dirname in result)
self.assertTrue(
'Copying fixture_scaffold/+package+/__init__.py_tmpl to' in result)
source = pkg_resources.resource_filename(
'pyramid.tests.test_scaffolds',
'fixture_scaffold/+package+/__init__.py_tmpl')
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'r') as f:
tcontent = f.read()
with open(source, 'r') as f:
scontent = f.read()
self.assertEqual(scontent, tcontent)
def test_copy_source_as_dirname(self):
vars = {'package':'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1, False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Creating %s/mypackage/' % self.dirname in result)
self.assertTrue('Copying __init__.py_tmpl to' in result)
source = pkg_resources.resource_filename(
'pyramid.tests.test_scaffolds',
'fixture_scaffold/+package+/__init__.py_tmpl')
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'r') as f:
tcontent = f.read()
with open(source, 'r') as f:
scontent = f.read()
self.assertEqual(scontent, tcontent)
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_run_stop_daemon_no_such_pid_file(self):
path = os.path.join(os.path.dirname(__file__), 'wontexist.pid')
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
self.assertEqual(self.out_.getvalue(),'No PID file exists in %s' %
path)
def test_run_stop_daemon_bad_pid_file(self):
path = __file__
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
self.assertEqual(
self.out_.getvalue(),'Not a valid PID file in %s' % path)
def test_run_stop_daemon_invalid_pid_in_file(self):
fn = tempfile.mktemp()
with open(fn, 'wb') as tmp:
tmp.write(b'9999999')
tmp.close()
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % fn)
inst.run()
self.assertEqual(self.out_.getvalue(),
'PID in %s is not valid (deleting)' % fn)
def test_parse_vars_good(self):
vars = ['a=1', 'b=2']
inst = self._makeOne('development.ini')
result = inst.parse_vars(vars)
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
vars = ['a']
inst = self._makeOne('development.ini')
self.assertRaises(ValueError, inst.parse_vars, vars)
def test_truncating_formatter(self):
buf = NativeIO()
logger = logging.Logger('test', logging.DEBUG)
hdlr = StreamHandler(buf)
hdlr.setFormatter(TruncatingFormatter())
logger.addHandler(hdlr)
logger.debug('%s', 'X' * 99, extra=dict(output_limit=100))
self.assert_equal(len(buf.getvalue().strip()), 99)
buf.seek(0)
buf.truncate()
logger.debug('%s', 'X' * 101, extra=dict(output_limit=100))
self.assert_equal(len(buf.getvalue().strip()), 100)
def test_truncating_formatter(self):
buf = NativeIO()
logger = logging.Logger('test', logging.DEBUG)
hdlr = StreamHandler(buf)
hdlr.setFormatter(TruncatingFormatter())
logger.addHandler(hdlr)
logger.debug('%s', 'X' * 99, extra=dict(output_limit=100))
self.assert_equal(len(buf.getvalue().strip()), 99)
buf.seek(0)
buf.truncate()
logger.debug('%s', 'X' * 101, extra=dict(output_limit=100))
self.assert_equal(len(buf.getvalue().strip()), 100)
def test_build_tree(self, m_bs):
m_bs.return_value = {
'registry': self.registry,
'request': self.request
}
sys.argv[1:] = ['--deps', 'pyramid_amdjs.ini']
self.registry[ID_AMD_MODULE] = {
'test': {
'path': 'pyramid_amdjs:tests/dir/test.js'
}
}
self.registry[ID_AMD_SPEC] = {'test': {'test': {}}}
out = NativeIO()
stdout = sys.stdout
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* Spec: test', val)
self.assertIn('jca', val)
self.assertIn('test', val)
def to_string(self, obj):
"""
Converts the given resource to a string representation and returns
it.
"""
stream = NativeIO()
self.to_stream(obj, stream)
return stream.getvalue()
def print_tb(self):
if self.isexc and self.exc_value:
out = NativeIO()
traceback.print_exception(
self.exc_type, self.exc_value, self.exc_traceback, file=out)
return out.getvalue()
else:
return self.exc
def to_string(self, obj):
"""
Converts the given resource to a string representation and returns
it.
"""
stream = NativeIO()
self.to_stream(obj, stream)
return text_(stream.getvalue(), encoding=self.encoding)
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _get_server(*args, **kwargs):
def server(app):
return ''
return server
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_get_options_no_command(self):
inst = self._makeOne()
inst.args = ['foo', 'a=1', 'b=2']
result = inst.get_options()
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_good(self):
from pyramid.tests.test_scripts.dummy import DummyApp
inst = self._makeOne('development.ini', 'a=1', 'b=2')
inst.loadserver = self._get_server
app = DummyApp()
def get_app(*args, **kwargs):
app.global_conf = kwargs.get('global_conf', None)
inst.loadapp = get_app
inst.run()
self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
inst = self._makeOne('development.ini', 'a')
inst.loadserver = self._get_server
self.assertRaises(ValueError, inst.run)
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _get_server(*args, **kwargs):
def server(app):
return ''
return server
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_get_options_no_command(self):
inst = self._makeOne()
inst.args = ['foo', 'a=1', 'b=2']
result = inst.get_options()
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_good(self):
from pyramid.tests.test_scripts.dummy import DummyApp
inst = self._makeOne('development.ini', 'a=1', 'b=2')
inst.loadserver = self._get_server
app = DummyApp()
def get_app(*args, **kwargs):
app.global_conf = kwargs.get('global_conf', None)
inst.loadapp = get_app
inst.run()
self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
inst = self._makeOne('development.ini', 'a')
inst.loadserver = self._get_server
self.assertRaises(ValueError, inst.run)
def Api(request):
""" Rest API interface """
response = request.response
# authentication by token
token = request.environ.get('HTTP_X_AUTH_TOKEN')
if token:
secret = ptah.get_settings(ptah.CFG_ID_PTAH, request.registry)['secret']
try:
timestamp, userid, tokens, user_data = parse_ticket(
secret, '%s!' % token, '0.0.0.0')
except BadTicket:
userid = None
if userid:
ptah.auth_service.set_userid(userid)
# search service and action
service = request.matchdict['service']
subpath = request.matchdict['subpath']
if subpath:
action = subpath[0]
arguments = subpath[1:]
if ':' in action:
action, arg = action.split(':', 1)
arguments = (arg,) + arguments
else:
action = 'apidoc'
arguments = ()
request.environ['SCRIPT_NAME'] = '/__rest__/%s' % service
response.headerslist = {'Content-Type': 'application/json'}
# execute action for specific service
try:
result = config.get_cfg_storage(ID_REST)[service](
request, action, *arguments)
except WSGIHTTPException as exc:
response.status = exc.status
result = {'message': str(exc)}
except Exception as exc:
response.status = 500
out = NativeIO()
traceback.print_exc(file=out)
result = {'message': str(exc),
'traceback': out.getvalue()}
if isinstance(result, Response):
return result
response.text = text_(
dumps(result, indent=True, default=dthandler), 'utf-8')
return response
def get_traceback():
"""
Fetches the last traceback from :var:`sys.exc_info` and returns it as a
formatted string.
:returns: formatted traceback (string)
"""
buf = NativeIO()
traceback.print_exc(file=buf)
return buf.getvalue()
def get_traceback():
"""
Fetches the last traceback from :var:`sys.exc_info` and returns it as a
formatted string.
:returns: formatted traceback (string)
"""
buf = NativeIO()
traceback.print_exc(file=buf)
return buf.getvalue()
def print_tb(self):
if self.isexc and self.exc_value:
out = NativeIO()
traceback.print_exception(self.exc_type,
self.exc_value,
self.exc_traceback,
file=out)
return out.getvalue()
else:
return self.exc
def test_list_models(self):
@ptah.tinfo(
'custom', title='Custom model',
description = 'Custom model description')
class CustomModel(object):
""" Custom module description """
title = 'Custom Module'
self.init_ptah()
sys.argv[1:] = ['--list-models', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* type:custom: Custom model (disabled: False)', val)
self.assertIn('Custom model description', val)
self.assertIn('class: CustomModel', val)
self.assertIn('module: test_manage', val)
# disable
cfg = ptah.get_settings(ptah.CFG_ID_PTAH)
cfg['disable_models'] = ('type:custom',)
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* type:custom: Custom model (disabled: True)', val)
def data_to_string(self, data_element):
"""
Converts the given data element into a string representation.
:param data_element: object implementing
:class:`everest.representers.interfaces.IExplicitDataElement`
:returns: string representation (using the MIME content type
configured for this representer)
"""
stream = NativeIO()
self.data_to_stream(data_element, stream)
return stream.getvalue()
def string_from_data(self, data_element):
"""
Converts the given data element into a string representation.
:param data_element: object implementing
:class:`everest.representers.interfaces.IExplicitDataElement`
:returns: string representation (using the MIME content type
configured for this representer)
"""
stream = NativeIO()
self.data_to_stream(data_element, stream)
return stream.getvalue()
def test_list_models(self):
@ptah.tinfo('custom',
title='Custom model',
description='Custom model description')
class CustomModel(object):
""" Custom module description """
title = 'Custom Module'
self.init_ptah()
sys.argv[1:] = ['--list-models', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* type:custom: Custom model (disabled: False)', val)
self.assertIn('Custom model description', val)
self.assertIn('class: CustomModel', val)
self.assertIn('module: test_manage', val)
# disable
cfg = ptah.get_settings(ptah.CFG_ID_PTAH)
cfg['disable_models'] = ('type:custom', )
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* type:custom: Custom model (disabled: True)', val)
def test_populate_no_params(self):
sys.argv[:] = ['ptah-populate', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
populate.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn(
'usage: ptah-populate [-h] [-l] [-a] config [step [step ...]]', val)
def run(self):
# print defaults
if self.options.printcfg:
data = config.get_cfg_storage(SETTINGS_OB_ID).export(True)
parser = configparser.ConfigParser(dict_type=OrderedDict)
for key, val in sorted(data.items()):
parser.set(configparser.DEFAULTSECT,
key, val.replace('%', '%%'))
fp = NativeIO()
try:
parser.write(fp)
finally:
pass
print (fp.getvalue())
return
if self.options.all:
section = ''
else:
section = self.options.section
# print description
groups = sorted(config.get_cfg_storage(ID_SETTINGS_GROUP).items(),
key = lambda item: item[1].__title__)
for name, group in groups:
if section and name != section:
continue
print ('')
title = group.__title__ or name
print (grpTitleWrap.fill('{0} ({1})'.format(title, name)))
if group.__description__:
print (grpDescriptionWrap.fill(
group.__description__))
print ('')
for node in group.__fields__.values():
default = '<required>' if node.required else node.default
print (nameWrap.fill(
('%s.%s: %s (%s: %s)' % (
name, node.name, node.title,
node.__class__.__name__, default))))
print (nameTitleWrap.fill(node.description))
print ('')
def test_list_modules(self):
@ptah.manage.module('custom')
class CustomModule(ptah.manage.PtahModule):
""" Custom module description """
title = 'Custom Module'
self.init_ptah()
sys.argv[1:] = ['--list-modules', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* custom: Custom Module (disabled: False)', val)
self.assertIn('Custom module description', val)
# disable
cfg = ptah.get_settings(ptah.CFG_ID_PTAH)
cfg['disable_modules'] = ('custom',)
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* custom: Custom Module (disabled: True)', val)
def run(self):
# print defaults
if self.options.printcfg:
data = config.get_cfg_storage(SETTINGS_OB_ID).export(True)
parser = configparser.ConfigParser(dict_type=OrderedDict)
for key, val in sorted(data.items()):
parser.set(configparser.DEFAULTSECT,
key, val.replace('%', '%%'))
fp = NativeIO()
try:
parser.write(fp)
finally:
pass
print (fp.getvalue())
return
if self.options.all:
section = ''
else:
section = self.options.section
# print description
groups = sorted(config.get_cfg_storage(ID_SETTINGS_GROUP).items())
for name, group in groups:
if section and name != section:
continue
print ('')
title = group.__title__ or name
print (grpTitleWrap.fill(title))
if group.__description__:
print (grpDescriptionWrap.fill(
group.__description__))
print ('')
for node in group.__fields__.values():
default = '<required>' if node.required else node.default
print (nameWrap.fill(
('%s.%s: %s (%s: %s)' % (
name, node.name, node.title,
node.__class__.__name__, default))))
print (nameTitleWrap.fill(node.description))
print ('')
def test_list_modules(self):
@ptah.manage.module('custom')
class CustomModule(ptah.manage.PtahModule):
""" Custom module description """
title = 'Custom Module'
self.init_ptah()
sys.argv[1:] = ['--list-modules', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* custom: Custom Module (disabled: False)', val)
self.assertIn('Custom module description', val)
# disable
cfg = ptah.get_settings(ptah.CFG_ID_PTAH)
cfg['disable_modules'] = ('custom', )
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* custom: Custom Module (disabled: True)', val)
def test_manage_no_params(self):
self.init_ptah()
sys.argv[:] = ['ptah-manage', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('[-h] [--list-modules] [--list-models] config', val)
def test_populate_no_params(self):
sys.argv[:] = ['ptah-populate', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
populate.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn(
'usage: ptah-populate [-h] [-l] [-a] config [step [step ...]]',
val)
def data_element_tree_to_string(data_element):
"""
Creates a string representation of the given data element tree.
"""
# FIXME: rewrite this as a visitor to use the data element tree traverser.
def __dump(data_el, stream, offset):
name = data_el.__class__.__name__
stream.write("%s%s" % (' ' * offset, name))
offset += 2
ifcs = provided_by(data_el)
if ICollectionDataElement in ifcs:
stream.write("[")
first_member = True
for member_data_el in data_el.get_members():
if first_member:
stream.write('%s' % os.linesep + ' ' * offset)
first_member = False
else:
stream.write(',%s' % os.linesep + ' ' * offset)
__dump(member_data_el, stream, offset)
stream.write("]")
else:
stream.write("(")
if ILinkedDataElement in ifcs:
stream.write("url=%s, kind=%s, relation=%s" %
(data_el.get_url(), data_el.get_kind(),
data_el.get_relation()))
else:
first_attr = True
for attr_name, attr_value in iteritems_(data_el.data):
if first_attr:
first_attr = False
else:
stream.write(',%s' % os.linesep + ' ' *
(offset + len(name) + 1))
if attr_value is None:
continue
if not IResourceDataElement in provided_by(attr_value):
stream.write("%s=%s" % (attr_name, attr_value))
else:
stream.write("%s=" % attr_name)
__dump(attr_value, stream, offset)
stream.write(')')
stream = NativeIO()
__dump(data_element, stream, 0)
return stream.getvalue()
def test_no_params(self, m_bs):
m_bs.return_value = {
'registry': self.registry, 'request': self.request}
sys.argv[:] = ['amdjs', 'pyramid_amdjs.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('[-h] [-b] [-m] [--deps] [--no-min] config', val)
def test_manage_no_params(self):
self.init_ptah()
sys.argv[:] = ['ptah-manage', 'ptah.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
manage.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn(
'[-h] [--list-modules] [--list-models] config', val)
def to_strings(self, resource):
"""
Dumps the all resources reachable from the given resource to a map of
string representations using the specified content_type (defaults
to CSV).
:returns: dictionary mapping resource member classes to string
representations
"""
collections = self.__collect(resource)
# Build a map of representations.
rpr_map = OrderedDict()
for (mb_cls, coll) in iteritems_(collections):
strm = NativeIO('w')
dump_resource(coll, strm, content_type=self.__content_type)
rpr_map[mb_cls] = strm.getvalue()
return rpr_map
def data_element_tree_to_string(data_element):
"""
Creates a string representation of the given data element tree.
"""
# FIXME: rewrite this as a visitor to use the data element tree traverser.
def __dump(data_el, stream, offset):
name = data_el.__class__.__name__
stream.write("%s%s" % (" " * offset, name))
offset += 2
ifcs = provided_by(data_el)
if ICollectionDataElement in ifcs:
stream.write("[")
first_member = True
for member_data_el in data_el.get_members():
if first_member:
stream.write("%s" % os.linesep + " " * offset)
first_member = False
else:
stream.write(",%s" % os.linesep + " " * offset)
__dump(member_data_el, stream, offset)
stream.write("]")
else:
stream.write("(")
if ILinkedDataElement in ifcs:
stream.write(
"url=%s, kind=%s, relation=%s" % (data_el.get_url(), data_el.get_kind(), data_el.get_relation())
)
else:
first_attr = True
for attr_name, attr_value in iteritems_(data_el.data):
if first_attr:
first_attr = False
else:
stream.write(",%s" % os.linesep + " " * (offset + len(name) + 1))
if attr_value is None:
continue
if not IResourceDataElement in provided_by(attr_value):
stream.write("%s=%s" % (attr_name, attr_value))
else:
stream.write("%s=" % attr_name)
__dump(attr_value, stream, offset)
stream.write(")")
stream = NativeIO()
__dump(data_element, stream, 0)
return stream.getvalue()
def to_strings(self, resource):
"""
Dumps the all resources reachable from the given resource to a map of
string representations using the specified content_type (defaults
to CSV).
:returns: dictionary mapping resource member classes to string
representations
"""
collections = self.__collect(resource)
# Build a map of representations.
rpr_map = OrderedDict()
for (mb_cls, coll) in iteritems_(collections):
strm = NativeIO('w')
dump_resource(coll, strm, content_type=self.__content_type)
rpr_map[mb_cls] = strm.getvalue()
return rpr_map
def test_no_params(self, m_bs):
m_bs.return_value = {
'registry': self.registry,
'request': self.request
}
sys.argv[:] = ['amdjs', 'pyramid_amdjs.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('[-h] [-b] [-m] [--deps] [--no-min] config', val)
def test_list_modules(self, m_bs):
m_bs.return_value = {
'registry': self.registry, 'request': self.request}
self.config.add_amd_js(
'test', 'pyramid_amdjs:tests/dir/test.js', 'Test module')
sys.argv[1:] = ['-m', 'pyramid_amdjs.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* test: pyramid_amdjs:tests/dir/test.js', val)
self.assertIn('Test module', val)
def test_build_tree(self, m_bs):
m_bs.return_value = {'registry': self.registry,
'request': self.request}
sys.argv[1:] = ['--deps', 'pyramid_amdjs.ini']
self.registry[ID_AMD_MODULE] = {
'test': {'path': 'pyramid_amdjs:tests/dir/test.js'}}
self.registry[ID_AMD_SPEC] = {'test': {'test': {}}}
out = NativeIO()
stdout = sys.stdout
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* Spec: test', val)
self.assertIn('jca', val)
self.assertIn('test', val)
def test_populate_list(self):
def step(registry):
""" """
self.config.ptah_populate_step('custom-step',
title='Custom step',
active=False,
factory=step)
sys.argv[:] = ['ptah-populate', 'ptah.ini', '-l']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
populate.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* custom-step: Custom step (inactive)', val)
def test_populate_list(self):
def step(registry):
""" """
self.config.ptah_populate_step(
'custom-step', title='Custom step',
active=False, factory=step)
sys.argv[:] = ['ptah-populate', 'ptah.ini', '-l']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
populate.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* custom-step: Custom step (inactive)', val)
def test_list_modules(self, m_bs):
m_bs.return_value = {
'registry': self.registry,
'request': self.request
}
self.config.add_amd_js('test', 'pyramid_amdjs:tests/dir/test.js',
'Test module')
sys.argv[1:] = ['-m', 'pyramid_amdjs.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('* test: pyramid_amdjs:tests/dir/test.js', val)
self.assertIn('Test module', val)
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
self.pid_file = None
def tearDown(self):
if self.pid_file and os.path.exists(self.pid_file):
os.remove(self.pid_file)
def out(self, msg):
self.out_.write(msg)
def _get_server(*args, **kwargs):
def server(app):
return ''
return server
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def _makeOneWithPidFile(self, pid):
self.pid_file = tempfile.mktemp()
inst = self._makeOne()
with open(self.pid_file, 'w') as f:
f.write(str(pid))
return inst
def test_remove_pid_file_verbose(self):
inst = self._makeOneWithPidFile(os.getpid())
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
self._assert_pid_file_removed(verbose=True)
def test_remove_pid_file_not_verbose(self):
inst = self._makeOneWithPidFile(os.getpid())
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=0)
self._assert_pid_file_removed(verbose=False)
def test_remove_pid_not_a_number(self):
inst = self._makeOneWithPidFile('not a number')
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
self._assert_pid_file_removed(verbose=True)
def test_remove_pid_current_pid_is_not_written_pid(self):
inst = self._makeOneWithPidFile(os.getpid())
inst._remove_pid_file('99999', self.pid_file, verbosity=1)
self._assert_pid_file_not_removed('')
def test_remove_pid_current_pid_is_not_pid_in_file(self):
inst = self._makeOneWithPidFile('99999')
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
msg = 'PID file %s contains 99999, not expected PID %s'
self._assert_pid_file_not_removed(msg % (self.pid_file, os.getpid()))
def test_remove_pid_no_pid_file(self):
inst = self._makeOne()
self.pid_file = 'some unknown path'
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
self._assert_pid_file_removed(verbose=False)
def test_remove_pid_file_unlink_exception(self):
inst = self._makeOneWithPidFile(os.getpid())
self._remove_pid_unlink_exception(inst)
msg = [
'Removing PID file %s' % (self.pid_file),
'Cannot remove PID file: (Some OSError - unlink)',
'Stale PID removed']
self._assert_pid_file_not_removed(msg=''.join(msg))
with open(self.pid_file) as f:
self.assertEqual(f.read(), '')
def test_remove_pid_file_stale_pid_write_exception(self):
inst = self._makeOneWithPidFile(os.getpid())
self._remove_pid_unlink_and_write_exceptions(inst)
msg = [
'Removing PID file %s' % (self.pid_file),
'Cannot remove PID file: (Some OSError - unlink)',
'Stale PID left in file: %s ' % (self.pid_file),
'(Some OSError - open)']
self._assert_pid_file_not_removed(msg=''.join(msg))
with open(self.pid_file) as f:
self.assertEqual(int(f.read()), os.getpid())
def test_record_pid_verbose(self):
self._assert_record_pid(verbosity=2, msg='Writing PID %d to %s')
def test_record_pid_not_verbose(self):
self._assert_record_pid(verbosity=1, msg='')
def _remove_pid_unlink_exception(self, inst):
old_unlink = os.unlink
def fake_unlink(filename):
raise OSError('Some OSError - unlink')
try:
os.unlink = fake_unlink
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
finally:
os.unlink = old_unlink
def _remove_pid_unlink_and_write_exceptions(self, inst):
old_unlink = os.unlink
def fake_unlink(filename):
raise OSError('Some OSError - unlink')
run_already = []
old_open = __builtin__.open
def fake_open(*args):
if not run_already:
run_already.append(True)
return old_open(*args)
raise OSError('Some OSError - open')
try:
os.unlink = fake_unlink
__builtin__.open = fake_open
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
finally:
os.unlink = old_unlink
__builtin__.open = old_open
def _assert_pid_file_removed(self, verbose=False):
self.assertFalse(os.path.exists(self.pid_file))
msg = 'Removing PID file %s' % (self.pid_file) if verbose else ''
self.assertEqual(self.out_.getvalue(), msg)
def _assert_pid_file_not_removed(self, msg):
self.assertTrue(os.path.exists(self.pid_file))
self.assertEqual(self.out_.getvalue(), msg)
def _assert_record_pid(self, verbosity, msg):
old_atexit = atexit.register
def fake_atexit(*args):
pass
self.pid_file = tempfile.mktemp()
pid = os.getpid()
inst = self._makeOne()
inst.options.verbose = verbosity
try:
atexit.register = fake_atexit
inst.record_pid(self.pid_file)
finally:
atexit.register = old_atexit
msg = msg % (pid, self.pid_file) if msg else ''
self.assertEqual(self.out_.getvalue(), msg)
with open(self.pid_file) as f:
self.assertEqual(int(f.read()), pid)
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_run_stop_daemon_no_such_pid_file(self):
path = os.path.join(os.path.dirname(__file__), 'wontexist.pid')
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
msg = 'No PID file exists in %s' % path
self.assertEqual(self.out_.getvalue(), msg)
def test_run_stop_daemon_bad_pid_file(self):
path = __file__
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
msg = 'Not a valid PID file in %s' % path
self.assertEqual(self.out_.getvalue(), msg)
def test_run_stop_daemon_invalid_pid_in_file(self):
fn = tempfile.mktemp()
with open(fn, 'wb') as tmp:
tmp.write(b'9999999')
tmp.close()
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % fn)
inst.run()
msg = 'PID in %s is not valid (deleting)' % fn
self.assertEqual(self.out_.getvalue(), msg)
def test_get_options_with_command(self):
inst = self._makeOne()
inst.args = ['foo', 'stop', 'a=1', 'b=2']
result = inst.get_options()
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_get_options_no_command(self):
inst = self._makeOne()
inst.args = ['foo', 'a=1', 'b=2']
result = inst.get_options()
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_good(self):
from pyramid.tests.test_scripts.dummy import DummyApp
inst = self._makeOne('development.ini', 'a=1', 'b=2')
inst.loadserver = self._get_server
app = DummyApp()
def get_app(*args, **kwargs):
app.global_conf = kwargs.get('global_conf', None)
inst.loadapp = get_app
inst.run()
self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
inst = self._makeOne('development.ini', 'a')
inst.loadserver = self._get_server
self.assertRaises(ValueError, inst.run)
class TestPCreateCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pcreate import PCreateCommand
return PCreateCommand
def _makeOne(self, *args):
effargs = ['pcreate']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def test_run_show_scaffolds_exist(self):
cmd = self._makeOne('-l')
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Available scaffolds'))
def test_run_show_scaffolds_none_exist(self):
cmd = self._makeOne('-l')
cmd.scaffolds = []
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('No scaffolds available'))
def test_run_no_scaffold_name(self):
cmd = self._makeOne()
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(
out.startswith('You must provide at least one scaffold name'))
def test_no_project_name(self):
cmd = self._makeOne('-s', 'dummy')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('You must provide a project name'))
def test_unknown_scaffold_name(self):
cmd = self._makeOne('-s', 'dummyXX', 'distro')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Unavailable scaffolds'))
def test_known_scaffold_single_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro'
})
def test_known_scaffold_absolute_path(self):
import os
path = os.path.abspath('Distro')
cmd = self._makeOne('-s', 'dummy', path)
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro'
})
def test_known_scaffold_multiple_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy1', '-s', 'dummy2', 'Distro')
scaffold1 = DummyScaffold('dummy1')
scaffold2 = DummyScaffold('dummy2')
cmd.scaffolds = [scaffold1, scaffold2]
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(scaffold1.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(scaffold1.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro'
})
self.assertEqual(scaffold2.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(scaffold2.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro'
})
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
self.pid_file = None
def tearDown(self):
if self.pid_file and os.path.exists(self.pid_file):
os.remove(self.pid_file)
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def _makeOneWithPidFile(self, pid):
self.pid_file = tempfile.mktemp()
inst = self._makeOne()
with open(self.pid_file, 'w') as f:
f.write(str(pid))
return inst
def test_remove_pid_file_verbose(self):
inst = self._makeOneWithPidFile(os.getpid())
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
self._assert_pid_file_removed(verbose=True)
def test_remove_pid_file_not_verbose(self):
inst = self._makeOneWithPidFile(os.getpid())
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=0)
self._assert_pid_file_removed(verbose=False)
def test_remove_pid_not_a_number(self):
inst = self._makeOneWithPidFile('not a number')
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
self._assert_pid_file_removed(verbose=True)
def test_remove_pid_current_pid_is_not_written_pid(self):
inst = self._makeOneWithPidFile(os.getpid())
inst._remove_pid_file('99999', self.pid_file, verbosity=1)
self._assert_pid_file_not_removed('')
def test_remove_pid_current_pid_is_not_pid_in_file(self):
inst = self._makeOneWithPidFile('99999')
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
msg = 'PID file %s contains 99999, not expected PID %s'
self._assert_pid_file_not_removed(msg % (self.pid_file, os.getpid()))
def test_remove_pid_no_pid_file(self):
inst = self._makeOne()
self.pid_file = 'some unknown path'
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
self._assert_pid_file_removed(verbose=False)
def test_remove_pid_file_unlink_exception(self):
inst = self._makeOneWithPidFile(os.getpid())
self._remove_pid_unlink_exception(inst)
msg = [
'Removing PID file %s' % (self.pid_file),
'Cannot remove PID file: (Some OSError - unlink)',
'Stale PID removed'
]
self._assert_pid_file_not_removed(msg=''.join(msg))
with open(self.pid_file) as f:
self.assertEqual(f.read(), '')
def test_remove_pid_file_stale_pid_write_exception(self):
inst = self._makeOneWithPidFile(os.getpid())
self._remove_pid_unlink_and_write_exceptions(inst)
msg = [
'Removing PID file %s' % (self.pid_file),
'Cannot remove PID file: (Some OSError - unlink)',
'Stale PID left in file: %s ' % (self.pid_file),
'(Some OSError - open)'
]
self._assert_pid_file_not_removed(msg=''.join(msg))
with open(self.pid_file) as f:
self.assertEqual(int(f.read()), os.getpid())
def test_record_pid_verbose(self):
self._assert_record_pid(verbosity=2, msg='Writing PID %d to %s')
def test_record_pid_not_verbose(self):
self._assert_record_pid(verbosity=1, msg='')
def _remove_pid_unlink_exception(self, inst):
old_unlink = os.unlink
def fake_unlink(filename):
raise OSError('Some OSError - unlink')
try:
os.unlink = fake_unlink
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
finally:
os.unlink = old_unlink
def _remove_pid_unlink_and_write_exceptions(self, inst):
old_unlink = os.unlink
def fake_unlink(filename):
raise OSError('Some OSError - unlink')
run_already = []
old_open = __builtin__.open
def fake_open(*args):
if not run_already:
run_already.append(True)
return old_open(*args)
raise OSError('Some OSError - open')
try:
os.unlink = fake_unlink
__builtin__.open = fake_open
inst._remove_pid_file(os.getpid(), self.pid_file, verbosity=1)
finally:
os.unlink = old_unlink
__builtin__.open = old_open
def _assert_pid_file_removed(self, verbose=False):
self.assertFalse(os.path.exists(self.pid_file))
msg = 'Removing PID file %s' % (self.pid_file) if verbose else ''
self.assertEqual(self.out_.getvalue(), msg)
def _assert_pid_file_not_removed(self, msg):
self.assertTrue(os.path.exists(self.pid_file))
self.assertEqual(self.out_.getvalue(), msg)
def _assert_record_pid(self, verbosity, msg):
old_atexit = atexit.register
def fake_atexit(*args):
pass
self.pid_file = tempfile.mktemp()
pid = os.getpid()
inst = self._makeOne()
inst.verbose = verbosity
try:
atexit.register = fake_atexit
inst.record_pid(self.pid_file)
finally:
atexit.register = old_atexit
msg = msg % (pid, self.pid_file) if msg else ''
self.assertEqual(self.out_.getvalue(), msg)
with open(self.pid_file) as f:
self.assertEqual(int(f.read()), pid)
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_run_stop_daemon_no_such_pid_file(self):
path = os.path.join(os.path.dirname(__file__), 'wontexist.pid')
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
msg = 'No PID file exists in %s' % path
self.assertEqual(self.out_.getvalue(), msg)
def test_run_stop_daemon_bad_pid_file(self):
path = __file__
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
msg = 'Not a valid PID file in %s' % path
self.assertEqual(self.out_.getvalue(), msg)
def test_run_stop_daemon_invalid_pid_in_file(self):
fn = tempfile.mktemp()
with open(fn, 'wb') as tmp:
tmp.write(b'9999999')
tmp.close()
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % fn)
inst.run()
msg = 'PID in %s is not valid (deleting)' % fn
self.assertEqual(self.out_.getvalue(), msg)
def test_parse_vars_good(self):
vars = ['a=1', 'b=2']
inst = self._makeOne('development.ini')
result = inst.parse_vars(vars)
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
vars = ['a']
inst = self._makeOne('development.ini')
self.assertRaises(ValueError, inst.parse_vars, vars)
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_run_stop_daemon_no_such_pid_file(self):
path = os.path.join(os.path.dirname(__file__), 'wontexist.pid')
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
self.assertEqual(self.out_.getvalue(),
'No PID file exists in %s' % path)
def test_run_stop_daemon_bad_pid_file(self):
path = __file__
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % path)
inst.run()
self.assertEqual(self.out_.getvalue(),
'Not a valid PID file in %s' % path)
def test_run_stop_daemon_invalid_pid_in_file(self):
import tempfile
tmp = tempfile.NamedTemporaryFile()
tmp.write(b'9999999')
tmp.flush()
tmpname = tmp.name
inst = self._makeOne('--stop-daemon', '--pid-file=%s' % tmpname)
inst.run()
try:
tmp.close()
except:
pass
self.assertEqual(self.out_.getvalue(),
'PID in %s is not valid (deleting)' % tmpname)
def test_parse_vars_good(self):
vars = ['a=1', 'b=2']
inst = self._makeOne('development.ini')
result = inst.parse_vars(vars)
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
vars = ['a']
inst = self._makeOne('development.ini')
self.assertRaises(ValueError, inst.parse_vars, vars)
class TestPCreateCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pcreate import PCreateCommand
return PCreateCommand
def _makeOne(self, *args):
effargs = ['pcreate']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
return cmd
def test_run_show_scaffolds_exist(self):
cmd = self._makeOne('-l')
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Available scaffolds'))
def test_run_show_scaffolds_none_exist(self):
cmd = self._makeOne('-l')
cmd.scaffolds = []
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('No scaffolds available'))
def test_run_no_scaffold_name(self):
cmd = self._makeOne()
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith(
'You must provide at least one scaffold name'))
def test_no_project_name(self):
cmd = self._makeOne('-s', 'dummy')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('You must provide a project name'))
def test_unknown_scaffold_name(self):
cmd = self._makeOne('-s', 'dummyXX', 'distro')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Unavailable scaffolds'))
def test_known_scaffold_single_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro'})
def test_known_scaffold_absolute_path(self):
import os
path = os.path.abspath('Distro')
cmd = self._makeOne('-s', 'dummy', path)
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro'})
def test_known_scaffold_multiple_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy1', '-s', 'dummy2', 'Distro')
scaffold1 = DummyScaffold('dummy1')
scaffold2 = DummyScaffold('dummy2')
cmd.scaffolds = [scaffold1, scaffold2]
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold1.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold1.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro'})
self.assertEqual(
scaffold2.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold2.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro'})
def test_known_scaffold_with_path_as_project_target_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy', '/tmp/foo/Distro/')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), '/tmp/foo/Distro'))
)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro'})
class Test_query_interactive(unittest.TestCase):
def setUp(self):
import tempfile
from pyramid.compat import NativeIO
self.dirname = tempfile.mkdtemp()
self.out = NativeIO()
self.fixturetuple = ('pyramid.tests.test_scaffolds',
'fixture_scaffold')
self.src_content = """\
These are not the droids
that you are looking for."""
self.dest_content = """\
These are the droids for
whom you are looking;
now you have found them."""
self.src_fn = os.path.join(self.dirname, 'mypackage', '__init__.py')
self.dest_fn = os.path.join(self.dirname, 'mypackage', '__init__.py')
# query_interactive is only normally executed when the destination
# is discovered to be already occupied by existing files, so ...
# create the required occupancy.
from pyramid.scaffolds.copydir import copy_dir
copy_dir(self.fixturetuple,
self.dirname,
{'package':'mypackage'},
0, False,
template_renderer=dummy_template_renderer)
def tearDown(self):
import shutil
shutil.rmtree(self.dirname, ignore_errors=True)
self.out.close()
def _callFUT(self, *arg, **kw):
from pyramid.scaffolds.copydir import query_interactive
return query_interactive(*arg, **kw)
def test_query_interactive_0y(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("y")
self._callFUT(self.src_fn, self.dest_fn,
self.src_content, self.dest_content,
simulate=False,
out_=self.out)
self.assertTrue("Replace" in self.out.getvalue())
def test_query_interactive_1n(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("n")
self._callFUT(self.src_fn, self.dest_fn,
self.src_content,
'\n'.join(self.dest_content.split('\n')[:-1]),
simulate=False,
out_=self.out)
self.assertTrue("Replace" in self.out.getvalue())
def test_query_interactive_2b(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("b")
with open(os.path.join(
self.dirname, 'mypackage', '__init__.py.bak'), 'w') as fp:
fp.write("")
fp.close()
self._callFUT(self.src_fn, self.dest_fn,
self.dest_content, self.src_content,
simulate=False,
out_=self.out)
self.assertTrue("Backing up" in self.out.getvalue())
def test_query_interactive_3d(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("d")
self._callFUT(self.src_fn, self.dest_fn,
self.dest_content, self.src_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise the test could be made
# more usefully precise...
# print("3d", output)
# self.assertTrue("@@" in output, output)
self.assertTrue("Replace" in output)
def test_query_interactive_4dc(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("dc")
self._callFUT(self.src_fn, self.dest_fn,
self.dest_content, self.src_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise, the test could be made
# more usefully precise...
# print("4dc", output)
# self.assertTrue("***" in output, output)
self.assertTrue("Replace" in output)
def test_query_interactive_5allbad(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("all z")
self._callFUT(self.src_fn, self.dest_fn,
self.src_content, self.dest_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise the test could be made
# more usefully precise...
# print("5allbad", output)
# self.assertTrue("Responses" in output, output)
self.assertTrue("Replace" in output)
def test_query_interactive_6all(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("all b")
self._callFUT(self.src_fn, self.dest_fn,
self.src_content, self.dest_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise the test could be made
# more usefully precise...
# print("6all", output)
# self.assertTrue("Responses" in output, output)
self.assertTrue("Replace" in output)
def test_build_bundle(self, m_bs, m_binit):
m_bs.return_value = {
'registry': self.registry,
'request': self.request
}
m_binit.return_value = '123'
self.config.add_amd_js('test', 'pyramid_amdjs:tests/dir/test.js',
'Test module')
self.config.add_handlebars_bundle('handlebars-test',
'pyramid_amdjs:tests/dir/',
'Handlebars bundle')
cfg = self.registry.settings
sys.argv[1:] = ['-b', 'pyramid_amdjs.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Spec files are not specified in .ini file', val)
cfg['amd.spec'] = [('main', 'pyramid_amdjs:tests/amd.spec')]
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Destination directory is not specified in .ini file',
val)
d = tempfile.mkdtemp()
cfg['amd.spec-dir'] = d
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Processing: main (pyramid_amdjs:tests/amd.spec)', val)
self.assertIn(
"""
* bundle.js
test: pyramid_amdjs:tests/dir/test.js
handlebars-test: templates bundle""", val)
self.assertTrue(os.path.isfile(os.path.join(d, 'bundle.js')))
self.assertFalse(os.path.isfile(os.path.join(d, 'bundle2.js')))
self.assertTrue(os.path.isfile(os.path.join(d, 'init-main.js')))
shutil.rmtree(d)
d = tempfile.mkdtemp()
cfg['amd.spec-dir'] = d
sys.argv[1:] = ['-b', '--no-min', 'pyramid_amdjs.ini']
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Processing: main (pyramid_amdjs:tests/amd.spec)', val)
self.assertIn(
"""
* bundle.js
test: pyramid_amdjs:tests/dir/test.js
handlebars-test: templates bundle""", val)
self.assertTrue(os.path.isfile(os.path.join(d, 'bundle.js')))
shutil.rmtree(d)
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
self.config_factory = dummy.DummyConfigParserFactory()
def out(self, msg):
self.out_.write(msg)
def _get_server(*args, **kwargs):
def server(app):
return ''
return server
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
cmd.ConfigParser = self.config_factory
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_config_vars_no_command(self):
inst = self._makeOne()
inst.args.config_uri = 'foo'
inst.args.config_vars = ['a=1', 'b=2']
result = inst.get_config_vars()
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_good(self):
inst = self._makeOne('development.ini', 'a=1', 'b=2')
inst.loadserver = self._get_server
app = dummy.DummyApp()
def get_app(*args, **kwargs):
app.global_conf = kwargs.get('global_conf', None)
inst.loadapp = get_app
inst.run()
self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
inst = self._makeOne('development.ini', 'a')
inst.loadserver = self._get_server
self.assertRaises(ValueError, inst.run)
def test_config_file_finds_watch_files(self):
inst = self._makeOne('development.ini')
self.config_factory.items = [(
'watch_files',
'foo\n/baz\npyramid.tests.test_scripts:*.py',
)]
inst.pserve_file_config('/base/path.ini', global_conf={'a': '1'})
self.assertEqual(self.config_factory.defaults, {
'a': '1',
'here': os.path.abspath('/base'),
})
self.assertEqual(inst.watch_files, [
os.path.abspath('/base/foo'),
os.path.abspath('/baz'),
os.path.abspath(os.path.join(here, '*.py')),
])
class TestPCreateCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pcreate import PCreateCommand
return PCreateCommand
def _makeOne(self, *args, **kw):
effargs = ['pcreate']
effargs.extend(args)
cmd = self._getTargetClass()(effargs, **kw)
cmd.out = self.out
return cmd
def test_run_show_scaffolds_exist(self):
cmd = self._makeOne('-l')
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Available scaffolds'))
def test_run_show_scaffolds_none_exist(self):
cmd = self._makeOne('-l')
cmd.scaffolds = []
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('No scaffolds available'))
def test_run_no_scaffold_no_args(self):
cmd = self._makeOne(quiet=True)
result = cmd.run()
self.assertEqual(result, 2)
def test_run_no_scaffold_name(self):
cmd = self._makeOne('dummy')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith(
'You must provide at least one scaffold name'))
def test_no_project_name(self):
cmd = self._makeOne('-s', 'dummy')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('You must provide a project name'))
def test_unknown_scaffold_name(self):
cmd = self._makeOne('-s', 'dummyXX', 'distro')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Unavailable scaffolds'))
def test_known_scaffold_single_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
def test_scaffold_with_hyphen_in_project_name(self):
import os
cmd = self._makeOne('-s', 'dummy', 'Distro-')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro-'))
)
self.assertEqual(
scaffold.vars,
{'project': 'Distro-', 'egg': 'Distro_', 'package': 'distro_',
'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
def test_known_scaffold_absolute_path(self):
import os
path = os.path.abspath('Distro')
cmd = self._makeOne('-s', 'dummy', path)
cmd.pyramid_dist = DummyDist("0.1")
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
def test_known_scaffold_multiple_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy1', '-s', 'dummy2', 'Distro')
scaffold1 = DummyScaffold('dummy1')
scaffold2 = DummyScaffold('dummy2')
cmd.scaffolds = [scaffold1, scaffold2]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold1.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold1.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
self.assertEqual(
scaffold2.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
)
self.assertEqual(
scaffold2.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
def test_known_scaffold_with_path_as_project_target_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy', '/tmp/foo/Distro/')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), '/tmp/foo/Distro'))
)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
def test_scaffold_with_prod_pyramid_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.2")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.2', 'pyramid_docs_branch':'0.2-branch'})
def test_scaffold_with_prod_pyramid_long_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.2.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.2.1', 'pyramid_docs_branch':'0.2-branch'})
def test_scaffold_with_prod_pyramid_unparsable_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("abc")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': 'abc', 'pyramid_docs_branch':'latest'})
def test_scaffold_with_dev_pyramid_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.12dev")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.12dev',
'pyramid_docs_branch': 'master'})
def test_scaffold_with_dev_pyramid_long_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.10.1dev")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars,
{'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
'pyramid_version': '0.10.1dev',
'pyramid_docs_branch': 'master'})
class Test_copy_dir(unittest.TestCase):
def setUp(self):
import tempfile
from pyramid.compat import NativeIO
self.dirname = tempfile.mkdtemp()
self.out = NativeIO()
self.fixturetuple = ('pyramid.tests.test_scaffolds',
'fixture_scaffold')
def tearDown(self):
import shutil
shutil.rmtree(self.dirname, ignore_errors=True)
self.out.close()
def _callFUT(self, *arg, **kw):
kw['out_'] = self.out
from pyramid.scaffolds.copydir import copy_dir
return copy_dir(*arg, **kw)
def test_copy_source_as_pkg_resource(self):
vars = {'package': 'mypackage'}
self._callFUT(self.fixturetuple,
self.dirname,
vars,
1,
False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Creating' in result)
self.assertTrue(
'Copying fixture_scaffold/+package+/__init__.py_tmpl to' in result)
source = pkg_resources.resource_filename(
'pyramid.tests.test_scaffolds',
'fixture_scaffold/+package+/__init__.py_tmpl')
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'r') as f:
tcontent = f.read()
with open(source, 'r') as f:
scontent = f.read()
self.assertEqual(scontent, tcontent)
def test_copy_source_as_dirname(self):
vars = {'package': 'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1,
False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Creating' in result)
self.assertTrue('Copying __init__.py_tmpl to' in result)
source = pkg_resources.resource_filename(
'pyramid.tests.test_scaffolds',
'fixture_scaffold/+package+/__init__.py_tmpl')
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'r') as f:
tcontent = f.read()
with open(source, 'r') as f:
scontent = f.read()
self.assertEqual(scontent, tcontent)
def test_content_is_same_message(self):
vars = {'package': 'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
2,
False,
template_renderer=dummy_template_renderer)
self._callFUT(source,
self.dirname,
vars,
2,
False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('%s already exists (same content)' % \
os.path.join(self.dirname, 'mypackage', '__init__.py') in result)
def test_direxists_message(self):
vars = {'package': 'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
# if not os.path.exists(self.dirname):
# os.mkdir(self.dirname)
self._callFUT(source,
self.dirname,
vars,
2,
False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Directory %s exists' % self.dirname in result, result)
def test_overwrite_false(self):
vars = {'package': 'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1,
False,
overwrite=False,
template_renderer=dummy_template_renderer)
# toplevel file
toplevel = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(toplevel, 'w') as f:
f.write('These are the words you are looking for.')
# sub directory file
sub = os.path.join(self.dirname, 'mypackage', 'templates', 'home.pt')
with open(sub, 'w') as f:
f.write('These are the words you are looking for.')
self._callFUT(source,
self.dirname,
vars,
1,
False,
overwrite=False,
template_renderer=dummy_template_renderer)
with open(toplevel, 'r') as f:
tcontent = f.read()
self.assertEqual('These are the words you are looking for.', tcontent)
with open(sub, 'r') as f:
tcontent = f.read()
self.assertEqual('These are the words you are looking for.', tcontent)
def test_overwrite_true(self):
vars = {'package': 'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1,
False,
overwrite=True,
template_renderer=dummy_template_renderer)
# toplevel file
toplevel = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(toplevel, 'w') as f:
f.write('These are not the words you are looking for.')
# sub directory file
sub = os.path.join(self.dirname, 'mypackage', 'templates', 'home.pt')
with open(sub, 'w') as f:
f.write('These are not the words you are looking for.')
self._callFUT(source,
self.dirname,
vars,
1,
False,
overwrite=True,
template_renderer=dummy_template_renderer)
with open(toplevel, 'r') as f:
tcontent = f.read()
self.assertNotEqual('These are not the words you are looking for.',
tcontent)
with open(sub, 'r') as f:
tcontent = f.read()
self.assertNotEqual('These are not the words you are looking for.',
tcontent)
def test_detect_SkipTemplate(self):
vars = {'package': 'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
def dummy_template_renderer(*args, **kwargs):
from pyramid.scaffolds.copydir import SkipTemplate
raise SkipTemplate
self._callFUT(source,
self.dirname,
vars,
1,
False,
template_renderer=dummy_template_renderer)
def test_query_interactive(self):
from pyramid.scaffolds import copydir
vars = {'package': 'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1,
False,
overwrite=False,
template_renderer=dummy_template_renderer)
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'w') as f:
f.write('These are not the words you are looking for.')
# We need query_interactive to return False in order to force
# execution of a branch
original_code_object = copydir.query_interactive
copydir.query_interactive = lambda *args, **kwargs: False
self._callFUT(source,
self.dirname,
vars,
1,
False,
interactive=True,
overwrite=False,
template_renderer=dummy_template_renderer)
copydir.query_interactive = original_code_object
def to_bytes(self, obj, encoding=None):
stream = NativeIO()
self.to_stream(obj, stream)
return stream.getvalue()
class Test_query_interactive(unittest.TestCase):
def setUp(self):
import tempfile
from pyramid.compat import NativeIO
self.dirname = tempfile.mkdtemp()
self.out = NativeIO()
self.fixturetuple = ('pyramid.tests.test_scaffolds',
'fixture_scaffold')
self.src_content = """\
These are not the droids
that you are looking for."""
self.dest_content = """\
These are the droids for
whom you are looking;
now you have found them."""
self.src_fn = os.path.join(self.dirname, 'mypackage', '__init__.py')
self.dest_fn = os.path.join(self.dirname, 'mypackage', '__init__.py')
# query_interactive is only normally executed when the destination
# is discovered to be already occupied by existing files, so ...
# create the required occupancy.
from pyramid.scaffolds.copydir import copy_dir
copy_dir(self.fixturetuple,
self.dirname, {'package': 'mypackage'},
0,
False,
template_renderer=dummy_template_renderer)
def tearDown(self):
import shutil
shutil.rmtree(self.dirname, ignore_errors=True)
self.out.close()
def _callFUT(self, *arg, **kw):
from pyramid.scaffolds.copydir import query_interactive
return query_interactive(*arg, **kw)
def test_query_interactive_0y(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("y")
self._callFUT(self.src_fn,
self.dest_fn,
self.src_content,
self.dest_content,
simulate=False,
out_=self.out)
self.assertTrue("Replace" in self.out.getvalue())
def test_query_interactive_1n(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("n")
self._callFUT(self.src_fn,
self.dest_fn,
self.src_content,
'\n'.join(self.dest_content.split('\n')[:-1]),
simulate=False,
out_=self.out)
self.assertTrue("Replace" in self.out.getvalue())
def test_query_interactive_2b(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("b")
with open(os.path.join(self.dirname, 'mypackage', '__init__.py.bak'),
'w') as fp:
fp.write("")
fp.close()
self._callFUT(self.src_fn,
self.dest_fn,
self.dest_content,
self.src_content,
simulate=False,
out_=self.out)
self.assertTrue("Backing up" in self.out.getvalue())
def test_query_interactive_3d(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("d")
self._callFUT(self.src_fn,
self.dest_fn,
self.dest_content,
self.src_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise the test could be made
# more usefully precise...
# print("3d", output)
# self.assertTrue("@@" in output, output)
self.assertTrue("Replace" in output)
def test_query_interactive_4dc(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("dc")
self._callFUT(self.src_fn,
self.dest_fn,
self.dest_content,
self.src_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise, the test could be made
# more usefully precise...
# print("4dc", output)
# self.assertTrue("***" in output, output)
self.assertTrue("Replace" in output)
def test_query_interactive_5allbad(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("all z")
self._callFUT(self.src_fn,
self.dest_fn,
self.src_content,
self.dest_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise the test could be made
# more usefully precise...
# print("5allbad", output)
# self.assertTrue("Responses" in output, output)
self.assertTrue("Replace" in output)
def test_query_interactive_6all(self):
from pyramid.scaffolds import copydir
copydir.input_ = RawInputMockObject("all b")
self._callFUT(self.src_fn,
self.dest_fn,
self.src_content,
self.dest_content,
simulate=False,
out_=self.out)
output = self.out.getvalue()
# The useful text in self.out gets wiped out on the second
# call to raw_input, otherwise the test could be made
# more usefully precise...
# print("6all", output)
# self.assertTrue("Responses" in output, output)
self.assertTrue("Replace" in output)
def test_dump_no_content_type(self):
member = _make_test_entity_member()
strm = NativeIO()
dump_resource(member, strm)
self.assert_true(strm.getvalue().startswith('"id",'))
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
self.loader = dummy.DummyLoader()
cmd._get_config_loader = self.loader
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_parse_vars_good(self):
inst = self._makeOne('development.ini', 'a=1', 'b=2')
app = dummy.DummyApp()
def get_app(name, global_conf):
app.name = name
app.global_conf = global_conf
return app
self.loader.get_wsgi_app = get_app
self.loader.server = lambda x: x
inst.run()
self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
inst = self._makeOne('development.ini', 'a')
self.assertRaises(ValueError, inst.run)
def test_config_file_finds_watch_files(self):
inst = self._makeOne('development.ini')
loader = self.loader('/base/path.ini')
loader.settings = {'pserve': {
'watch_files': 'foo\n/baz\npyramid.tests.test_scripts:*.py',
}}
inst.pserve_file_config(loader, global_conf={'a': '1'})
self.assertEqual(loader.calls[0]['defaults'], {
'a': '1',
})
self.assertEqual(inst.watch_files, set([
os.path.abspath('/base/foo'),
os.path.abspath('/baz'),
os.path.abspath(os.path.join(here, '*.py')),
]))
def test_config_file_finds_open_url(self):
inst = self._makeOne('development.ini')
loader = self.loader('/base/path.ini')
loader.settings = {'pserve': {
'open_url': 'http://127.0.0.1:8080/',
}}
inst.pserve_file_config(loader, global_conf={'a': '1'})
self.assertEqual(loader.calls[0]['defaults'], {
'a': '1',
})
self.assertEqual(inst.open_url, 'http://127.0.0.1:8080/')
def test_guess_server_url(self):
inst = self._makeOne('development.ini')
loader = self.loader('/base/path.ini')
loader.settings = {'server:foo': {
'port': '8080',
}}
url = inst.guess_server_url(loader, 'foo', global_conf={'a': '1'})
self.assertEqual(loader.calls[0]['defaults'], {
'a': '1',
})
self.assertEqual(url, 'http://127.0.0.1:8080')
def test_reload_call_hupper_with_correct_args(self):
from pyramid.scripts import pserve
class AttrDict(dict):
def __init__(self, *args, **kwargs):
super(AttrDict, self).__init__(*args, **kwargs)
self.__dict__ = self
def dummy_start_reloader(*args, **kwargs):
dummy_start_reloader.args = args
dummy_start_reloader.kwargs = kwargs
orig_hupper = pserve.hupper
try:
pserve.hupper = AttrDict(is_active=lambda: False,
start_reloader=dummy_start_reloader)
inst = self._makeOne('--reload', 'development.ini')
inst.run()
finally:
pserve.hupper = orig_hupper
self.assertEquals(dummy_start_reloader.args, ('pyramid.scripts.pserve.main',))
self.assertEquals(dummy_start_reloader.kwargs, {
'reload_interval': 1,
'verbose': 1,
'worker_kwargs': {'argv': ['pserve', '--reload', 'development.ini'],
'quiet': False}})
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
self.config_factory = dummy.DummyConfigParserFactory()
def out(self, msg):
self.out_.write(msg)
def _get_server(*args, **kwargs):
def server(app):
return ''
return server
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
cmd.ConfigParser = self.config_factory
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_config_vars_no_command(self):
inst = self._makeOne()
inst.args.config_uri = 'foo'
inst.args.config_vars = ['a=1', 'b=2']
result = inst.get_config_vars()
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_good(self):
inst = self._makeOne('development.ini', 'a=1', 'b=2')
inst.loadserver = self._get_server
app = dummy.DummyApp()
def get_app(*args, **kwargs):
app.global_conf = kwargs.get('global_conf', None)
inst.loadapp = get_app
inst.run()
self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
inst = self._makeOne('development.ini', 'a')
inst.loadserver = self._get_server
self.assertRaises(ValueError, inst.run)
def test_config_file_finds_watch_files(self):
inst = self._makeOne('development.ini')
self.config_factory.items = [(
'watch_files',
'foo\n/baz\npyramid.tests.test_scripts:*.py',
)]
inst.pserve_file_config('/base/path.ini', global_conf={'a': '1'})
self.assertEqual(self.config_factory.defaults, {
'a': '1',
'here': os.path.abspath('/base'),
})
self.assertEqual(inst.watch_files, [
os.path.abspath('/base/foo'),
os.path.abspath('/baz'),
os.path.abspath(os.path.join(here, '*.py')),
])
class TestPCreateCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
def out(self, msg):
self.out_.write(msg)
def _getTargetClass(self):
from pyramid.scripts.pcreate import PCreateCommand
return PCreateCommand
def _makeOne(self, *args, **kw):
effargs = ['pcreate']
effargs.extend(args)
cmd = self._getTargetClass()(effargs, **kw)
cmd.out = self.out
return cmd
def test_run_show_scaffolds_exist(self):
cmd = self._makeOne('-l')
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Available scaffolds'))
def test_run_show_scaffolds_none_exist(self):
cmd = self._makeOne('-l')
cmd.scaffolds = []
result = cmd.run()
self.assertEqual(result, 0)
out = self.out_.getvalue()
self.assertTrue(out.startswith('No scaffolds available'))
def test_run_no_scaffold_no_args(self):
cmd = self._makeOne(quiet=True)
result = cmd.run()
self.assertEqual(result, 2)
def test_run_no_scaffold_name(self):
cmd = self._makeOne('dummy')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(
out.startswith('You must provide at least one scaffold name'))
def test_no_project_name(self):
cmd = self._makeOne('-s', 'dummy')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('You must provide a project name'))
def test_unknown_scaffold_name(self):
cmd = self._makeOne('-s', 'dummyXX', 'distro')
result = cmd.run()
self.assertEqual(result, 2)
out = self.out_.getvalue()
self.assertTrue(out.startswith('Unavailable scaffolds'))
def test_known_scaffold_single_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.1',
'pyramid_docs_branch': '0.1-branch'
})
def test_scaffold_with_hyphen_in_project_name(self):
import os
cmd = self._makeOne('-s', 'dummy', 'Distro-')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro-')))
self.assertEqual(
scaffold.vars, {
'project': 'Distro-',
'egg': 'Distro_',
'package': 'distro_',
'pyramid_version': '0.1',
'pyramid_docs_branch': '0.1-branch'
})
def test_known_scaffold_absolute_path(self):
import os
path = os.path.abspath('Distro')
cmd = self._makeOne('-s', 'dummy', path)
cmd.pyramid_dist = DummyDist("0.1")
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.1',
'pyramid_docs_branch': '0.1-branch'
})
def test_known_scaffold_multiple_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy1', '-s', 'dummy2', 'Distro')
scaffold1 = DummyScaffold('dummy1')
scaffold2 = DummyScaffold('dummy2')
cmd.scaffolds = [scaffold1, scaffold2]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(scaffold1.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(
scaffold1.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.1',
'pyramid_docs_branch': '0.1-branch'
})
self.assertEqual(scaffold2.output_dir,
os.path.normpath(os.path.join(os.getcwd(), 'Distro')))
self.assertEqual(
scaffold2.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.1',
'pyramid_docs_branch': '0.1-branch'
})
def test_known_scaffold_with_path_as_project_target_rendered(self):
import os
cmd = self._makeOne('-s', 'dummy', '/tmp/foo/Distro/')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.output_dir,
os.path.normpath(os.path.join(os.getcwd(), '/tmp/foo/Distro')))
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.1',
'pyramid_docs_branch': '0.1-branch'
})
def test_scaffold_with_prod_pyramid_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.2")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.2',
'pyramid_docs_branch': '0.2-branch'
})
def test_scaffold_with_prod_pyramid_long_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.2.1")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.2.1',
'pyramid_docs_branch': '0.2-branch'
})
def test_scaffold_with_prod_pyramid_unparsable_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("abc")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': 'abc',
'pyramid_docs_branch': 'latest'
})
def test_scaffold_with_dev_pyramid_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.12dev")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.12dev',
'pyramid_docs_branch': 'master'
})
def test_scaffold_with_dev_pyramid_long_version(self):
cmd = self._makeOne('-s', 'dummy', 'Distro')
scaffold = DummyScaffold('dummy')
cmd.scaffolds = [scaffold]
cmd.pyramid_dist = DummyDist("0.10.1dev")
result = cmd.run()
self.assertEqual(result, 0)
self.assertEqual(
scaffold.vars, {
'project': 'Distro',
'egg': 'Distro',
'package': 'distro',
'pyramid_version': '0.10.1dev',
'pyramid_docs_branch': 'master'
})
class TestPServeCommand(unittest.TestCase):
def setUp(self):
from pyramid.compat import NativeIO
self.out_ = NativeIO()
self.config_factory = dummy.DummyConfigParserFactory()
def out(self, msg):
self.out_.write(msg)
def _get_server(*args, **kwargs):
def server(app):
return ''
return server
def _getTargetClass(self):
from pyramid.scripts.pserve import PServeCommand
return PServeCommand
def _makeOne(self, *args):
effargs = ['pserve']
effargs.extend(args)
cmd = self._getTargetClass()(effargs)
cmd.out = self.out
cmd.ConfigParser = self.config_factory
return cmd
def test_run_no_args(self):
inst = self._makeOne()
result = inst.run()
self.assertEqual(result, 2)
self.assertEqual(self.out_.getvalue(), 'You must give a config file')
def test_config_vars_no_command(self):
inst = self._makeOne()
inst.args.config_uri = 'foo'
inst.args.config_vars = ['a=1', 'b=2']
result = inst.get_config_vars()
self.assertEqual(result, {'a': '1', 'b': '2'})
def test_parse_vars_good(self):
inst = self._makeOne('development.ini', 'a=1', 'b=2')
inst.loadserver = self._get_server
app = dummy.DummyApp()
def get_app(*args, **kwargs):
app.global_conf = kwargs.get('global_conf', None)
inst.loadapp = get_app
inst.run()
self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
def test_parse_vars_bad(self):
inst = self._makeOne('development.ini', 'a')
inst.loadserver = self._get_server
self.assertRaises(ValueError, inst.run)
def test_config_file_finds_watch_files(self):
inst = self._makeOne('development.ini')
self.config_factory.items = [(
'watch_files',
'foo\n/baz\npyramid.tests.test_scripts:*.py',
)]
inst.pserve_file_config('/base/path.ini', global_conf={'a': '1'})
self.assertEqual(self.config_factory.defaults, {
'a': '1',
'here': os.path.abspath('/base'),
})
self.assertEqual(
inst.watch_files,
set([
os.path.abspath('/base/foo'),
os.path.abspath('/baz'),
os.path.abspath(os.path.join(here, '*.py')),
]))
def test_config_file_finds_open_url(self):
inst = self._makeOne('development.ini')
self.config_factory.items = [(
'open_url',
'http://127.0.0.1:8080/',
)]
inst.pserve_file_config('/base/path.ini', global_conf={'a': '1'})
self.assertEqual(self.config_factory.defaults, {
'a': '1',
'here': os.path.abspath('/base'),
})
self.assertEqual(inst.open_url, 'http://127.0.0.1:8080/')
def test__guess_server_url(self):
inst = self._makeOne('development.ini')
self.config_factory.items = [(
'port',
'8080',
)]
url = inst._guess_server_url('/base/path.ini',
'main',
global_conf={'a': '1'})
self.assertEqual(self.config_factory.defaults, {
'a': '1',
'here': os.path.abspath('/base'),
})
self.assertEqual(self.config_factory.parser.section, 'server:main')
self.assertEqual(url, 'http://127.0.0.1:8080')
def test_reload_call_hupper_with_correct_args(self):
from pyramid.scripts import pserve
class AttrDict(dict):
def __init__(self, *args, **kwargs):
super(AttrDict, self).__init__(*args, **kwargs)
self.__dict__ = self
def dummy_start_reloader(*args, **kwargs):
dummy_start_reloader.args = args
dummy_start_reloader.kwargs = kwargs
orig_hupper = pserve.hupper
try:
pserve.hupper = AttrDict(is_active=lambda: False,
start_reloader=dummy_start_reloader)
inst = self._makeOne('--reload', 'development.ini')
inst.run()
finally:
pserve.hupper = orig_hupper
self.assertEquals(dummy_start_reloader.args,
('pyramid.scripts.pserve.main', ))
self.assertEquals(
dummy_start_reloader.kwargs, {
'reload_interval': 1,
'verbose': 1,
'worker_kwargs': {
'argv': ['pserve', '--reload', 'development.ini'],
'quiet': False
}
})
def to_bytes(self, obj, encoding=None):
stream = NativeIO()
self.to_stream(obj, stream)
return stream.getvalue()
class Test_copy_dir(unittest.TestCase):
def setUp(self):
import tempfile
from pyramid.compat import NativeIO
self.dirname = tempfile.mkdtemp()
self.out = NativeIO()
self.fixturetuple = ('pyramid.tests.test_scaffolds',
'fixture_scaffold')
def tearDown(self):
import shutil
shutil.rmtree(self.dirname, ignore_errors=True)
self.out.close()
def _callFUT(self, *arg, **kw):
kw['out_'] = self.out
from pyramid.scaffolds.copydir import copy_dir
return copy_dir(*arg, **kw)
def test_copy_source_as_pkg_resource(self):
vars = {'package':'mypackage'}
self._callFUT(self.fixturetuple,
self.dirname,
vars,
1, False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Creating %s/mypackage/' % self.dirname in result)
self.assertTrue(
'Copying fixture_scaffold/+package+/__init__.py_tmpl to' in result)
source = pkg_resources.resource_filename(
'pyramid.tests.test_scaffolds',
'fixture_scaffold/+package+/__init__.py_tmpl')
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'r') as f:
tcontent = f.read()
with open(source, 'r') as f:
scontent = f.read()
self.assertEqual(scontent, tcontent)
def test_copy_source_as_dirname(self):
vars = {'package':'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1, False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Creating %s/mypackage/' % self.dirname in result)
self.assertTrue('Copying __init__.py_tmpl to' in result)
source = pkg_resources.resource_filename(
'pyramid.tests.test_scaffolds',
'fixture_scaffold/+package+/__init__.py_tmpl')
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'r') as f:
tcontent = f.read()
with open(source, 'r') as f:
scontent = f.read()
self.assertEqual(scontent, tcontent)
def test_content_is_same_message(self):
vars = {'package':'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
2, False,
template_renderer=dummy_template_renderer)
self._callFUT(source,
self.dirname,
vars,
2, False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('%s already exists (same content)' % \
os.path.join(self.dirname, 'mypackage', '__init__.py') in result)
def test_direxists_message(self):
vars = {'package':'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
# if not os.path.exists(self.dirname):
# os.mkdir(self.dirname)
self._callFUT(source,
self.dirname,
vars,
2, False,
template_renderer=dummy_template_renderer)
result = self.out.getvalue()
self.assertTrue('Directory %s exists' % self.dirname in result, result)
def test_overwrite_false(self):
vars = {'package':'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1, False,
overwrite=False,
template_renderer=dummy_template_renderer)
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'w') as f:
f.write('These are not the words you are looking for.')
self._callFUT(source,
self.dirname,
vars,
1, False,
overwrite=False,
template_renderer=dummy_template_renderer)
def test_detect_SkipTemplate(self):
vars = {'package':'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
def dummy_template_renderer(*args, **kwargs):
from pyramid.scaffolds.copydir import SkipTemplate
raise SkipTemplate
self._callFUT(source,
self.dirname,
vars,
1, False,
template_renderer=dummy_template_renderer)
def test_query_interactive(self):
from pyramid.scaffolds import copydir
vars = {'package':'mypackage'}
source = pkg_resources.resource_filename(*self.fixturetuple)
self._callFUT(source,
self.dirname,
vars,
1, False,
overwrite=False,
template_renderer=dummy_template_renderer)
target = os.path.join(self.dirname, 'mypackage', '__init__.py')
with open(target, 'w') as f:
f.write('These are not the words you are looking for.')
# We need query_interactive to return False in order to force
# execution of a branch
original_code_object = copydir.query_interactive
copydir.query_interactive = lambda *args, **kwargs: False
self._callFUT(source,
self.dirname,
vars,
1, False,
interactive=True,
overwrite=False,
template_renderer=dummy_template_renderer)
copydir.query_interactive = original_code_object
def test_settings_command(self):
field = ptah.form.TextField('node', default='test')
ptah.register_settings(
'group1',
field,
title='Section1',
description='Description1',
)
ptah.register_settings(
'group2',
field,
title='Section2',
description='Description2',
)
self.init_ptah()
group1 = ptah.get_settings('group1', self.registry)
group2 = ptah.get_settings('group2', self.registry)
# all
sys.argv[1:] = ['-a']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
settings.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Section1', val)
self.assertIn('Section2', val)
self.assertIn('group1.node', val)
self.assertIn('group2.node', val)
# section
sys.argv[1:] = ['-l', 'group1']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
settings.main(False)
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Section1', val)
self.assertNotIn('Section2', val)
self.assertIn('group1.node', val)
self.assertNotIn('group2.node', val)
# print
sys.argv[1:] = ['-p']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
settings.main(False)
sys.stdout = stdout
val = out.getvalue().strip()
self.assertIn('group1.node = "test"', val)
self.assertIn('group2.node = "test"', val)
def test_dump_no_content_type(self):
member = _make_test_entity_member()
strm = NativeIO()
dump_resource(member, strm)
self.assert_true(strm.getvalue().startswith('"id",'))
def test_build_bundle(self, m_bs, m_binit):
m_bs.return_value = {'registry': self.registry,
'request': self.request}
m_binit.return_value = '123'
self.config.add_amd_js(
'test', 'pyramid_amdjs:tests/dir/test.js', 'Test module')
self.config.add_handlebars_bundle(
'handlebars-test', 'pyramid_amdjs:tests/dir/', 'Handlebars bundle')
cfg = self.registry.settings
sys.argv[1:] = ['-b', 'pyramid_amdjs.ini']
stdout = sys.stdout
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Spec files are not specified in .ini file', val)
cfg['amd.spec'] = [('main', 'pyramid_amdjs:tests/amd.spec')]
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn(
'Destination directory is not specified in .ini file', val)
d = tempfile.mkdtemp()
cfg['amd.spec-dir'] = d
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Processing: main (pyramid_amdjs:tests/amd.spec)', val)
self.assertIn("""
* bundle.js
test: pyramid_amdjs:tests/dir/test.js
handlebars-test: templates bundle""", val)
self.assertTrue(os.path.isfile(os.path.join(d, 'bundle.js')))
self.assertFalse(os.path.isfile(os.path.join(d, 'bundle2.js')))
self.assertTrue(os.path.isfile(os.path.join(d, 'init-main.js')))
shutil.rmtree(d)
d = tempfile.mkdtemp()
cfg['amd.spec-dir'] = d
sys.argv[1:] = ['-b', '--no-min', 'pyramid_amdjs.ini']
out = NativeIO()
sys.stdout = out
amd.main()
sys.stdout = stdout
val = out.getvalue()
self.assertIn('Processing: main (pyramid_amdjs:tests/amd.spec)', val)
self.assertIn("""
* bundle.js
test: pyramid_amdjs:tests/dir/test.js
handlebars-test: templates bundle""", val)
self.assertTrue(os.path.isfile(os.path.join(d, 'bundle.js')))
shutil.rmtree(d)
