def options(self, parser, env):
     Plugin.options(self, parser, env)
     parser.add_option("--re-pattern",
                       dest="pattern", action="store",
                       default=env.get("NOSE_REGEX_PATTERN", "test.*"),
                       help=("Run test methods that have a method name \
                       matching this regular expression"))    
Exemplo n.º 2
0
	def configure(self, options, conf):
		Plugin.configure(self, options, conf)
		self.pattern = options.pattern
		if options.verbosity >= 2:
			self.verbose = True
			if self.enabled:
				err.write("Pattern for matching test mothods is %s\n" % self.pattern)
Exemplo n.º 3
0
 def configure(self, options, config):
     '''Configure the plug in'''
     # Call super
     Plugin.configure(self, options, config)
     # ---------------------------------------------------------------------
     # NOSE
     # ---------------------------------------------------------------------
     # Store the configuration
     self.config = config
     # Check if processes enabled
     try: self.fork = 1 != max(int(options.multiprocess_workers), 1)
     # If multiprocess not available
     except: self.fork = False
     # ---------------------------------------------------------------------
     # CORE
     # ---------------------------------------------------------------------
     # Store test target folder
     self.core_target = os.path.abspath(options.core_target)
     # Store source folder
     if options.source: self.source = os.path.abspath(options.source)
     else: self.source = None
     # Check if has to search sources
     self.search_source = options.search_source
     # Check if has to search tests
     self.search_test = options.search_test
Exemplo n.º 4
0
 def options(self, parser, env):
     Plugin.options(self, parser, env)
     parser.add_option("--csv-file", \
                       dest="filename", \
                       action="store", \
                       default=env.get("NOSE_CSV_FILE", "log.csv"), \
                       help=("Name of the report"))
Exemplo n.º 5
0
    def __init__(self):
        Plugin.__init__(self)
        import uuid
        self.ds_name = "queueblame-%s" % str(uuid.uuid4())[0:6]

        from collections import defaultdict
        self.queues_by_test = defaultdict(lambda: defaultdict(dict))
Exemplo n.º 6
0
    def configure(self, options, conf):
        """Configure the plugin"""
        Plugin.configure(self, options, conf)

        for setting_str in options.env:
            env_variable, value = setting_str.split('=')
            os.environ[env_variable] = value
Exemplo n.º 7
0
 def options(self, parser, env):
     Plugin.options(self, parser, env)
     parser.add_option(
         '--artifact-dir', action='store',
         dest='artifact_dir', metavar="DIR",
         help=("Root artifact directory for testrun. [Default " \
               "is new sub-dir under /tmp]"))
Exemplo n.º 8
0
 def configure(self, options, config):
     # Configure
     Plugin.configure(self, options, config)
     # Set options
     if options.enable_plugin_specplugin:
         options.verbosity = max(options.verbosity, 2)
     self.spec_doctests = options.spec_doctests
     # Color setup
     for label, color in list({
         'error': 'red',
         'ok': 'green',
         'deprecated': 'yellow',
         'skipped': 'yellow',
         'failure': 'red',
         'identifier': 'cyan',
         'file': 'blue',
     }.items()):
         # No color: just print() really
         func = lambda text, bold=False: text
         if not options.no_spec_color:
             # Color: colorizes!
             func = partial(colorize, color)
         # Store in dict (slightly quicker/nicer than getattr)
         self.color[label] = func
         # Add attribute for easier hardcoded access
         setattr(self, label, func)
Exemplo n.º 9
0
 def options(self, parser, env):
     Plugin.options(self, parser, env)
     parser.add_option('--id-file', action='store', dest='testIdFile',
                       default='.noseids',
                       help="Store test ids found in test runs in this "
                       "file. Default is the file .noseids in the "
                       "working directory.")
Exemplo n.º 10
0
 def options(self, parser, env=os.environ):
     # print "Options for nose plugin:", self.name # dbg
     Plugin.options(self, parser, env)
     parser.add_option(
         "--ipdoctest-tests",
         action="store_true",
         dest="ipdoctest_tests",
         default=env.get("NOSE_IPDOCTEST_TESTS", True),
         help="Also look for doctests in test modules. "
         "Note that classes, methods and functions should "
         "have either doctests or non-doctest tests, "
         "not both. [NOSE_IPDOCTEST_TESTS]",
     )
     parser.add_option(
         "--ipdoctest-extension",
         action="append",
         dest="ipdoctest_extension",
         help="Also look for doctests in files with " "this extension [NOSE_IPDOCTEST_EXTENSION]",
     )
     # Set the default as a list, if given in env; otherwise
     # an additional value set on the command line will cause
     # an error.
     env_setting = env.get("NOSE_IPDOCTEST_EXTENSION")
     if env_setting is not None:
         parser.set_defaults(ipdoctest_extension=tolist(env_setting))
