Python Mocker.method方法代码示例

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def do_test(windows_template):
     app = Application()
     m = Mocker()
     seen = set()
     dirty_docs = []
     eds = []
     for ecfg in windows_template:
         projects = []
         for pcfg in ecfg:
             proj = m.mock(Project)
             projects.append(proj)
             editors = []
             has_dirty = False
             for doc_id in pcfg:
                 editor = m.mock(Editor)
                 editors.append(editor)
                 (editor.document.id << doc_id).count(1, 2)
                 if doc_id not in seen:
                     seen.add(doc_id)
                     dirty_docs.append(editor)
                     has_dirty = True
             proj.dirty_editors() >> editors
             if has_dirty:
                 dirty_docs.append(proj)
         ed = m.mock(Window)
         ed.projects >> projects
         eds.append(ed)
     m.method(app.iter_windows)() >> eds
     with m:
         result = list(app.iter_dirty_editors())
         eq_(result, dirty_docs)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def test(serial):
     m = Mocker()
     proj = Project.create()
     log = m.replace("editxt.project.log", passthrough=False)
     nsdat = m.replace(NSData, passthrough=False)
     nspls = m.replace(NSPropertyListSerialization, passthrough=False)
     create_document_view_with_state = m.method(Project.create_document_view_with_state)
     create_document_view = m.method(Project.create_document_view)
     proj._documents = docs = m.mock(KVOList)
     if "path" in serial:
         data = nsdat.dataWithContentsOfFile_(serial["path"]) >> m.mock()
         serial_, format, error = nspls. \
             propertyListFromData_mutabilityOption_format_errorDescription_( \
                 data, NSPropertyListImmutable, None, None) >> ({}, m.mock(), None)
     else:
         serial_ = serial
     docs_ = serial_.get("documents", [])
     for item in docs_:
         create_document_view_with_state(item)
         if item == "doc_not_found":
             m.throw(Exception("document not found"))
             log.warn("cannot open document: %r" % item)
         #proj._is_dirty = True
     bool(docs); m.result(bool(docs_))
     if not docs_:
         create_document_view()
         #proj._is_dirty = True
     with m:
         proj.deserialize(serial)
         if "path" in serial:
             eq_(proj.path, serial["path"])
             assert "name" not in serial
         else:
             eq_(proj.name, serial.get("name", const.UNTITLED_PROJECT_NAME))
             eq_(proj.expanded, serial.get("expanded", True))

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def test(eds_config):
     app = Application()
     m = Mocker()
     create_window = m.method(app.create_window)
     open_error_log = m.method(app.open_error_log)
     nsapp = m.mock(ak.NSApplication)
     ud_class = m.replace(fn, 'NSUserDefaults')
     m.method(app.iter_saved_window_states)() >> iter(eds_config)
     tc = m.replace(app, 'text_commander', spec=CommandManager)
     dc = m.mock(DocumentController)
     tc.load_commands(dc.textMenu >> m.mock(ak.NSMenu))
     tc.load_shortcuts(dc.shortcutsMenu >> m.mock(ak.NSMenu))
     if eds_config:
         error = False
         for ed_config in eds_config:
             if isinstance(ed_config, mod.StateLoadFailure):
                 error = True
             else:
                 create_window(ed_config)
         if error:
             open_error_log(set_current=False)
     else:
         create_window()
     with m:
         app.application_will_finish_launching(nsapp, dc)
         eq_(app.text_commander, tc)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def test(c):
     m = Mocker()
     fc = FindController.shared_controller()
     regexfind = m.method(fc.regexfinditer)
     simplefind = m.method(fc.simplefinditer)
     rfr = m.property(fc, "recently_found_range")
     sel = NSMakeRange(1, 2)
     direction = "<direction>"
     opts = m.property(fc, "opts").value >> m.mock(FindOptions)
     ftext = u"<find>"
     if opts.regular_expression >> c.regex:
         finditer = regexfind
     elif opts.match_entire_word >> c.mword:
         finditer = regexfind
         ftext = u"\\b" + re.escape(ftext) + u"\\b"
     else:
         finditer = simplefind
     range = NSMakeRange(sel.location, 0)
     items = []
     rng = None
     for i, r in enumerate(c.matches):
         if r is WRAPTOKEN:
             items.append(r)
             continue
         found = FoundRange(NSMakeRange(*r))
         items.append(found)
         if i == 0 and found.range == sel:
             continue
         rfr.value = found
         rng = found.range
     finditer(u"<text>", ftext, range, direction, True) >> items
     with m:
         result = fc._find(u"<text>", u"<find>", sel, direction)
         eq_(result, rng)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def test(ed_config):
     ac = Application()
     m = Mocker()
     df_class = m.replace("editxt.application.NSUserDefaults")
     iter_editors = m.method(ac.iter_editors)
     save_open_projects = m.method(ac.save_open_projects)
     discard_editor = m.method(ac.discard_editor)
     nsapp = m.mock()
     ac.editors = eds = []
     all_settings = []
     for i in ed_config:
         ed = m.mock(Editor)
         eds.append(ed)
         ed.window_settings_loaded >> (i != 2)
         if i != 2:
             settings = "<settings %s>" % i
             all_settings.append(settings)
             ed.window_settings >> settings
     iter_editors(nsapp) >> reversed(eds)
     defaults = df_class.standardUserDefaults() >> MockUserDefaults()
     save_open_projects(defaults)
     with m:
         ac.app_will_terminate(nsapp)
     result = defaults.arrayForKey_(const.WINDOW_SETTINGS_DEFAULTS_KEY)
     eq_(result, all_settings)
     assert defaults.synced

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def test(app, has_text_storage, event=None):
     INDENT_SIZE = 42
     m = Mocker()
     ps_class = m.replace(ak, 'NSParagraphStyle')
     doc = TextDocument(app)
     if has_text_storage:
         with m.off_the_record():
             ts = doc.text_storage = m.mock(ak.NSTextStorage)
     else:
         ts = doc.text_storage = None
     font = app.default_font.font
     tabw = ak.NSString.stringWithString_("8" * INDENT_SIZE) \
              .sizeWithAttributes_({ak.NSFontAttributeName: font}).width
     ps = ps_class.defaultParagraphStyle().mutableCopy() >> m.mock()
     ps.setTabStops_([])
     ps.setDefaultTabInterval_(tabw)
     attrs = {
         ak.NSFontAttributeName: font,
         ak.NSParagraphStyleAttributeName: ps,
         ak.NSForegroundColorAttributeName: app.theme.text_color,
     }
     if has_text_storage:
         no_color = {k: v for k, v in attrs.items()
                     if k != ak.NSForegroundColorAttributeName}
         ts.addAttributes_range_(no_color, fn.NSMakeRange(0, ts.length() >> 20))
         ts.setFont_(doc.font.font)
     editors = [m.mock(Editor), m.mock(Editor)]
     m.method(app.iter_editors_of_document)(doc) >> editors
     for editor in editors:
         editor.set_text_attributes(attrs)
     with m:
         doc.reset_text_attributes(INDENT_SIZE, event)
         eq_(doc.default_text_attributes(), attrs)
         eq_(doc.syntax_needs_color,
             has_text_storage and event and event.theme_changed)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
