Python tcmessages.TeamcityServiceMessages类代码示例

 def __init__(self, stream=sys.stdout, *args, **kwargs):
   TestResult.__init__(self)
   for arg, value in kwargs.items():
     setattr(self, arg, value)
   self.output = stream
   self.messages = TeamcityServiceMessages(self.output, prepend_linebreak=True)
   self.messages.testMatrixEntered()
   self.current_suite = None

 def __init__(self, stream=sys.stdout, *args, **kwargs):
     TestResult.__init__(self)
     for arg, value in kwargs.items():
         setattr(self, arg, value)
     self.output = stream
     self.messages = TeamcityServiceMessages(self.output, prepend_linebreak=True)
     if not "_jb_do_not_call_enter_matrix" in os.environ:
         self.messages.testMatrixEntered()
     self.current_failed = False
     self.current_suite = None
     self.subtest_suite = None

    def __init__(self, stream=sys.stderr, descriptions=None, verbosity=1, config=None, errorClasses=None):
        super(TeamcityPlugin, self).__init__()

        if errorClasses is None:
            errorClasses = {}

        self.errorClasses = errorClasses
        if config is None:
            config = Config()
        self.config = config
        self.output = stream
        self.messages = TeamcityServiceMessages(self.output, prepend_linebreak=True)
        self.messages.testMatrixEntered()
        self.current_suite = None
        TextTestResult.__init__(self, stream, descriptions, verbosity, config, errorClasses)
        TeamcityTestResult.__init__(self, stream)