Exemplo n.º 11
0
 def options(self, parser, env=os.environ):
     '''Add launch options for NoseXUnitLite'''
     # Call super
     Plugin.options(self, parser, env)
     # ---------------------------------------------------------------------
     # CORE
     # ---------------------------------------------------------------------
     # Add test target folder
     parser.add_option('--core-target',
                       action='store',
                       default = nconst.TARGET_CORE,
                       dest='core_target',
                       help='Output folder for test reports (default is %s).' % nconst.TARGET_CORE)
     # Add source folder
     parser.add_option('--source-folder',
                       action='store',
                       default=None,
                       dest='source',
                       help='Set source folder (optional). Add folder in sys.path.')
     # Search sources in source tree
     parser.add_option('--search-source',
                       action='store_true',
                       default=False,
                       dest='search_source',
                       help="Walk in the source folder to add deeper folders in sys.path if they don't contain __init__.py file. Works only if --source-folder is defined.")
     # Search tests in 
     parser.add_option('--search-test',
                       action='store_true',
                       default=False,
                       dest='search_test',
                       help='Search tests in folders with no __init__.py file (default: do nothing).')
Exemplo n.º 12
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env)
     parser.add_option(
         "-u", "--select-unittests", action="store_true",
         default=False, dest="select_unittests",
         help="Run all unittests"
     )
     parser.add_option(
         "--select-databasetests", action="store_true",
         default=False, dest="select_databasetests",
         help="Run all database tests"
     )
     parser.add_option(
         "--select-destructivedatabasetests", action="store_true",
         default=False, dest="select_destructivedatabasetests",
         help="Run all destructive database tests"
     )
     parser.add_option(
         "--select-httptests", action="store_true",
         default=False, dest="select_httptests",
         help="Run all HTTP tests"
     )
     parser.add_option(
         "--select-seleniumtests", action="store_true",
         default=False, dest="select_seleniumtests",
         help="Run all Selenium tests"
     )
Exemplo n.º 13
0
 def options(self, parser, env):
     Plugin.options(self, parser, env)
     parser.add_option('--mutations-path', action='store',
                       default='.',
                       dest='mutations_path',
                       help='Restrict mutations to source files in this path'
                            ' (default: current working directory)')
     parser.add_option('--mutations-exclude', action='store',
                       metavar='REGEX', default=None,
                       dest='mutations_exclude',
                       help='Exclude mutations for source files containing '
                             'this pattern (default: None)')
     parser.add_option('--mutations-exclude-lines', action='store',
                       metavar='REGEX',
                       default=self.exclude_lines_pattern,
                       dest='mutations_exclude_lines',
                       help='Exclude mutations for lines containing this '
                            'pattern (default: \'%s\'' %
                             self.exclude_lines_pattern)
     parser.add_option('--mutations-mutators-modules', action='store',
                       default='elcap.mutator',
                       dest='mutators_modules',
                       help='Comma separated list of modules where the '
                            'Mutators are defined.')
     parser.add_option('--mutations-mutators', action='store',
                       default='',
                       dest='mutators',
                       help='Comma separated list of mutators to use. '
                            'Example: BooleanMutator,NumberMutator. An '
                            'empty list implies all Mutators in the defined '
                            'modules will be used.')
Exemplo n.º 14
0
 def __init__(self):
     Plugin.__init__(self)
     self.stream_capturer = StreamCapturer()
     self.destination = os.environ.get('IPTEST_SUBPROC_STREAMS', 'capture')
     # This is ugly, but distant parts of the test machinery need to be able
     # to redirect streams, so we make the object globally accessible.
     nose.iptest_stdstreams_fileno = self.get_write_fileno