def test_set_syntaxdef(app):
    from editxt.syntax import SyntaxDefinition
    m = Mocker()
    sd = m.mock(SyntaxDefinition)
    doc = TextDocument(app)
    m.method(doc.color_text)()
    with m:
        doc.syntaxdef = sd
        eq_(doc.syntaxer.syntaxdef, sd)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
def test_SortLinesController_sort_():
    m = Mocker()
    sort = m.replace(sortlines, passthrough=False)
    tv = m.mock(TextView)
    slc = SortLinesController.create_with_textview(tv)
    sort(tv, slc.opts)
    m.method(slc.save_options)()
    m.method(slc.cancel_)(None)
    with m:
        slc.sort_(None)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
def test_WrapLinesController_wrap_():
    m = Mocker()
    cmd = m.replace(mod, 'wrap_selected_lines')
    tv = m.mock(TextView)
    ctl = WrapLinesController(tv)
    cmd(tv, ctl.options)
    m.method(ctl.save_options)()
    m.method(ctl.cancel_)(None)
    with m:
        ctl.wrap_(None)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def test(c):
     m = Mocker()
     fc = FindController.shared_controller()
     sender = m.mock()
     if "do" in c:
         c.do(m, c, fc, sender)
     else:
         m.method(fc.finder, c.real)(*c.args)
     with m:
         getattr(fc, c.meth)(sender)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
def test_init_with_serial():
    m = Mocker()
    kvo_class = m.replace(mod, 'KVOList')
    deserialize = m.method(Project.deserialize)
    reset_cache = m.method(Project.reset_serial_cache)
    docs = kvo_class.alloc().init() >> []
    deserialize("<serial>")
    reset_cache(); m.count(2)
    with m:
        proj = Project.alloc().init_with_serial("<serial>")

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
def test_SortLinesController_sort_():
    m = Mocker()
    sort = m.replace(mod, 'sortlines')
    tv = m.mock(TextView)
    with replace_history() as history:
        slc = SortLinesController(tv)
        sort(tv, slc.options)
        m.method(slc.save_options)()
        m.method(slc.cancel_)(None)
        with m:
            slc.sort_(None)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
def test_SortLinesController_sort_():
    m = Mocker()
    sort = m.replace(mod, 'sortlines')
    with test_app() as app:
        editor = base.Options(app=app)
        slc = SortLinesController(editor)
        sort(editor, slc.options)
        m.method(slc.save_options)()
        m.method(slc.cancel_)(None)
        with m:
            slc.sort_(None)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
def test_WrapLinesController_wrap_():
    with test_app() as app:
        m = Mocker()
        editor = base.Options(app=app)
        cmd = m.replace(mod, 'wrap_selected_lines')
        ctl = WrapLinesController(editor)
        cmd(editor, ctl.options)
        m.method(ctl.save_options)()
        m.method(ctl.cancel_)(None)
        with m:
            ctl.wrap_(None)

# 需要导入模块: from mocker import Mocker [as 别名]
# 或者: from mocker.Mocker import method [as 别名]
 def test(c):
     with test_app() as app:
         m = Mocker()
         fc = FindController(app)
         sender = m.mock()
         if "do" in c:
             c.do(m, c, fc, sender)
         else:
             m.method(fc.finder, c.real)(*c.args)
         with m:
             getattr(fc, c.meth)(sender)