class TeamcityTestResult(TestResult):
    """
  Set ``_jb_do_not_call_enter_matrix`` to prevent it from runnig "enter matrix"
  """

    def __init__(self, stream=sys.stdout, *args, **kwargs):
        TestResult.__init__(self)
        for arg, value in kwargs.items():
            setattr(self, arg, value)
        self.output = stream
        self.messages = TeamcityServiceMessages(self.output, prepend_linebreak=True)
        if not "_jb_do_not_call_enter_matrix" in os.environ:
            self.messages.testMatrixEntered()
        self.current_failed = False
        self.current_suite = None
        self.subtest_suite = None

    def find_first(self, val):
        quot = val[0]
        count = 1
        quote_ind = val[count:].find(quot)
        while quote_ind != -1 and val[count + quote_ind - 1] == "\\":
            count = count + quote_ind + 1
            quote_ind = val[count:].find(quot)

        return val[0 : quote_ind + count + 1]

    def find_second(self, val):
        val_index = val.find("!=")
        if val_index != -1:
            count = 1
            val = val[val_index + 2 :].strip()
            quot = val[0]
            quote_ind = val[count:].find(quot)
            while quote_ind != -1 and val[count + quote_ind - 1] == "\\":
                count = count + quote_ind + 1
                quote_ind = val[count:].find(quot)
            return val[0 : quote_ind + count + 1]

        else:
            quot = val[-1]
            quote_ind = val[: len(val) - 1].rfind(quot)
            while quote_ind != -1 and val[quote_ind - 1] == "\\":
                quote_ind = val[: quote_ind - 1].rfind(quot)
            return val[quote_ind:]

    def formatErr(self, err):
        exctype, value, tb = err
        return "".join(traceback.format_exception(exctype, value, tb))

    def getTestName(self, test, is_subtest=False):
        if is_subtest:
            test_name = self.getTestName(test.test_case)
            return "{} {}".format(test_name, test._subDescription())
        if hasattr(test, "_testMethodName"):
            if test._testMethodName == "runTest":
                return str(test)
            return test._testMethodName
        else:
            test_name = str(test)
            whitespace_index = test_name.index(" ")
            if whitespace_index != -1:
                test_name = test_name[:whitespace_index]
            return test_name

    def getTestId(self, test):
        return test.id

    def addSuccess(self, test):
        TestResult.addSuccess(self, test)

    def addError(self, test, err):
        location = self.init_suite(test)
        self.current_failed = True
        TestResult.addError(self, test, err)

        err = self._exc_info_to_string(err, test)

        self.messages.testStarted(self.getTestName(test), location=location)
        self.messages.testError(self.getTestName(test), message="Error", details=err, duration=self.__getDuration(test))

    def find_error_value(self, err):
        error_value = traceback.extract_tb(err)
        error_value = error_value[-1][-1]
        return error_value.split("assert")[-1].strip()

    def addFailure(self, test, err):
        location = self.init_suite(test)
        self.current_failed = True
        TestResult.addFailure(self, test, err)

        error_value = smart_str(err[1])
        if not len(error_value):
            # means it's test function and we have to extract value from traceback
            error_value = self.find_error_value(err[2])

        self_find_first = self.find_first(error_value)
        self_find_second = self.find_second(error_value)
        quotes = ["'", '"']
        if (
#.........这里部分代码省略.........

from tcmessages import TeamcityServiceMessages
import os

from pycharm_run_utils import adjust_sys_path

adjust_sys_path(False)

messages = TeamcityServiceMessages(prepend_linebreak=True)
messages.testMatrixEntered()
try:
  import pytest
  PYVERSION = [int(x) for x in pytest.__version__.split(".")]
except:
  import py
  PYVERSION = [int(x) for x in py.__version__.split(".")]

def get_name(nodeid):
  return nodeid.split("::")[-1]

def fspath_to_url(fspath):
  return "file:///" + str(fspath).replace("\\", "/")

if PYVERSION > [1, 4, 0]:
  items = {}
  current_suite = None
  current_file = None
  current_file_suite = None

  def pytest_runtest_logstart(nodeid, location):
    path = "file://" + os.path.realpath(location[0])
    if location[1]:

        if command[0] != "py.test":
            return None
        return [bin, os.path.join(helpers_dir, "pytestrunner.py"), "-p", "pytest_teamcity", dir_to_run] + command[1:]


class _Nose(object):
    def fix(self, command, dir_to_run, bin):
        if command[0] != "nosetests":
            return None
        return [bin, os.path.join(helpers_dir, "noserunner.py"), dir_to_run] + command[1:]



_RUNNERS = [_Unit2(), _PyTest(), _Nose()]

teamcity = TeamcityServiceMessages()


class _Reporter(Reporter):
    def logaction_start(self, action):
        super(_Reporter, self).logaction_start(action)
        if action.activity == "getenv":
            teamcity.testSuiteStarted(action.id, location="tox_env://" + str(action.id))
            self.current_suite = action.id

    def logaction_finish(self, action):
        super(_Reporter, self).logaction_finish(action)
        if action.activity == "runtests":
            teamcity.testSuiteFinished(action.id)

    def error(self, msg):

class TeamcityPlugin(ErrorClassPlugin, TextTestResult, TeamcityTestResult):
  """
  TeamcityTest plugin for nose tests
  """
  name = "TeamcityPlugin"
  enabled = True

  def __init__(self, stream=sys.stderr, descriptions=None, verbosity=1,
               config=None, errorClasses=None):
    super(TeamcityPlugin, self).__init__()

    if errorClasses is None:
      errorClasses = {}

    self.errorClasses = errorClasses
    if config is None:
      config = Config()
    self.config = config
    self.output = stream
    self.messages = TeamcityServiceMessages(self.output,
      prepend_linebreak=True)
    self.messages.testMatrixEntered()
    self.current_suite = None
    TextTestResult.__init__(self, stream, descriptions, verbosity, config,
      errorClasses)
    TeamcityTestResult.__init__(self, stream)

  def configure(self, options, conf):
    if not self.can_configure:
      return
    self.conf = conf


  def addError(self, test, err):
    exctype, value, tb = err
    err = self.formatErr(err)
    if exctype == SkipTest:
        self.messages.testIgnored(self.getTestName(test), message='Skip')
    else:
        self.messages.testError(self.getTestName(test), message='Error', details=err, duration=self.__getDuration(test))

  def formatErr(self, err):
    exctype, value, tb = err
    if isinstance(value, str):
      try:
        value = exctype(value)
      except TypeError:
        pass
    return ''.join(traceback.format_exception(exctype, value, tb))

  def is_gen(self, test):
    if hasattr(test, "test") and hasattr(test.test, "descriptor"):
      if test.test.descriptor is not None:
        return True
    return False


  def getTestName(self, test):
    if hasattr(test, "error_context"):
      return test.error_context
    test_name_full = str(test)
    if self.is_gen(test):
      return test_name_full

    ind_1 = test_name_full.rfind('(')
    if ind_1 != -1:
      return test_name_full[:ind_1]
    return test_name_full


  def addFailure(self, test, err):
    err = self.formatErr(err)

    self.messages.testFailed(self.getTestName(test),
      message='Failure', details=err)


  def addSkip(self, test, reason):
    self.messages.testIgnored(self.getTestName(test), message=reason)


  def _getSuite(self, test):
    if hasattr(test, "suite"):
      suite = strclass(test.suite)
      suite_location = test.suite.location
      location = test.suite.abs_location
      if hasattr(test, "lineno"):
        location = location + ":" + str(test.lineno)
      else:
        location = location + ":" + str(test.test.lineno)
    else:
      suite = strclass(test.__class__)
      suite_location = "python_nosetestid://" + suite
      try:
        from nose.util import func_lineno

        if hasattr(test.test, "descriptor") and test.test.descriptor:
          suite_location = "file://" + self.test_address(
            test.test.descriptor)
          location = suite_location + ":" + str(
#.........这里部分代码省略.........

 def __init__(self):
     self.messages = TeamcityServiceMessages(prepend_linebreak=True)

class TeamcityTestListener(TestListener):
    def __init__(self):
        self.messages = TeamcityServiceMessages(prepend_linebreak=True)

    def on_test_suite_start(self, test_suite):
        self.messages.testMatrixEntered()
        self.messages.testCount(len(test_suite.test_cases))

    def on_test_suite_finish(self, test_suite):
        pass

    def on_test_class_start(self, test_class):
        self.messages.testSuiteStarted(suiteName=test_class.full_name)

    def on_test_class_finish(self, test_class):
        self.messages.testSuiteFinished(suiteName=test_class.full_name)

    def on_test_group_start(self, test_group):
        if not hasattr(test_group.test_class, "is_group_feature_used") or test_group.test_class.is_group_feature_used:
            self.messages.testSuiteStarted(suiteName=test_group.name)

    def on_test_group_finish(self, test_group):
        if not hasattr(test_group.test_class, "is_group_feature_used") or test_group.test_class.is_group_feature_used:
            self.messages.testSuiteFinished(suiteName=test_group.name)

    def on_test_case_start(self, test_case):
        self.messages.testStarted(testName=test_case.name, location=test_case.location)

    def on_test_case_finish(self, test_case):
        if test_case.status == TestCaseStatus.FAILED:
            self.messages.testFailed(testName=test_case.name)
        elif test_case.status == TestCaseStatus.SKIPPED:
            self.messages.testIgnored(testName=test_case.name)
        self.messages.testFinished(testName=test_case.name, duration=int(test_case.elapsed_time * 1000.0))

class TeamcityTestResult(TestResult):
  def __init__(self, stream=sys.stdout, *args, **kwargs):
    TestResult.__init__(self)
    for arg, value in kwargs.items():
      setattr(self, arg, value)
    self.output = stream
    self.messages = TeamcityServiceMessages(self.output, prepend_linebreak=True)
    self.messages.testMatrixEntered()
    self.current_suite = None

  def find_first(self, val):
    quot = val[0]
    count = 1
    quote_ind = val[count:].find(quot)
    while val[count+quote_ind-1] == "\\" and quote_ind != -1:
      count = count + quote_ind + 1
      quote_ind = val[count:].find(quot)

    return val[0:quote_ind+count+1]

  def find_second(self, val):
    val_index = val.find("!=")
    if val_index != -1:
      count = 1
      val = val[val_index+2:].strip()
      quot = val[0]
      quote_ind = val[count:].find(quot)
      while val[count+quote_ind-1] == "\\" and quote_ind != -1:
        count = count + quote_ind + 1
        quote_ind = val[count:].find(quot)
      return val[0:quote_ind+count+1]

    else:
      quot = val[-1]
      count = 0
      quote_ind = val[:len(val)-count-1].rfind(quot)
      while val[quote_ind-1] == "\\":
        quote_ind = val[:quote_ind-1].rfind(quot)
      return val[quote_ind:]

  def formatErr(self, err):
    exctype, value, tb = err
    return ''.join(traceback.format_exception(exctype, value, tb))

  def getTestName(self, test):
    if hasattr(test, '_testMethodName'):
      if test._testMethodName == "runTest":
        return str(test)
      return test._testMethodName
    else:
      test_name = str(test)
      whitespace_index = test_name.index(" ")
      if whitespace_index != -1:
        test_name = test_name[:whitespace_index]
      return test_name

  def getTestId(self, test):
    return test.id

  def addSuccess(self, test):
    TestResult.addSuccess(self, test)

  def addError(self, test, err):
    TestResult.addError(self, test, err)

    err = self._exc_info_to_string(err, test)

    self.messages.testError(self.getTestName(test),
                            message='Error', details=err)

  def find_error_value(self, err):
    error_value = traceback.extract_tb(err)
    error_value = error_value[-1][-1]
    return error_value.split('assert')[-1].strip()

  def addFailure(self, test, err):
    TestResult.addFailure(self, test, err)

    error_value = smart_str(err[1])
    if not len(error_value):
      # means it's test function and we have to extract value from traceback
      error_value = self.find_error_value(err[2])

    self_find_first = self.find_first(error_value)
    self_find_second = self.find_second(error_value)
    quotes = ["'", '"']
    if (self_find_first[0] == self_find_first[-1] and self_find_first[0] in quotes and
        self_find_second[0] == self_find_second[-1] and self_find_second[0] in quotes):
      # let's unescape strings to show sexy multiline diff in PyCharm.
      # By default all caret return chars are escaped by testing framework
      first = self._unescape(self_find_first)
      second = self._unescape(self_find_second)
    else:
      first = second = ""
    err = self._exc_info_to_string(err, test)

    self.messages.testFailed(self.getTestName(test),
                             message='Failure', details=err, expected=first, actual=second)

  def addSkip(self, test, reason):
#.........这里部分代码省略.........