Exemplo n.º 15
0
 def __init__(self):
     Plugin.__init__(self)
     self.ccs = []
     self.container_started = False
     self.blames = {"scidata": [], "state": [], "directory": [], "events": [], "resources": [], "objects": []}
     self.last_blame = {}
     self.sysname = None
Exemplo n.º 16
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env)
     
     parser.add_option(
         "", "--persist-test-database", action="store_true",
         default=env.get(self.env_opt), dest="persist_test_database",
         help="Do not flush database unless neccessary [%s]" % self.env_opt)
Exemplo n.º 17
0
    def options(self, parser, env=None):
        Plugin.options(self, parser, env)
        parser.add_option('--rapido-blue', action='store_true',
                          dest='rapido_blue',
                          default=False,
                          help=
                          "Use the color blue instead of \
green for successfull tests")
Exemplo n.º 18
0
 def options(self, parser, env):
     """Register commmandline options.
     """
     Plugin.options(self, parser, env)
     parser.add_option(
         "--html-output",
         default=env.get('NOSE_OUTPUT_FILE'),
         dest="outputFile", help="Dest. of output file")
Exemplo n.º 19
0
    def configure(self, options, config):
        Plugin.configure(self, options, config)

        self.config = config
        if not self.enabled:
            return

        self._sink = Sink()
Exemplo n.º 20
0
 def configure(self, options, conf):
     log.debug("Configuring PSCTest2NosePlugin")
     Plugin.configure(self, options, conf)
     self.conf = conf
     if hasattr(self.conf.options, 'collect_only'):
         self.collect_only = getattr(self.conf.options, 'collect_only')
     log.debug("self.collect_only is %s" % self.collect_only)
     self.buildConfig = getattr(self.conf.options, 'build_config') if hasattr(self.conf.options, 'build_config') else None
Exemplo n.º 21
0
 def configure(self, options, conf):
     """
     Called after the command line has been parsed, with the parsed options and the config container. 
     Here, implement any config storage or changes to state or operation that are set by command line options.
     DO NOT return a value from this method unless you want to stop all other plugins from being configured.
     """
     Plugin.configure(self, options, conf)
     connection.use_debug_cursor = True
Exemplo n.º 22
0
  def configure(self, options, conf):
    """Configure the plugin based on provided options"""
    Plugin.configure(self, options, conf)

    if options.show_each_error:
      self.show_each_error = True
    if options.show_each_failure:
      self.show_each_failure = True
Exemplo n.º 23
0
 def options(self, parser, env):
     """Register commandline options.
     """
     Plugin.options(self, parser, env)
     parser.add_option('--randomize', action='store_true', dest='randomize',
                       help="Randomize the order of the tests within a unittest.TestCase class")
     parser.add_option('--seed', action='store', dest='seed', default=None, type = long,
                       help="Initialize the seed for deterministic behavior in reproducing failed tests")
Exemplo n.º 24
0
 def __init__(self):
     Plugin.__init__(self)
     self.ccs = []
     self.container_started = False
     self.blames = {'scidata':[], 'state':[], 'directory':[], 'events':[],
             'resources':[], 'objects':[]}
     self.last_blame = {}
     self.sysname = None
Exemplo n.º 25
0
 def configure(self, options, conf):
     Plugin.configure(self, options, conf)
     conf.exclude = map(re.compile, tolist(r'^(manage\.py|.*settings\.py|apps)$'))
     
     if options.django_settings and self.env is not None:
         self.env['DJANGO_SETTINGS_MODULE'] = options.django_settings
     
     self.verbosity = conf.verbosity
Exemplo n.º 26
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env)
     parser.add_option(
         "--with-dependency",
         action="store_true",
         dest="dependency",
         help="Order tests according to @requires decorators",
     )
Exemplo n.º 27
0
 def add_options(self, parser, env=os.environ):
     # keep copy so we can make our setting in the env we were passed
     self.env = env
     Plugin.add_options(self, parser, env)
     parser.add_option('--django-settings', action='store',
                       dest='django_settings', default=None,
                       help="Set module as the DJANGO_SETTINGS_MODULE"
                       " environment variable.")
Exemplo n.º 28
0
 def configure(self, options, config):
     Plugin.configure(self, options, config)
     #==
     if not self.enabled: 
         return
     #==
     self.report_path   = options.report_file
     if options.template_file:
         self.html_path, self.template_path = os.path.split(options.template_file)
