def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
:param path: the absolute path to the Trac environment
:param create: if `True`, the environment is created and
populated with default data; otherwise, the
environment is expected to already exist.
:param options: A list of `(section, name, value)` tuples that
define configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.log = None
self.config = None
# System info should be provided through ISystemInfoProvider rather
# than appending to systeminfo, which may be a private in a future
# release.
self.systeminfo = []
if create:
self.create(options)
else:
self.verify()
self.setup_config()
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
:param path: the absolute path to the Trac environment
:param create: if `True`, the environment is created and
populated with default data; otherwise, the
environment is expected to already exist.
:param options: A list of `(section, name, value)` tuples that
define configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.systeminfo = []
self._href = self._abs_href = None
if create:
self.create(options)
else:
self.verify()
self.setup_config()
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
def __init__(self, default_data=False, enable=None):
ComponentManager.__init__(self)
Component.__init__(self)
self.enabled_components = enable
self.db = InMemoryDatabase()
self.path = ''
self.config = TestConfiguration(None)
from trac.log import logger_factory
self.log = logger_factory('test')
from trac.web.href import Href
self.href = Href('/trac.cgi')
self.abs_href = Href('http://example.org/trac.cgi')
from trac import db_default
if default_data:
cursor = self.db.cursor()
for table, cols, vals in db_default.get_data(self.db):
cursor.executemany(
"INSERT INTO %s (%s) VALUES (%s)" %
(table, ','.join(cols), ','.join(['%s' for c in cols])),
vals)
self.db.commit()
self.known_users = []
def __init__(self, path, create=False, options=[]):
# global environment w/o parent, set these two before super.__init__
# as database access can take place within trac.env.Environment
self.parent = None
self.product = None
# `trac.env.Environment.__init__` is not invoked as creation is handled differently
# from base implementation - different setup participants are invoked when creating
# global environment.
ComponentManager.__init__(self)
self.path = path
self.systeminfo = []
self._href = self._abs_href = None
self._multiproduct_schema_enabled = False
if create:
self.create(options)
else:
self.verify()
self.setup_config()
# invoke `IEnvironmentSetupParticipant.environment_created` for all
# global setup participants
if create:
for participant in self.global_setup_participants:
with ComponentEnvironmentContext(self, participant):
participant.environment_created()
def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
@param path: the absolute path to the Trac environment
@param create: if `True`, the environment is created and populated with
default data; otherwise, the environment is expected to
already exist.
@param options: A list of `(section, name, value)` tuples that define
configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.setup_config(load_defaults=create)
self.setup_log()
from trac.loader import load_components
load_components(self)
if create:
self.create(options)
else:
self.verify()
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
@param path: the absolute path to the Trac environment
@param create: if `True`, the environment is created and populated with
default data; otherwise, the environment is expected to
already exist.
@param options: A list of `(section, name, value)` tuples that define
configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.setup_config(load_defaults=create)
self.setup_log()
from trac.loader import load_components
load_components(self)
if create:
self.create(options)
else:
self.verify()
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
:param path: the absolute path to the Trac environment
:param create: if `True`, the environment is created and
populated with default data; otherwise, the
environment is expected to already exist.
:param options: A list of `(section, name, value)` tuples that
define configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.log = None
self.config = None
# System info should be provided through ISystemInfoProvider rather
# than appending to systeminfo, which may be a private in a future
# release.
self.systeminfo = []
if create:
self.create(options)
for setup_participant in self.setup_participants:
setup_participant.environment_created()
else:
self.verify()
self.setup_config()
def __init__(self, path, create=False, db_str=None):
"""Initialize the Trac environment.
@param path: the absolute path to the Trac environment
@param create: if `True`, the environment is created and populated with
default data; otherwise, the environment is expected to
already exist.
@param db_str: the database connection string
"""
ComponentManager.__init__(self)
try: # Use binary I/O on Windows
import msvcrt, sys
msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
except ImportError:
pass
self.path = path
self.__cnx_pool = None
if create:
self.create(db_str)
else:
self.verify()
self.load_config()
self.setup_log()
from trac.loader import load_components
load_components(self)
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
def __init__(self, path, create=False, db_str=None):
"""Initialize the Trac environment.
@param path: the absolute path to the Trac environment
@param create: if `True`, the environment is created and populated with
default data; otherwise, the environment is expected to
already exist.
@param db_str: the database connection string
"""
ComponentManager.__init__(self)
self.path = path
self.__cnx_pool = None
if create:
self.create(db_str)
else:
self.verify()
self.load_config()
self.setup_log()
from trac.loader import load_components
load_components(self)
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
:param path: the absolute path to the Trac environment
:param create: if `True`, the environment is created and
populated with default data; otherwise, the
environment is expected to already exist.
:param options: A list of `(section, name, value)` tuples that
define configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.systeminfo = []
self._href = self._abs_href = None
if create:
self.create(options)
else:
self.verify()
self.setup_config()
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
def __init__(self, path, create=False, options=[]):
# global environment w/o parent, set these two before super.__init__
# as database access can take place within trac.env.Environment
self.parent = None
self.product = None
# `trac.env.Environment.__init__` is not invoked as creation is handled differently
# from base implementation - different setup participants are invoked when creating
# global environment.
ComponentManager.__init__(self)
self.path = path
self.systeminfo = []
self._href = self._abs_href = None
self._multiproduct_schema_enabled = False
if create:
self.create(options)
else:
self.verify()
self.setup_config()
# invoke `IEnvironmentSetupParticipant.environment_created` for all
# global setup participants
if create:
for participant in self.global_setup_participants:
with ComponentEnvironmentContext(self, participant):
participant.environment_created()
def __init__(self):
ComponentManager.__init__(self)
self.log = logger_factory('null')
self.config = Configuration(None)
self.href = Href('/')
self.abs_href = Href('http://www.example.com/')
self._wiki_pages = {}
self.path = ''
def __init__(self, enable=[]):
ComponentManager.__init__(self)
from trac.config import Configuration
from trac.log import logger_factory
self.config = Configuration(None)
self.log = logger_factory('test')
self.href = Href('/trac.cgi')
self.enabled_components = enable
def __init__(self, path, create=False, options=[]):
ComponentManager.__init__(self)
self.path = path
self.href = self.abs_href = None
if create:
self.create(options)
else:
self.verify()
self.setup_config()
def __init__(self, path, create=False, options=[]):
ComponentManager.__init__(self)
self.path = path
self.systeminfo = []
self.href = self.abs_href = None
if create:
self.create(options)
else:
self.verify()
self.setup_config()
def __init__(self, default_data=False, enable=None):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
"""
ComponentManager.__init__(self)
Component.__init__(self)
self.systeminfo = []
import trac
self.path = os.path.dirname(trac.__file__)
if not os.path.isabs(self.path):
self.path = os.path.join(os.getcwd(), self.path)
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'stderr')
if enable is not None:
self.config.set('components', 'trac.*', 'disabled')
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'enabled')
# -- logging
from trac.log import logger_handler_factory
self.log, self._log_handler = logger_handler_factory('test')
# -- database
self.dburi = get_dburi()
if self.dburi.startswith('sqlite'):
self.config.set('trac', 'database', 'sqlite::memory:')
self.db = InMemoryDatabase()
if default_data:
self.reset_db(default_data)
from trac.web.href import Href
self.href = Href('/trac.cgi')
self.abs_href = Href('http://example.org/trac.cgi')
self.known_users = []
translation.activate(Locale and Locale('en', 'US'))
def __init__(self, default_data=False, enable=None):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
"""
ComponentManager.__init__(self)
Component.__init__(self)
self.systeminfo = []
import trac
self.path = os.path.dirname(trac.__file__)
if not os.path.isabs(self.path):
self.path = os.path.join(os.getcwd(), self.path)
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'stderr')
if enable is not None:
self.config.set('components', 'trac.*', 'disabled')
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'enabled')
# -- logging
from trac.log import logger_handler_factory
self.log, self._log_handler = logger_handler_factory('test')
# -- database
self.dburi = get_dburi()
if self.dburi.startswith('sqlite'):
self.config.set('trac', 'database', 'sqlite::memory:')
self.db = InMemoryDatabase()
if default_data:
self.reset_db(default_data)
from trac.web.href import Href
self.href = Href('/trac.cgi')
self.abs_href = Href('http://example.org/trac.cgi')
self.known_users = []
translation.activate(Locale and Locale('en', 'US'))
def __getitem__(self, cls):
if issubclass(cls, trac.env.Environment):
return self.parent
elif cls is self.__class__:
return self
else:
return ComponentManager.__getitem__(self, cls)
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.milestone1 = Milestone(self.env)
self.milestone1.name = 'Test'
self.milestone1.insert()
self.milestone2 = Milestone(self.env)
self.milestone2.name = 'Test2'
self.milestone2.insert()
tkt1 = Ticket(self.env)
tkt1.populate({'summary': 'Foo', 'milestone': 'Test', 'owner': 'foman',
'status': 'new'})
tkt1.insert()
tkt2 = Ticket(self.env)
tkt2.populate({'summary': 'Bar', 'milestone': 'Test',
'status': 'closed', 'owner': 'barman'})
tkt2.insert()
tkt3 = Ticket(self.env)
tkt3.populate({'summary': 'Sum', 'milestone': 'Test', 'owner': 'suman',
'status': 'reopened'})
tkt3.insert()
self.tkt1 = tkt1
self.tkt2 = tkt2
self.tkt3 = tkt3
prov = DefaultTicketGroupStatsProvider(ComponentManager())
prov.env = self.env
prov.config = self.env.config
self.stats = prov.get_ticket_group_stats([tkt1.id, tkt2.id, tkt3.id])
def setUp(self):
self.env = EnvironmentStub(default_data=True)
self.milestone1 = Milestone(self.env)
self.milestone1.name = 'Test'
self.milestone1.insert()
self.milestone2 = Milestone(self.env)
self.milestone2.name = 'Test2'
self.milestone2.insert()
tkt1 = insert_ticket(self.env,
summary='Foo',
milestone='Test',
owner='foman',
status='new')
tkt2 = insert_ticket(self.env,
summary='Bar',
milestone='Test',
status='closed',
owner='barman')
tkt3 = insert_ticket(self.env,
summary='Sum',
milestone='Test',
owner='suman',
status='reopened')
self.tkt1 = tkt1
self.tkt2 = tkt2
self.tkt3 = tkt3
prov = DefaultTicketGroupStatsProvider(ComponentManager())
prov.env = self.env
prov.config = self.env.config
self.stats = prov.get_ticket_group_stats([tkt1.id, tkt2.id, tkt3.id])
def __getitem__(self, cls):
if issubclass(cls, trac.env.Environment):
return self.parent
elif cls is self.__class__:
return self
else:
return ComponentManager.__getitem__(self, cls)
def setUp(self):
from multiproject.core.configuration import conf
from vcm import RepositoriesAdminPanel
RepositoriesAdminPanel.env = Mock()
from trac.core import ComponentManager
mgr = ComponentManager()
self.rap = RepositoriesAdminPanel(mgr)
def setUp(self):
from trac.core import ComponentMeta
self.compmgr = ComponentManager()
# Make sure we have no external components hanging around in the
# component registry
self.old_registry = ComponentMeta._registry
ComponentMeta._registry = {}
def setUp(self):
self.env = EnvironmentStub()
self.req = Mock()
self.request_dispatcher = RequestDispatcher(self.env)
self.compmgr = ComponentManager()
# Make sure we have no external components hanging around in the
# component registry
self.old_registry = ComponentMeta._registry
ComponentMeta._registry = {}
def __init__(self, default_data=False, enable=None):
"""Construct a new Environment stub object.
default_data: If True, populate the database with some defaults.
enable: A list of component classes or name globs to activate in the
stub environment.
"""
ComponentManager.__init__(self)
Component.__init__(self)
self.enabled_components = enable or ['trac.*']
self.systeminfo = [('Python', sys.version)]
import trac
self.path = os.path.dirname(trac.__file__)
if not os.path.isabs(self.path):
self.path = os.path.join(os.getcwd(), self.path)
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'stderr')
# -- logging
from trac.log import logger_factory
self.log = logger_factory('test')
# -- database
self.dburi = get_dburi()
if self.dburi.startswith('sqlite'):
self.db = InMemoryDatabase()
if default_data:
self.reset_db(default_data)
from trac.web.href import Href
self.href = Href('/trac.cgi')
self.abs_href = Href('http://example.org/trac.cgi')
self.known_users = []
def __init__(self, path, create=False, options=[]):
"""Initialize the Trac environment.
@param path: the absolute path to the Trac environment
@param create: if `True`, the environment is created and populated with
default data; otherwise, the environment is expected to
already exist.
@param options: A list of `(section, name, value)` tuples that define
configuration options
"""
ComponentManager.__init__(self)
self.path = path
self.setup_config(load_defaults=create)
self.setup_log()
from trac import core, __version__ as VERSION
trac_version = get_pkginfo(core).get('version', VERSION)
self.systeminfo = [
('Trac', trac_version),
('Python', sys.version),
('setuptools', setuptools.__version__),
]
self.log.info('-' * 32 + ' environment startup [Trac %s] ' + '-' * 32,
trac_version)
self._href = self._abs_href = None
from trac.loader import load_components
plugins_dir = self.shared_plugins_dir
load_components(self, plugins_dir and (plugins_dir,))
if create:
self.create(options)
else:
self.verify()
if create:
for setup_participant in self.setup_participants:
setup_participant.environment_created()
self._known_users_cache_time = 0
self._known_users_cache = None
def setUp(self):
# self.env = EnvironmentStub()
env_path = os.path.join(tempfile.gettempdir(), 'trac-tempenv')
self.env = Environment(env_path, create=True)
self.db = self.env.get_db_cnx()
self.compmgr = ComponentManager()
# init TicketTemplateModule
self.tt = ttadmin.TicketTemplateModule(self.compmgr)
setattr(self.tt, "env", self.env)
def __init__(self, env, product, create=False):
"""Initialize the product environment.
:param env: the global Trac environment
:param product: product prefix or an instance of
multiproduct.model.Product
"""
if not isinstance(env, trac.env.Environment):
cls = self.__class__
raise TypeError("Initializer must be called with " \
"trac.env.Environment instance as first argument " \
"(got %s instance instead)" %
(cls.__module__ + '.' + cls.__name__, ))
ComponentManager.__init__(self)
if isinstance(product, Product):
if product._env is not env:
raise ValueError("Product's environment mismatch")
elif isinstance(product, basestring):
products = Product.select(env, where={'prefix': product})
if len(products) == 1 :
product = products[0]
else:
env.log.debug("Products for '%s' : %s",
product, products)
raise LookupError("Missing product %s" % (product,))
self.parent = env
self.product = product
self.systeminfo = []
self.setup_config()
# when creating product environment, invoke `IEnvironmentSetupParticipant.environment_created`
# for all setup participants that don't support multi product environments
if create:
for participant in self.product_setup_participants:
with ComponentEnvironmentContext(self, participant):
participant.environment_created()
def __init__(self, env, product, create=False):
"""Initialize the product environment.
:param env: the global Trac environment
:param product: product prefix or an instance of
multiproduct.model.Product
"""
if not isinstance(env, trac.env.Environment):
cls = self.__class__
raise TypeError("Initializer must be called with " \
"trac.env.Environment instance as first argument " \
"(got %s instance instead)" %
(cls.__module__ + '.' + cls.__name__, ))
ComponentManager.__init__(self)
if isinstance(product, Product):
if product._env is not env:
raise ValueError("Product's environment mismatch")
elif isinstance(product, basestring):
products = Product.select(env, where={'prefix': product})
if len(products) == 1:
product = products[0]
else:
env.log.debug("Products for '%s' : %s", product, products)
raise LookupError("Missing product %s" % (product, ))
self.parent = env
self.product = product
self.systeminfo = []
self.setup_config()
# when creating product environment, invoke `IEnvironmentSetupParticipant.environment_created`
# for all setup participants that don't support multi product environments
if create:
for participant in self.product_setup_participants:
with ComponentEnvironmentContext(self, participant):
participant.environment_created()
def __init__(self, path, create=False, options=[], default_data=True):
"""Initialize the Trac environment.
:param path: the absolute path to the Trac environment
:param create: if `True`, the environment is created and otherwise,
the environment is expected to already exist.
:param options: A list of `(section, name, value)` tuples that
define configuration options
:param default_data: if `True` (the default), the environment is
populated with default data when created.
"""
ComponentManager.__init__(self)
self.path = os.path.normpath(os.path.normcase(path))
self.log = None
self.config = None
if create:
self.create(options, default_data)
for setup_participant in self.setup_participants:
setup_participant.environment_created()
else:
self.verify()
self.setup_config()
def setUp(self):
"""
Create a directory full of pseudo-releases to be inspected by
L{ProjectVersionMacro} in its expansion.
"""
self.releases = FilePath(self.mktemp())
self.releases.makedirs()
self.releases.child('twisted-9.0.0-md5sums.txt').touch()
self.releases.child('twisted-10.0.0-md5sums.txt').touch()
self.releases.child('twisted-11.1.0-md5sums.txt').touch()
self.releases.child('twisted-12.2.3-md5sums.txt').setContent(
self.md5sums)
self.macro = ProjectVersionMacro(ComponentManager())
self.macro.log = lambda *args: None
self.macro.log.error = lambda *args: None
self.macro.log.warn = lambda *args: None
self.macro.RELEASES = self.releases
def __init__(self, config_file=None, enabled_plugins=None, path=None):
"""
:param str config_file: path to the main configuration file.
Defaults to ``/etc/trac/project.ini`` which is normal project configuration.
:param list enabled_plugins:
An explicit list of plugins to load, instead of reading enabled [components]
from ``config_file``. If empty list is given no plugins are loaded.
However plugins can be still listed via ``extra_plugins`` arg.
:param str path: path to the imaginary trac location.
"""
if config_file is None:
# TODO: switch to some constant when can be done without conf
from multiproject.core.configuration import conf
config_file = conf.config_file
# From Environment.setup_config:
self.config = Configuration(config_file)
if path is None:
path = os.path.join(self.config.get('multiproject', 'sys_projects_root'), '__mock_environment__')
if enabled_plugins is not None:
# explicit list given, disable all from configuration
for key, val in self.config.options('components'):
self.config.remove('components', key)
# and replace with the given list
for plugin in enabled_plugins:
self.config.set('components', plugin, u'enabled')
# We override the Environment.__init__ here.
# Environment.__init__ is as follows:
# ComponentManager.__init__(self)
#
# self.path = path
# self.systeminfo = []
# self._href = self._abs_href = None
#
# if create:
# self.create(options)
# else:
# self.verify()
# self.setup_config()
#
# if create:
# for setup_participant in self.setup_participants:
# setup_participant.environment_created()
# The Environment.setup_config is as follows:
# self.config = Configuration(os.path.join(self.path, 'conf',
# 'trac.ini'))
# self.setup_log()
# from trac.loader import load_components
# plugins_dir = self.shared_plugins_dir
# load_components(self, plugins_dir and (plugins_dir,))
# We use suitable lines from these as follows:
# From Environment.__init__:
ComponentManager.__init__(self)
self.path = path
self.systeminfo = []
self._href = self._abs_href = None
# Our own plugin hack ends here, and setup_config lines continue here
self.setup_log()
from trac.loader import load_components
load_components(self)
def __init__(self,
default_data=False,
enable=None,
disable=None,
path=None,
destroying=False,
config=None):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
:param disable: A list of component classes or name globs to
deactivate in the stub environment.
:param path: The location of the environment in the file system.
No files or directories are created when specifying
this parameter.
:param destroying: If True, the database will not be reset. This is
useful for cases when the object is being
constructed in order to call `destroy_db`.
:param config: A list of (section, key, value) configuration
tuples.
"""
if enable is not None and not isinstance(enable, (list, tuple)):
raise TypeError('Keyword argument "enable" must be a list')
if disable is not None and not isinstance(disable, (list, tuple)):
raise TypeError('Keyword argument "disable" must be a list')
ComponentManager.__init__(self)
self._old_registry = None
self._old_components = None
import trac
self.path = path
if self.path is None:
self.path = os.path.abspath(os.path.dirname(trac.__file__))
self.path = os.path.normpath(os.path.normcase(self.path))
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'none') # Ignored.
if enable is not None:
self.config.set('components', 'trac.*', 'disabled')
else:
self.config.set('components', 'tracopt.versioncontrol.*',
'enabled')
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'enabled')
for name_or_class in disable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'disabled')
self.config.set('trac', 'permission_policies',
'DefaultPermissionPolicy, LegacyAttachmentPolicy')
for item in config or []:
self.config.set(*item)
# -- logging
self.setup_log()
# -- database
self.dburi = get_dburi()
self.config.set('components', 'trac.db.*', 'enabled')
self.config.set('trac', 'database', self.dburi)
if not destroying:
self.reset_db(default_data)
self.config.set('trac', 'base_url', 'http://example.org/trac.cgi')
translation.activate(locale_en)
def __init__(self, foo, bar):
ComponentManager.__init__(self)
self.foo, self.bar = foo, bar
def setUp(self):
compmgr = ComponentManager()
self.e = TracEmoji(compmgr)
super(self.__class__, self).setUp()
def __init__(self, foo, bar):
ComponentManager.__init__(self)
self.foo, self.bar = foo, bar
def __init__(self, default_data=False, enable=None, disable=None,
path=None, destroying=False):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
:param disable: A list of component classes or name globs to
deactivate in the stub environment.
:param path: The location of the environment in the file system.
No files or directories are created when specifying
this parameter.
:param destroying: If True, the database will not be reset. This is
useful for cases when the object is being
constructed in order to call `destroy_db`.
"""
if enable is not None and not isinstance(enable, (list, tuple)):
raise TypeError('Keyword argument "enable" must be a list')
if disable is not None and not isinstance(disable, (list, tuple)):
raise TypeError('Keyword argument "disable" must be a list')
ComponentManager.__init__(self)
self.systeminfo = []
import trac
self.path = path
if self.path is None:
self.path = os.path.dirname(trac.__file__)
if not os.path.isabs(self.path):
self.path = os.path.join(os.getcwd(), self.path)
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'stderr')
if enable is not None:
self.config.set('components', 'trac.*', 'disabled')
else:
self.config.set('components', 'tracopt.versioncontrol.*',
'enabled')
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'enabled')
for name_or_class in disable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'disabled')
# -- logging
from trac.log import logger_handler_factory
self.log, self._log_handler = logger_handler_factory('test')
# -- database
self.config.set('components', 'trac.db.*', 'enabled')
self.dburi = get_dburi()
init_global = False
if self.global_databasemanager:
self.components[DatabaseManager] = self.global_databasemanager
else:
self.config.set('trac', 'database', self.dburi)
self.global_databasemanager = DatabaseManager(self)
self.config.set('trac', 'debug_sql', True)
init_global = not destroying
if default_data or init_global:
self.reset_db(default_data)
self.config.set('trac', 'base_url', 'http://example.org/trac.cgi')
self.known_users = []
translation.activate(locale_en)
def __init__(self, config_file=None, enabled_plugins=None, path=None):
"""
:param str config_file: path to the main configuration file.
Defaults to ``/etc/trac/project.ini`` which is normal project configuration.
:param list enabled_plugins:
An explicit list of plugins to load, instead of reading enabled [components]
from ``config_file``. If empty list is given no plugins are loaded.
However plugins can be still listed via ``extra_plugins`` arg.
:param str path: path to the imaginary trac location.
"""
if config_file is None:
# TODO: switch to some constant when can be done without conf
from multiproject.core.configuration import conf
config_file = conf.config_file
# From Environment.setup_config:
self.config = Configuration(config_file)
if path is None:
path = os.path.join(
self.config.get('multiproject', 'sys_projects_root'),
'__mock_environment__')
if enabled_plugins is not None:
# explicit list given, disable all from configuration
for key, val in self.config.options('components'):
self.config.remove('components', key)
# and replace with the given list
for plugin in enabled_plugins:
self.config.set('components', plugin, u'enabled')
# We override the Environment.__init__ here.
# Environment.__init__ is as follows:
# ComponentManager.__init__(self)
#
# self.path = path
# self.systeminfo = []
# self._href = self._abs_href = None
#
# if create:
# self.create(options)
# else:
# self.verify()
# self.setup_config()
#
# if create:
# for setup_participant in self.setup_participants:
# setup_participant.environment_created()
# The Environment.setup_config is as follows:
# self.config = Configuration(os.path.join(self.path, 'conf',
# 'trac.ini'))
# self.setup_log()
# from trac.loader import load_components
# plugins_dir = self.shared_plugins_dir
# load_components(self, plugins_dir and (plugins_dir,))
# We use suitable lines from these as follows:
# From Environment.__init__:
ComponentManager.__init__(self)
self.path = path
self.systeminfo = []
self._href = self._abs_href = None
# Our own plugin hack ends here, and setup_config lines continue here
self.setup_log()
from trac.loader import load_components
load_components(self)
def setUp(self):
self.env = EnvironmentStub()
self.req = MockRequest(self.env)
self.request_dispatcher = RequestDispatcher(self.env)
self.compmgr = ComponentManager()
self.env.clear_component_registry()
def __init__(self, default_data=False, enable=None, disable=None,
path=None, destroying=False):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
:param disable: A list of component classes or name globs to
deactivate in the stub environment.
:param path: The location of the environment in the file system.
No files or directories are created when specifying
this parameter.
:param destroying: If True, the database will not be reset. This is
useful for cases when the object is being
constructed in order to call `destroy_db`.
"""
if enable is not None and not isinstance(enable, (list, tuple)):
raise TypeError('Keyword argument "enable" must be a list')
if disable is not None and not isinstance(disable, (list, tuple)):
raise TypeError('Keyword argument "disable" must be a list')
ComponentManager.__init__(self)
self._old_registry = None
self._old_components = None
import trac
self.path = path
if self.path is None:
self.path = os.path.abspath(os.path.dirname(trac.__file__))
self.path = os.path.normpath(os.path.normcase(self.path))
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'none') # Ignored.
if enable is not None:
self.config.set('components', 'trac.*', 'disabled')
else:
self.config.set('components', 'tracopt.versioncontrol.*',
'enabled')
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'enabled')
for name_or_class in disable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'disabled')
self.config.set('trac', 'permission_policies',
'DefaultPermissionPolicy, LegacyAttachmentPolicy')
# -- logging
self.log = logging.getLogger('trac.test')
level = self.log_level.upper()
level_as_int = trac.log.LOG_LEVEL_MAP.get(level)
self.log.setLevel(level_as_int)
handler_cls = logging.handlers.BufferingHandler
if not self.log.handlers:
log_handler = handler_cls(sys.maxsize) # Never flush implicitly.
formatter = logging.Formatter(self.log_format)
log_handler.setFormatter(formatter)
self.log.addHandler(log_handler)
elif len(self.log.handlers) == 1 and \
isinstance(self.log.handlers[0], handler_cls):
self.log.handlers[0].flush() # Reset buffer.
else:
raise TracError("Logger has unexpected handler(s).")
# -- database
self.dburi = get_dburi()
self.config.set('components', 'trac.db.*', 'enabled')
self.config.set('trac', 'database', self.dburi)
if not destroying:
self.reset_db(default_data)
self.config.set('trac', 'base_url', 'http://example.org/trac.cgi')
translation.activate(locale_en)
def __init__(self,
default_data=False,
enable=None,
disable=None,
path=None,
destroying=False):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
:param disable: A list of component classes or name globs to
deactivate in the stub environment.
:param path: The location of the environment in the file system.
No files or directories are created when specifying
this parameter.
:param destroying: If True, the database will not be reset. This is
useful for cases when the object is being
constructed in order to call `destroy_db`.
"""
if enable is not None and not isinstance(enable, (list, tuple)):
raise TypeError('Keyword argument "enable" must be a list')
if disable is not None and not isinstance(disable, (list, tuple)):
raise TypeError('Keyword argument "disable" must be a list')
ComponentManager.__init__(self)
Component.__init__(self)
self.systeminfo = []
import trac
self.path = path
if self.path is None:
self.path = os.path.dirname(trac.__file__)
if not os.path.isabs(self.path):
self.path = os.path.join(os.getcwd(), self.path)
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, 'basic-workflow.ini')
self.config.set('logging', 'log_level', 'DEBUG')
self.config.set('logging', 'log_type', 'stderr')
if enable is not None:
self.config.set('components', 'trac.*', 'disabled')
else:
self.config.set('components', 'tracopt.versioncontrol.*',
'enabled')
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'enabled')
for name_or_class in disable or ():
config_key = self._component_name(name_or_class)
self.config.set('components', config_key, 'disabled')
# -- logging
from trac.log import logger_handler_factory
self.log, self._log_handler = logger_handler_factory('test')
# -- database
self.config.set('components', 'trac.db.*', 'enabled')
self.dburi = get_dburi()
init_global = False
if self.global_databasemanager:
self.components[DatabaseManager] = self.global_databasemanager
else:
self.config.set('trac', 'database', self.dburi)
self.global_databasemanager = DatabaseManager(self)
self.config.set('trac', 'debug_sql', True)
self.config.set('logging', 'log_type', 'stderr')
self.config.set('logging', 'log_level', 'DEBUG')
init_global = not destroying
if default_data or init_global:
self.reset_db(default_data)
from trac.web.href import Href
self.href = Href('/trac.cgi')
self.abs_href = Href('http://example.org/trac.cgi')
self.known_users = []
translation.activate(locale_en)
msg = "Data Loading Error: "
if hasattr(detail, 'message'):
msg = msg + detail.message
if hasattr(detail, 'problem_mark'):
mark = detail.problem_mark
msg = msg + "\nError position: (%s:%s)" % (mark.line + 1,
mark.column + 1)
print msg
sys.exit(0)
if (verbose):
print "input"
print yaml.dump(data)
from trac.core import ComponentManager, ComponentMeta
compmgr = ComponentManager()
# Make sure we have no external components hanging around in the
# component registry
old_registry = ComponentMeta._registry
ComponentMeta._registry = {}
xx = GanttMacro(compmgr)
start, end = xx.process_dates(data)
if (verbose):
print "min start %s" % start
print "max end %s" % end
print "processed"
print yaml.dump(data)
def __init__(self, default_data=False, enable=None, disable=None, path=None, destroying=False):
"""Construct a new Environment stub object.
:param default_data: If True, populate the database with some
defaults.
:param enable: A list of component classes or name globs to
activate in the stub environment.
"""
ComponentManager.__init__(self)
Component.__init__(self)
self.systeminfo = []
import trac
self.path = path
if self.path is None:
self.path = os.path.dirname(trac.__file__)
if not os.path.isabs(self.path):
self.path = os.path.join(os.getcwd(), self.path)
# -- configuration
self.config = Configuration(None)
# We have to have a ticket-workflow config for ''lots'' of things to
# work. So insert the basic-workflow config here. There may be a
# better solution than this.
load_workflow_config_snippet(self.config, "basic-workflow.ini")
self.config.set("logging", "log_level", "DEBUG")
self.config.set("logging", "log_type", "stderr")
if enable is not None:
self.config.set("components", "trac.*", "disabled")
else:
self.config.set("components", "tracopt.versioncontrol.*", "enabled")
for name_or_class in enable or ():
config_key = self._component_name(name_or_class)
self.config.set("components", config_key, "enabled")
for name_or_class in disable or ():
config_key = self._component_name(name_or_class)
self.config.set("components", config_key, "disabled")
# -- logging
from trac.log import logger_handler_factory
self.log, self._log_handler = logger_handler_factory("test")
# -- database
self.config.set("components", "trac.db.*", "enabled")
self.dburi = get_dburi()
init_global = False
if self.global_databasemanager:
self.components[DatabaseManager] = global_databasemanager
else:
self.config.set("trac", "database", self.dburi)
self.global_databasemanager = DatabaseManager(self)
self.config.set("trac", "debug_sql", True)
self.config.set("logging", "log_type", "stderr")
self.config.set("logging", "log_level", "DEBUG")
init_global = not destroying
if default_data or init_global:
self.reset_db(default_data)
from trac.web.href import Href
self.href = Href("/trac.cgi")
self.abs_href = Href("http://example.org/trac.cgi")
self.known_users = []
translation.activate(locale_en)