def setup_layer(options, layer, setup_layers): assert layer is not object output = options.output if layer not in setup_layers: for base in layer.__bases__: if base is not object: setup_layer(options, base, setup_layers) output.start_set_up(name_from_layer(layer)) t = time.time() if hasattr(layer, 'setUp'): try: layer.setUp() except Exception: if options.post_mortem: if options.resume_layer: options.output.error_with_banner( cant_pm_in_subprocess_message % options.resume_layer) raise else: zope.testrunner.debug.post_mortem( sys.exc_info()) else: raise output.stop_set_up(time.time() - t) setup_layers[layer] = 1
def layer_sort_key(layer): """Compute sort key for layers. Based on the reverse MRO ordering in order to put layers with shared base layers next to each other. """ seen = set([]) key = [] # Note: we cannot reuse gather_layers() here because it uses a # different traversal order. def _gather(layer): seen.add(layer) # We make the simplifying assumption that the order of initialization # of base layers does not matter. Given that, traversing the bases # in reverse order here keeps the ordering of layers in # testrunner-layers.rst the same as it was in older versions of # zope.testrunner, so let's use that. for base in layer.__bases__[::-1]: if base is not object and base not in seen: _gather(base) key.append(layer) _gather(layer) return tuple(name_from_layer(l) for l in key if l != UnitTests)
def ordered_layers(self): if (self.options.processes > 1 and not self.options.resume_layer): # if we want multiple processes, we need a fake layer as first # to start spreading out layers/tests to subprocesses # but only if this is not in the subprocess yield (name_from_layer(EmptyLayer), EmptyLayer, EmptySuite()) layer_names = dict([(layer_from_name(layer_name), layer_name) for layer_name in self.tests_by_layer_name]) for layer in order_by_bases(layer_names): layer_name = layer_names[layer] yield layer_name, layer, self.tests_by_layer_name[layer_name]
def order_by_bases(layers): """Order the layers from least to most specific (bottom to top) """ named_layers = [(name_from_layer(layer), layer) for layer in layers] named_layers.sort() named_layers.reverse() gathered = [] for name, layer in named_layers: gather_layers(layer, gathered) gathered.reverse() seen = {} result = [] for layer in gathered: if layer not in seen: seen[layer] = 1 if layer in layers: result.append(layer) return result
def tear_down_unneeded(options, needed, setup_layers, optional=False): # Tear down any layers not needed for these tests. The unneeded layers # might interfere. unneeded = [l for l in setup_layers if l not in needed] unneeded = order_by_bases(unneeded) unneeded.reverse() output = options.output for l in unneeded: output.start_tear_down(name_from_layer(l)) t = time.time() try: try: if hasattr(l, 'tearDown'): l.tearDown() except NotImplementedError: output.tear_down_not_supported() if not optional: raise CanNotTearDown(l) else: output.stop_tear_down(time.time() - t) finally: del setup_layers[l]
def __str__(self): return "Layer: %s" % (name_from_layer(self.layer))
def __str__(self): return "Layer: %s.tearDown" % (name_from_layer(self.layer))