Exemplo n.º 29
0
 def options(self, parser, env):
     Plugin.options(self, parser, env)
     parser.add_option(
         '--json-file', action='store',
         dest='json_file', metavar="FILE",
         default=env.get('NOSE_JSON_FILE', 'nosetests.json'),
         help=("Path to json file to store the report in. "
               "Default is nosetests.json in the working directory "
               "[NOSE_JSON_FILE]"))
Exemplo n.º 30
0
 def __init__(self):
     Plugin.__init__(self)
     self.execution_guid = str(uuid.uuid4())
     self.testcase_guid = None
     self.execution_start_time = 0
     self.case_start_time = 0
     self.application = None
     self.testcase_manager = None
     self.error_handled = False
Exemplo n.º 31
0
 def options(self, parser, env):
     Plugin.options(self, parser, env)
     parser.add_option(
         '--json-file',
         action='store',
         dest='json_file',
         metavar="FILE",
         default=env.get('NOSE_JSON_FILE', 'nosetests.json'),
         help=("Path to json file to store the report in. "
               "Default is nosetests.json in the working directory "
               "[NOSE_JSON_FILE]"))
Exemplo n.º 32
0
    def configure(self, options, config):
        #print "Configuring nose plugin:", self.name # dbg
        Plugin.configure(self, options, config)
        self.doctest_tests = options.ipdoctest_tests
        self.extension = tolist(options.ipdoctest_extension)

        self.parser = IPDocTestParser()
        self.finder = DocTestFinder(parser=self.parser)
        self.checker = IPDoctestOutputChecker()
        self.globs = None
        self.extraglobs = None
Exemplo n.º 33
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env=env)
     parser.add_option('--build_username', action='store', type="string", dest="username", default="iikdvt", help="Username device is provisioned to.")
     parser.add_option('--build_password', action='store', type="string", dest="password", default="iik1sfun", help="Password of username device is provisioned to.")
     parser.add_option('--build_hostname', action='store', type="string", dest="hostname", default="test.idigi.com", help="Server device is connected to.")
     parser.add_option('--build_device_type', action='store', type="string", dest="device_type", default="Linux Application", help="Device Type to Use for Config Tool.")
     parser.add_option('--build_firmware_version', action='store', type='string', dest="firmware_version", default="1.0.0.0", help="Firmware Version to Use for Config Tool.")
     parser.add_option('--build_config_tool_jar', action='store', type="string", dest="config_tool_jar", default="ConfigGenerator.jar", help="Config Tool Jar used to generate RCI Config Code")
     parser.add_option('--build_keystore', action='store', type="string", dest="keystore", default=None, help="Keystore for Config Tool to use for SSL trust.")
     parser.add_option('--build_cflags', action='store', type="string", dest="cflags", help="CFLAGS to add to compile", default="")
     parser.add_option('--build_src', action='store', type="string", dest="src", help="Source Directory to Build From.", default=".")
Exemplo n.º 34
0
 def options(self, parser, env):
     """Sets additional command line options."""
     Plugin.options(self, parser, env)
     parser.add_option('--html-file',
                       action='store',
                       dest='html_file',
                       metavar="FILE",
                       default=env.get('NOSE_HTML_FILE', 'nosetests.html'),
                       help="Path to html file to store the report in. "
                       "Default is nosetests.html in the working directory "
                       "[NOSE_HTML_FILE]")
 def options(self, parser, env):
     """Sets additional command line options."""
     Plugin.options(self, parser, env)
     parser.add_option(
         '--customxunit-file',
         action='store',
         dest='xunit_file',
         metavar="FILE",
         default=env.get('NOSE_XUNIT_FILE', 'nosetests.xml'),
         help=("Path to xml file to store the xunit report in. "
               "Default is nosetests.xml in the working directory "
               "[NOSE_XUNIT_FILE]"))
Exemplo n.º 36
0
    def configure(self, options, config):
        Plugin.configure(self, options, config)

        if options.enable_plugin_spec:
            options.verbosity = max(options.verbosity, 2)

        if options.spec_color:
            self._colorize = lambda color: lambda text: in_color(color, text)
        else:
            self._colorize = lambda color: lambda text: text

        self.spec_doctests = options.spec_doctests
