Wing Python IDE

import os
import wingapi

g_last_target = [None]

def generate_tests_for_class():
  """Generate a test skeleton for the class at the current editor focus, open
  it side by side with the original source, and set up automatic navigation
  of the source being tested."""

  # Collect objects we need to work with:  The app and the editor we're starting from
  app = wingapi.gApplication
  code_editor = app.GetActiveEditor()

  # Try to find a class at current editor focus
  fn, scope = _find_class(code_editor)
  if scope is None:
    app.ShowMessageDialog("No Class Found", "Could not generate tests:  "
                          "No class was found at current focus")
    return

  # Get the methods for the class
  code_ana = app.GetAnalysis(fn)
  contents = code_ana.GetScopeContents('.'.join(scope), timeout=3.0)
  methods = [s for s in contents if 'method' in contents[s]]

  # Create the test skeleton, with one test for each public method
  output = [
    'import unittest',
    '',
    'class Test{}(unittest.TestCase):'.format(scope[-1]),
  ]
  for method in methods:
    if method.startswith('_'):
      continue
    output.extend([
      '',
      _indent(code_editor, 1) + 'def test{}(self):'.format(method),
      _indent(code_editor, 2) + 'pass',
    ])
  if len(output) == 3:
    output.extend([
      '',
      _indent(code_editor, 1) +'pass',
    ])

  # Set up a side-by-side mode after saving the current visual state
  visual_state = app.GetVisualState(style='tools-and-editors')
  app.ExecuteCommand('unsplit')
  app.ExecuteCommand('split-horizontally')

  # Open up the test skeleton in an unsaved file with name based on the original code
  test_fn = os.path.join(os.path.dirname(fn), 'test_{}'.format(os.path.basename(fn)))
  test_editor = app.OpenEditor(test_fn)
  test_editor.GetDocument().SetText(code_editor.GetEol().join(output))

  # Connect to the test editor so we can show the matching method in the source
  # when the caret moves around within the tests
  def track_position(start, end):
    lineno = test_editor.GetDocument().GetLineNumberFromPosition(start) + 1
    test_ana = app.GetAnalysis(test_editor.GetDocument().GetFilename())
    scope = test_ana.FindScopeContainingLine(lineno)
    scope = scope.split('.')
    if scope:
      if not scope[0].startswith('Test') or not scope[-1].startswith('test'):
        return
      scope[0] = scope[0][len('Test'):]
      scope[-1] = scope[-1][len('test'):]
      scope = _find_symbol(code_ana, scope, 'method')
    if not scope:
      return
    if g_last_target[0] == scope:
      return
    g_last_target[0] = scope
    infos = code_ana.GetSymbolInfo('.'.join(scope[:-1]), scope[-1])
    if not infos:
      return
    lineno = infos[0].lineStart
    start = code_editor.GetDocument().GetLineStart(lineno) + infos[0].pos
    end = start + len(scope[-1])
    code_editor.ScrollToLine(max(0, lineno-2), select=(start, end), pos='top', callout=1)
  test_editor.Connect('selection-changed', track_position)

  # Connect to the test editor so we can restore the prior visual state when it is closed
  def restore_state(unused):
    app.SetVisualState(visual_state)
  test_editor.Connect('destroy', restore_state)

  app.ShowMessageDialog("Tests Generated", "Tests for class {} have been generated.  ".format(scope[-1]) +
                        "As you fill in the tests, the method being tested is shown on the left as you "
                        "move around the test file on the right.  Closing the tests will return Wing to "
                        "the previous visual state.")

# Command configuration

def _generate_tests_for_class_available():
  ed = wingapi.gApplication.GetActiveEditor()
  if ed is None:
    return False
  mime = wingapi.gApplication.GetMimeType(ed.GetDocument().GetFilename())
  if mime != 'text/x-python':
    return False
  return _find_class(ed)[1] is not None

generate_tests_for_class.available = _generate_tests_for_class_available
generate_tests_for_class.label = "Generate Tests for Class"
generate_tests_for_class.contexts = [wingapi.kContextNewMenu('Scripts', 1)]

# Utilities

def _indent(ed, level):
  """Get indentation that matches the file we're writing the test for"""
  indent_style = ed.GetIndentStyle()
  if indent_style == 1:
    return ' ' * ed.GetIndentSize() * level
  elif indent_style == 2:
    return '\t' * level
  else:
    tabs = ed.GetIndentSize() * level / ed.GetTabSize()
    spaces = ed.GetIndentSize() * level - (tabs * ed.GetTabSize)
    return '\t' * tabs + ' ' * spaces

def _find_symbol(ana, scope, symbol_type):
  """Find the outermost symbol of given type in the given scope"""
  for i in range(0, len(scope)):
    infos = ana.GetSymbolInfo('.'.join(scope[:i]), scope[i])
    for info in infos:
      if symbol_type in info.generalType:
        return scope[:i+1]
  return None

def _find_class(ed):
  """Find the current top-level class in the given code editor"""
  if ed is None:
    return None, None
  scope = ed.GetSourceScope()
  if scope is None:
    return None, None
  fn, lineno = scope[:2]
  ana = wingapi.gApplication.GetAnalysis(fn)
  scope = _find_symbol(ana, scope[2:], 'class')
  return fn, scope