Exemplo n.º 37
0
 def options(self, parser, env=os.environ):
     """Sets additional command line options."""
     Plugin.options(self, parser, env)
     parser.add_option(
         '--lode-report',
         action='store',
         dest='lode_report',
         metavar="FILE",
         default=env.get('LODE_REPORT_FILE', 'lode-report.json'),
         help=("Path to xml file to store the lode report in. "
               "Default is lode-report.xml in the working directory "
               "[LODE_REPORT_FILE]"))
Exemplo n.º 38
0
 def configure(self, options, conf):
     Plugin.configure(self, options, conf)
     self.stream = None
     self.enabled = True
     self.has_failed_tests = False
     self.good_tests = []
     self.function_calls = {}
     self.calls = {}
     self.app_paths = filter(bool,
                             map(normalize_path, options.mutant_path or []))
     self.exclude_paths = filter(
         bool, map(normalize_path, options.mutant_exclude or []))
Exemplo n.º 39
0
 def options(self, parser, env):
     """Register commandline options.
     """
     Plugin.options(self, parser, env)
     parser.add_option('--seed',
                       action='store',
                       dest='seed',
                       default=None,
                       type=int,
                       help="Initialize the seed "
                       "for deterministic behavior in "
                       "reproducing failed tests")
Exemplo n.º 40
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env)
     parser.add_option('--spec-color', action='store_true',
                       dest='spec_color',
                       default=env.get('NOSE_SPEC_COLOR'),
                       help="Show coloured (red/green) output for specifications "
                       "[NOSE_SPEC_COLOR]")
     parser.add_option('--spec-doctests', action='store_true',
                       dest='spec_doctests',
                       default=env.get('NOSE_SPEC_DOCTESTS'),
                       help="Include doctests in specifications "
                       "[NOSE_SPEC_DOCTESTS]")
Exemplo n.º 41
0
    def configure(self, options, conf):
        """Set the configuration"""

        if options.lettuce_path:
            self._base_path = options.lettuce_path
        else:
            self._base_path = os.path.join(conf.workingDir, "features")

        conf.lettuce_verbosity = options.lettuce_verbosity
        conf.lettuce_scenarios = options.lettuce_scenarios

        Plugin.configure(self, options, conf)
Exemplo n.º 42
0
    def __init__(self):
        try:
            env.boardId = sys.argv[1]
            if env.boardId == "-h":
                print "Syntax: mp7jeeves BOARDID --optionals"
                return
            sys.argv.pop(1)
        except:
            print "Is that the right command structure? (mp7jeeves BOARDID --optionals)"
            raise

        Plugin.__init__(self)
Exemplo n.º 43
0
 def options(self, parser, env):
     """
     Add options to command line.
     """
     Plugin.options(self, parser, env)
     parser.add_option('--xcoverage-file', action='store',
                       default=env.get('NOSE_XCOVER_FILE', 'coverage.xml'),
                       dest='xcoverage_file',
                       metavar="FILE",
                       help='Path to xml file to store the coverage report in. '
                       'Default is coverage.xml in the working directory. '
                       '[NOSE_XCOVERAGE_FILE]')
Exemplo n.º 44
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env)
     opt = parser.add_option
     opt("--log-info", action="callback", type="string", callback=_log,
         help="turn on info logging for <LOG> (multiple OK)")
     opt("--log-debug", action="callback", type="string", callback=_log,
         help="turn on debug logging for <LOG> (multiple OK)")
     opt("--require", action="append", dest="require", default=[],
         help="require a particular driver or module version (multiple OK)")
     opt("--db", action="store", dest="db", default="sqlite",
         help="Use prefab database uri")
     opt('--dbs', action='callback', callback=_list_dbs,
         help="List available prefab dbs")
     opt("--dburi", action="store", dest="dburi",
         help="Database uri (overrides --db)")
     opt("--dropfirst", action="store_true", dest="dropfirst",
         help="Drop all tables in the target database first (use with caution on Oracle, "
         "MS-SQL)")
     opt("--mockpool", action="store_true", dest="mockpool",
         help="Use mock pool (asserts only one connection used)")
     opt("--zero-timeout", action="callback", callback=_zero_timeout,
         help="Set pool_timeout to zero, applies to QueuePool only")
     opt("--low-connections", action="store_true", dest="low_connections",
         help="Use a low number of distinct connections - i.e. for Oracle TNS"
     )
     opt("--enginestrategy", action="callback", type="string",
         callback=_engine_strategy,
         help="Engine strategy (plain or threadlocal, defaults to plain)")
     opt("--reversetop", action="store_true", dest="reversetop", default=False,
         help="Use a random-ordering set implementation in the ORM (helps "
               "reveal dependency issues)")
     opt("--with-cdecimal", action="store_true", dest="cdecimal", default=False,
         help="Monkeypatch the cdecimal library into Python 'decimal' for all tests")
     opt("--unhashable", action="store_true", dest="unhashable", default=False,
         help="Disallow SQLAlchemy from performing a hash() on mapped test objects.")
     opt("--noncomparable", action="store_true", dest="noncomparable", default=False,
         help="Disallow SQLAlchemy from performing == on mapped test objects.")
     opt("--truthless", action="store_true", dest="truthless", default=False,
         help="Disallow SQLAlchemy from truth-evaluating mapped test objects.")
     opt("--serverside", action="callback", callback=_server_side_cursors,
         help="Turn on server side cursors for PG")
     opt("--mysql-engine", action="store", dest="mysql_engine", default=None,
         help="Use the specified MySQL storage engine for all tables, default is "
              "a db-default/InnoDB combo.")
     opt("--table-option", action="append", dest="tableopts", default=[],
         help="Add a dialect-specific table option, key=value")
     opt("--write-profiles", action="store_true", dest="write_profiles", default=False,
             help="Write/update profiling data.")
     global file_config
     file_config = ConfigParser.ConfigParser()
     file_config.readfp(StringIO.StringIO(base_config))
     file_config.read(['test.cfg', os.path.expanduser('~/.satest.cfg')])
     config.file_config = file_config
Exemplo n.º 45
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env=env)
     parser.add_option('--ic-username',
                       action='store',
                       type="string",
                       dest="username",
                       default="iikdvt",
                       help="Username device is provisioned to.")
     parser.add_option(
         '--ic-password',
         action='store',
         type="string",
         dest="password",
         default="iik1sfun",
         help="Password of username device is provisioned to.")
     parser.add_option('--ic-hostname',
                       action='store',
                       type="string",
                       dest="hostname",
                       default="test.idigi.com",
                       help="Server device is connected to.")
     parser.add_option('--ic-deviceid',
                       action='store',
                       type="string",
                       dest="device_id",
                       default="00000000-00000000-00409DFF-FF432317",
                       help="Device ID of device running iDigi Connector.")
     parser.add_option('--ic-vendorid',
                       action='store',
                       type="string",
                       dest="vendor_id",
                       default="16777242",
                       help="Vendor ID of device running iDigi Connector.")
     parser.add_option(
         '--ic-devicetype',
         action='store',
         type="string",
         dest="device_type",
         default="ECC DVT",
         help="Device Type of device runnning iDigi Connector.")
     parser.add_option('--ic-ipaddr',
                       action='store',
                       type="string",
                       dest="ipaddr",
                       default="0.0.0.0",
                       help="IP address of device under test.")
     parser.add_option('--ic-configuration',
                       action='store',
                       type="string",
                       dest="configuration",
                       default="default",
                       help="Cloud Connector configuration mode to run")
Exemplo n.º 46
0
 def configure(self, options, conf):
     Plugin.configure(self, options, conf)
     self.idfile = os.path.expanduser(options.testIdFile)
     if not os.path.isabs(self.idfile):
         self.idfile = os.path.join(conf.workingDir, self.idfile)
     self.id = 1
     # Ids and tests are mirror images: ids are {id: test address} and
     # tests are {test address: id}
     self.ids = {}
     self.tests = {}
     # used to track ids seen when tests is filled from
     # loaded ids file
     self._seen = {}
Exemplo n.º 47
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env)
     parser.add_option(
         "--html-report-file",
         action="store",
         #default="nose_report.html",
         dest="report_file",
         help="File to output HTML report to")
     parser.add_option("--html-template-file",
                       action="store",
                       default=html_path / default_template,
                       dest="template_file",
                       help="jinja template used to output HTML ")
Exemplo n.º 48
0
 def configure(self, options, config):
     Plugin.configure(self, options, config)
     if self.enabled:
         config.options.noSkip = True
         self.result = dict(summary={}, testcases=[])
         self.result['summary'] = {
             'errors': 0,
             'failures': 0,
             'passed': 0,
             'skip': 0
         }
         self.testsuite_name = options.html_testsuite_name
         self.output_file = options.html_file
Exemplo n.º 49
0
 def configure(self, options, config):
     """Configures the xunit plugin."""
     Plugin.configure(self, options, config)
     self.config = config
     if self.enabled:
         self.jinja = Environment(
             loader=FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')),
             trim_blocks=True,
             lstrip_blocks=True
         )
         self.stats = {'errors': 0, 'failures': 0, 'passes': 0, 'skipped': 0}
         self.report_data = defaultdict(Group)
         self.report_file = codecs.open(options.html_file, 'w', self.encoding, 'replace')
Exemplo n.º 50
0
 def options(self, parser, env):
     """Register commandline options.
     """
     Plugin.options(self, parser, env)
     parser.add_option('--id-file', action='store', dest='testIdFile',
                       default='.noseids', metavar="FILE",
                       help="Store test ids found in test runs in this "
                       "file. Default is the file .noseids in the "
                       "working directory.")
     parser.add_option('--failed', action='store_true',
                       dest='failed', default=False,
                       help="Run the tests that failed in the last "
                       "test run.")
Exemplo n.º 51
0
    def configure(self, options, config):
        Plugin.configure(self, options, config)
        # Pull standard doctest plugin out of config; we will do doctesting
        config.plugins.plugins = [p for p in config.plugins.plugins
                                  if p.name != 'doctest']
        self.doctest_tests = options.doctest_tests
        self.extension = tolist(options.doctestExtension)

        self.parser = doctest.DocTestParser()
        self.finder = DocTestFinder()
        self.checker = IPDoctestOutputChecker()
        self.globs = None
        self.extraglobs = None
Exemplo n.º 52
0
    def options(self, parser, env=os.environ):
        logger.debug("options(self, parser, env = os.environ):...")

        parser.add_option(
            "--psprofile-file",
            action="store",
            default=env.get("NOSE_PSP_FILE", "psprofile.json"),
            dest="psp_file",
            metavar="FILE",
            help=
            "By Default a psprofile.json is generated in the current working directory"
        )

        Plugin.options(self, parser, env)
Exemplo n.º 53
0
    def options(self, parser, env=os.environ):
        Plugin.options(self, parser, env)
        opt = parser.add_option

        def make_option(name, **kw):
            callback_ = kw.pop("callback", None) or kw.pop("zeroarg_callback", None)
            if callback_:
                def wrap_(option, opt_str, value, parser):
                    callback_(opt_str, value, parser)
                kw["callback"] = wrap_
            opt(name, **kw)

        plugin_base.setup_options(make_option)
        plugin_base.read_config()
Exemplo n.º 54
0
 def __init__(self):
     Plugin.__init__(self)
     self.ccs = []
     self.container_started = False
     self.blames = {
         'scidata': [],
         'state': [],
         'directory': [],
         'events': [],
         'resources': [],
         'objects': []
     }
     self.last_blame = {}
     self.sysname = None
Exemplo n.º 55
0
    def configure(self, options, conf):


        Plugin.configure(self, options, conf)
        if self.enabled:

            # browser-help is a usage call
            if getattr(options, 'browser_help'):
                self._browser_help()

            # get options from command line or config file
            if options.config_file:
                self.ingest_config_file(options.config_file)
            else:
                self.ingest_options(options)

            ### Validation ###
            # local
            if BROWSER_LOCATION == 'local':
                self._check_validity(BROWSER, self._valid_browsers_for_local)

            # sauce
            elif BROWSER_LOCATION == 'sauce':
                valid_browsers_for_sauce, valid_oses_for_sauce, combos = self._get_sauce_options()

                if not SAUCE_USERNAME or not SAUCE_APIKEY:
                    raise TypeError("'sauce' value for --browser-location "
                                    "requires --sauce-username and --sauce-apikey.")
                self._check_validity(BROWSER, valid_browsers_for_sauce)
                if not OS:
                    raise TypeError(
                        "'sauce' value for --browser-location requires the --os option.")
                self._check_validity(OS, valid_oses_for_sauce, flag="--os")

            # remote
            elif BROWSER_LOCATION == 'remote':
                self._check_validity(BROWSER, self._valid_browsers_for_remote)
                if not REMOTE_ADDRESS:
                    raise TypeError(
                        "'remote' value for --browser-location requires --remote-address.")

            # grid
            elif BROWSER_LOCATION == 'grid':
                self._check_validity(BROWSER, self._valid_browsers_for_remote)
                if not REMOTE_ADDRESS:
                    raise TypeError(
                        "'grid' value for --browser-location requires --grid-address.")
                if not OS:
                    raise TypeError(
                        "'grid' value for --browser-location requires the --os option.")
Exemplo n.º 56
0
    def options(self, parser, env=os.environ):

        Plugin.options(self, parser, env)
        parser.add_option(
            '--config-file',
            action='store',
            dest='config_file',
            help=
            'Load options from a config file instead of enter via the command line.'
        )
        valid_location_options = [
            'develop', 'staging', 'dogfood', 'production'
        ]
        parser.add_option('--env',
                          action='store',
                          choices=valid_location_options,
                          dest='environment',
                          help='Run the browser in this location (options ' +
                          self._stringify_options(valid_location_options) +
                          ').')
        parser.add_option(
            '--browser',
            action='store',
            dest='browser',
            help='Select the type of browser you want Selenium to use.')
        parser.add_option('--baseurl',
                          action='store',
                          dest='base_url',
                          help='base url of the application in test.')
        parser.add_option('--timeout',
                          action='store',
                          dest='timeout',
                          type='str',
                          help='Change the timeout on the fly.')
        parser.add_option('--fbuser',
                          action='store',
                          dest='fb_user',
                          help='Facebook username')
        parser.add_option('--fbpass',
                          action='store',
                          dest='fb_pass',
                          help='Facebook password')
        parser.add_option(
            '--logging',
            action='store',
            dest='logging',
            help=
            'Set logging level (debug, info, warn, error, critical). Disabled by default.'
        )
Exemplo n.º 57
0
    def configure(self, options, config):
        # print "Configuring nose plugin:", self.name # dbg
        Plugin.configure(self, options, config)
        # Pull standard doctest plugin out of config; we will do doctesting
        config.plugins.plugins = [
            p for p in config.plugins.plugins if p.name != "doctest"
        ]
        self.doctest_tests = options.ipdoctest_tests
        self.extension = tolist(options.ipdoctest_extension)

        self.parser = IPDocTestParser()
        self.finder = DocTestFinder(parser=self.parser)
        self.checker = IPDoctestOutputChecker()
        self.globs = None
        self.extraglobs = None
Exemplo n.º 58
0
    def options(self, parser, env=None):
        Plugin.options(self, parser, env)
        omaker = make_option_maker(parser,
                                   dest_prefix="dbdump",
                                   env_prefix="NOSE_DBDUMP",
                                   cmdline_prefix="dbdump")

        omaker('databases',
               action="append",
               help="Dump the selected databases")
        omaker('output', help="Path to store the database dump")
        omaker('dsn', help="engine://[user[:password]@]hostname[:port]")
        omaker('keep',
               action='store_true',
               help="Don't delete the database dump")
Exemplo n.º 59
0
 def options(self, parser, env=os.environ):
     Plugin.options(self, parser, env)
     parser.add_option('--no-spec-color', action='store_true',
                       dest='no_spec_color',
                       default=env.get('NOSE_NO_SPEC_COLOR'),
                       help="Don't show colors with --with-spec"
                       "[NOSE_NO_SPEC_COLOR]")
     parser.add_option('--spec-doctests', action='store_true',
                       dest='spec_doctests',
                       default=env.get('NOSE_SPEC_DOCTESTS'),
                       help="Include doctests in specifications "
                       "[NOSE_SPEC_DOCTESTS]")
     parser.add_option('--no-detailed-errors', action='store_false',
                       dest='detailedErrors',
                       help="Force detailed errors off")
Exemplo n.º 60
0
    def configure(self, options, conf):
        Plugin.configure(self, options, conf)

        if not self.enabled:
            return
            
        self.cflags = options.cflags
        self.src = options.src
        self.username = options.username
        self.password = options.password
        self.hostname = options.hostname
        self.device_type = options.device_type
        self.firmware_version = options.firmware_version
        self.config_tool_jar = options.config_tool_jar
        self.keystore = options.keystore