def test_set_main_view_of_window(): proj = Project.create() m = Mocker() view = m.mock(ak.NSView) win = m.mock(ak.NSWindow) with m: proj.set_main_view_of_window(view, win) # for now this does nothing
def test_collect_process_info_new_report(self): """Check how the process info is collected first time.""" mocker = Mocker() assert not self.worker.process_cache # patch Process to return our mock for test pid Process = mocker.mock() self.patch(stats_worker.psutil, 'Process', Process) proc = mocker.mock() pid = 1234 expect(Process(pid)).result(proc) # patch ProcessReport to return or mock for given proc ProcessReport = mocker.mock() self.patch(stats_worker, 'ProcessReport', ProcessReport) proc_report = mocker.mock() expect(ProcessReport(proc)).result(proc_report) # expect to get called with some info, return some results name = 'test_proc' result = object() expect(proc_report.get_memory_and_cpu(prefix=name)).result(result) with mocker: real = self.worker._collect_process(pid, name) self.assertIdentical(real, result)
def test_find_match_not_matched(self): key1 = "chr1:154000-230000" mocker = Mocker() junction = mocker.mock() junction.coverage mocker.result(40) container1 = mocker.mock() container2 = mocker.mock() container1.keys() mocker.result([key1]) container1[key1] mocker.result(junction) container2[key1] mocker.throw(KeyError) mocker.count(1) mocker.replay() self.common, self.diff = jc.findMatch(container1, container2) self.assertEqual(self.common.keys(), []) self.assertEqual(self.diff.keys(), [key1]) mocker.restore() mocker.verify()
def test_find_match_matched(self): key = "chr1:154000-230000" mocker = Mocker() junction = mocker.mock() junction.coverage mocker.result(40) mocker.count(1, None) container = mocker.mock() container.keys() mocker.result([key]) container[key] mocker.result(junction) mocker.count(1, None) mocker.replay() self.common, self.diff = jc.findMatch(container, container) self.assertEqual(self.common.keys(), ["chr1:154000-230000"]) self.assertEqual(self.diff.keys(), []) mocker.restore() mocker.verify()
def test(c): m = Mocker() beep = m.replace(mod, "beep") options = make_options(c) editor = m.mock(Editor) editor.selection >> c.select (editor.text << Text(c.text)).count(0, None) tv = m.mock(ak.NSTextView) (editor.text_view << tv).count(0, 1) (tv.shouldChangeTextInRange_replacementString_(ANY, ANY) << True).count(0, 1) expect(tv.didChangeText()).count(0, 1) expect(tv.setNeedsDisplay_(True)).count(0, 1) if c.expect is BEEP: beep() finder = Finder((lambda: editor), options, None) with m: if isinstance(c.expect, Exception): def check(err): print(err) eq_(str(err), str(c.expect)) with assert_raises(type(c.expect), msg=check): getattr(finder, c.action)(None) else: getattr(finder, c.action)(None) if c.expect is BEEP: eq_(editor.text[:], c.text) else: eq_(editor.text[:], c.expect)
def test(c): m = Mocker() opts = "<options>" tv = m.mock(TextView) ts = tv.textStorage() >> m.mock(ak.NSTextStorage) wrap = m.replace(mod, 'wraplines') iterlines = m.replace("editxt.command.wraplines.iterlines") text = tv.string() >> fn.NSString.stringWithString_(c.text) sel = (0, len(text)) if c.sel is None else c.sel sel = text.lineRangeForRange_(tv.selectedRange() >> sel) eol = tv.doc_view.document.eol >> m.mock() lines = iterlines(text, sel) >> "<lines>" eol.join(wrap(lines, opts, tv) >> [c.result]) >> c.result tv.shouldChangeTextInRange_replacementString_(sel, c.result) >> True output = [] def callback(range, text): output.append(text) expect(ts.replaceCharactersInRange_withString_( sel, c.result)).call(callback) tv.didChangeText() tv.setSelectedRange_((sel[0], len(c.result))) with m: wrap_selected_lines(tv, opts) eq_(c.result, output[0])
def test_get_share(self): """Get a share.""" mocker = Mocker() # the share share = mocker.mock() expect(share.id).result("share_id") expect(share.root_id).result("share_root_id") expect(share.name).result("name") expect(share.shared_by_id).result("shared_by_id") expect(share.shared_to_id).result("shared_to_id") expect(share.accepted).result(True) expect(share.access).result(1) # user user = mocker.mock() self.dal._get_user = lambda *a: user expect(user.get_share("share_id")).result(share) with mocker: result = self.dal.get_share("user_id", "share_id") should = dict( share_id="share_id", share_root_id="share_root_id", name="name", shared_by_id="shared_by_id", accepted=True, shared_to_id="shared_to_id", access=1, ) self.assertEqual(result, should)
def test(c): m = Mocker() ac = Application() ac.editors = eds = [] found_item = None for w in c.eds: ed = m.mock(Editor) eds.append(ed) projs = (ed.projects >> []) for p in w.projs: proj = m.mock(Project) docs = [] projs.append(proj) if found_item is None: proj.id >> p.id if p.id == c.id: found_item = proj else: proj.documents() >> docs for d in p.docs: doc = m.mock(TextDocumentView) docs.append(doc) if found_item is None: doc.id >> d.id if d.id == c.id: found_item = doc with m: result = ac.find_item_with_id(c.id) eq_(result, found_item) if c.found: assert result is not None else: assert result is None
def test_make_file_with_content(self): """Make a file with content associated.""" mocker = Mocker() # node, with a generation attribute node = mocker.mock() expect(node.id).result("node_id") expect(node.generation).result(123) # user, with the chained calls to the operation user = mocker.mock() expect( user.volume("vol_id") .dir("parent_id") .make_file_with_content("name", "hash", "crc32", "size", "deflated_size", "storage_key") ).result(node) self.dal._get_user = lambda *a: user with mocker: kwargs = dict( user_id="user_id", volume_id="vol_id", name="name", parent_id="parent_id", crc32="crc32", size="size", node_hash="hash", deflated_size="deflated_size", storage_key="storage_key", session_id="session_id", ) result = self.dal.make_file_with_content(**kwargs) self.assertEqual(result, dict(generation=123, node_id="node_id"))
def test_list_volumes_root_and_quota(self): """List volumes, check root and quota.""" mocker = Mocker() # root root = mocker.mock() expect(root.generation).result(123) expect(root.root_id).result("root_id") # quota quota = mocker.mock() expect(quota.free_bytes).result(4567890) # user user = mocker.mock() self.dal._get_user = lambda *a: user expect(user.volume().get_volume()).result(root) expect(user.get_shared_to(accepted=True)).result([]) expect(user.get_udfs()).result([]) expect(user.get_quota()).result(quota) with mocker: result = self.dal.list_volumes("user_id") self.assertEqual(sorted(result), ["free_bytes", "root", "shares", "udfs"]) self.assertEqual(result["root"], dict(generation=123, root_id="root_id")) self.assertEqual(result["free_bytes"], 4567890)
def test(c): m = Mocker() regundo = m.replace(mod, 'register_undo_callback') convert = m.replace(mod, 'change_indentation') doc = m.mock(TextDocument) with m.off_the_record(): dv = Editor(None, document=doc) tv = dv.text_view = m.mock(ak.NSTextView) if c.convert: old_indent = "\t" if c.oldm is TAB else (" " * c.olds) new_indent = "\t" if c.newm is TAB else (" " * c.news) convert(tv, old_indent, new_indent, c.news) if c.oldm != c.newm: doc.props.indent_mode = c.newm if c.olds != c.news: doc.props.indent_size = c.news if c.convert or c.convert is None: undo_change = m.mock(); undo_change(c.newm, c.news, c.oldm, c.olds, None) def _undo(undoman, undo): dv.change_indentation = undo_change undo() undoman = doc.undo_manager >> m.mock(fn.NSUndoManager) expect(regundo(undoman, ANY)).call(_undo) with m: dv.change_indentation(c.oldm, c.olds, c.newm, c.news, c.convert)
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)
def test_parsing_files_with_empty_content_returns_invalid_files_list(): mocker = Mocker() settings = Settings() files = ["some path"] story_text = "" filemock = mocker.mock() filemock.list_files(directories=settings.tests_dirs, pattern=settings.file_pattern) mocker.result(files) filemock.read_file(files[0]) mocker.result(story_text) language_mock = mocker.mock() language_mock.get("as_a") mocker.result("As a") language_mock.get("i_want_to") mocker.result("I want to") language_mock.get("so_that") mocker.result("So that") language_mock.get("no_header_failure") mocker.result("No header found") with mocker: parser = FileParser(language=language_mock, file_object=filemock) fixture = parser.get_stories(settings=settings) assert len(fixture.no_story_header) == 1 file_path = fixture.no_story_header[0] assert file_path == "some path"
def test_parsing_files_with_proper_header_returns_parsed_scenario(): mocker = Mocker() settings = Settings() files = ["some path"] story_text = """As a someone I want to do something So that I'm happy""" filemock = mocker.mock() filemock.list_files(directories=settings.tests_dirs, pattern=settings.file_pattern) mocker.result(files) filemock.read_file(files[0]) mocker.result(story_text) language_mock = mocker.mock() language_mock.get("as_a") mocker.result("As a") language_mock.get("i_want_to") mocker.result("I want to") language_mock.get("so_that") mocker.result("So that") with mocker: parser = FileParser(language=language_mock, file_object=filemock) fixture = parser.get_stories(settings=settings) assert len(fixture.stories) == 1 assert fixture.stories[0].as_a == "someone" assert fixture.stories[0].i_want_to == "do something" assert fixture.stories[0].so_that == "I'm happy"
def test_parse_scenario_line(): mocker = Mocker() story = Story(as_a="Someone", i_want_to="Do Something", so_that="I'm Happy", identity="some file") settings_mock = mocker.mock() settings_mock.scenarios_to_run mocker.result([]) language_mock = mocker.mock() language_mock.get("scenario") mocker.result("Scenario") with mocker: parser = FileParser(language=language_mock, file_object=None) scenario = parser.parse_scenario_line(story, "Scenario 1 - Doing something", settings_mock) assert scenario is not None assert scenario.index == "1", "Expected 1 actual %s" % scenario.index assert scenario.title == "Doing something"
def test(c): proj = Project.create() m = Mocker() dsd_class = m.replace("editxt.application.DocumentSavingDelegate") app = m.replace("editxt.app", type=Application) ed = m.mock(Editor) app.find_editors_with_project(proj) >> [ed for x in xrange(c.num_eds)] if c.num_eds == 1: docs = [m.mock(TextDocumentView)] doc = docs[0].document >> m.mock(TextDocument) app.iter_editors_with_view_of_document(doc) >> \ (ed for x in xrange(c.num_doc_views)) dirty_documents = m.method(proj.dirty_documents) dirty_documents() >> docs def check_docs(_docs): d = docs if c.num_doc_views == 1 else [] eq_(list(_docs), d + [proj]) return True callback = [] def get_callback(func): callback.append(func) return True def do_callback(): callback[0](c.should_close) saver = m.mock(DocumentSavingDelegate) dsd_class.alloc() >> saver saver.init_callback_(MATCH(check_docs), MATCH(get_callback)) >> saver expect(saver.save_next_document()).call(do_callback) if c.should_close: ed.discard_and_focus_recent(proj) else: ed.discard_and_focus_recent(proj) with m: proj.perform_close(ed)
def test_set_main_view_of_window(): proj = Project.create() m = Mocker() view = m.mock(NSView) win = m.mock(NSWindow) with m: proj.set_main_view_of_window(view, win) # for now this does nothing
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))
def test(c): text = "the text is made of many texts" m = Mocker() tv = m.mock(TextView) tv._Finder__last_mark >> (None, 0) tv._Finder__last_mark = (c.options.find_text, c.count) ts = tv.textStorage() >> m.mock(ak.NSTextStorage) app = m.replace(editxt, "app") app.config["highlight_selected_text.color"] >> "<color>" full_range = fn.NSMakeRange(0, ts.length() >> len(text)) layout = tv.layoutManager() layout.removeTemporaryAttribute_forCharacterRange_( ak.NSBackgroundColorAttributeName, full_range) find_target = lambda: tv finder = Finder(find_target, c.options) if c.options.find_text: text = fn.NSString.alloc().initWithString_(text) (tv.string() << text).count(1, None) mark_range = layout.addTemporaryAttribute_value_forCharacterRange_ >> m.mock( ) mark = mark_range(ak.NSBackgroundColorAttributeName, ANY, ANY) expect(mark).count(c.count) with m: count = finder.mark_occurrences(c.options.find_text, c.allow_regex) eq_(count, c.count)
def test_add_part_to_uploadjob(self): """Delete an uploadjob.""" mocker = Mocker() # upload job uj = mocker.mock() expect( uj.add_part( "chunk_size", "inflated_size", "crc32", "hash_context", "magic_hash_context", "decompress_context" ) ) # user user = mocker.mock() self.dal._get_user = lambda *a: user expect(user.get_uploadjob("uploadjob_id")).result(uj) with mocker: d = dict( user_id="user_id", uploadjob_id="uploadjob_id", chunk_size="chunk_size", inflated_size="inflated_size", crc32="crc32", hash_context="hash_context", magic_hash_context="magic_hash_context", decompress_context="decompress_context", ) result = self.dal.add_part_to_uploadjob(**d) self.assertEqual(result, {})
def test_pyccuracy_core_run_tests_works_when_None_Result_returned_from_story_runner(): mocker = Mocker() context_mock, fso_mock = make_context_and_fso_mocks(mocker) context_mock.settings.write_report mocker.result(False) suite_mock = mocker.mock() suite_mock.no_story_header mocker.result([]) suite_mock.stories mocker.result(['some story']) runner_mock = mocker.mock() parser_mock = mocker.mock() parser_mock.used_actions mocker.count(min=1, max=None) mocker.result([]) parser_mock.get_stories(ANY) mocker.result(suite_mock) runner_mock.run_stories(KWARGS) mocker.result(None) with mocker: pc = PyccuracyCore(parser_mock, runner_mock) assert pc.run_tests(should_throw=False, context=context_mock, fso=fso_mock) == None
def test_make_file_with_content(self): """Make a file with content associated.""" mocker = Mocker() # node, with a generation attribute node = mocker.mock() expect(node.id).result('node_id') expect(node.generation).result(123) # user, with the chained calls to the operation user = mocker.mock() expect(user.volume('vol_id').dir('parent_id') .make_file_with_content('name', 'hash', 'crc32', 'size', 'deflated_size', 'storage_key') ).result(node) self.dal._get_user = lambda *a: user with mocker: kwargs = dict(user_id='user_id', volume_id='vol_id', name='name', parent_id='parent_id', crc32='crc32', size='size', node_hash='hash', deflated_size='deflated_size', storage_key='storage_key', session_id='session_id') result = self.dal.make_file_with_content(**kwargs) self.assertEqual(result, dict(generation=123, node_id='node_id'))
def test_offset(self): """ Test that, if the server's BEGIN_CONTENT message specifies an offset, the file to be uploaded is seek'ed to the right position. """ offset = 23 mocker = Mocker() transport = mocker.mock() transport.registerProducer(ANY, streaming=True) transport.write(ANY) mocker.count(1, None) # I don't really care how many times fd = mocker.mock() fd.seek(offset) # this is really all I care about fd.read(ANY) mocker.result('') mocker.replay() protocol = StorageClient() protocol.transport = transport pc = PutContent(protocol, 'share', 'node', '', '', 0, 0, 0, fd) message = protocol_pb2.Message() message.type = protocol_pb2.Message.BEGIN_CONTENT message.begin_content.offset = offset pc.start() pc.processMessage(message)
def test_add_part_to_uploadjob(self): """Delete an uploadjob.""" mocker = Mocker() # upload job uj = mocker.mock() expect(uj.add_part('chunk_size', 'inflated_size', 'crc32', 'hash_context', 'magic_hash_context', 'decompress_context')) # user user = mocker.mock() self.dal._get_user = lambda *a: user expect(user.volume('volume_id') .get_uploadjob('uploadjob_id')).result(uj) with mocker: d = dict(user_id='user_id', uploadjob_id='uploadjob_id', chunk_size='chunk_size', inflated_size='inflated_size', crc32='crc32', hash_context='hash_context', magic_hash_context='magic_hash_context', decompress_context='decompress_context', volume_id='volume_id') result = self.dal.add_part_to_uploadjob(**d) self.assertEqual(result, {})
def test_server_start_stop_metrics(self): """Test start/stop metrics.""" mocker = Mocker() service_meter = mocker.mock(name='meter') self.service.metrics = service_meter revno = mocker.mock(name='revno') self.patch(metrics.services, 'revno', revno) service_meter.meter('server_stop') service_meter.decrement('services_active') service_meter.meter('server_start') service_meter.increment('services_active') service_meter.timing("busy.ping", ANY) mocker.count(0, None) revno() mocker.count(0, None) service_meter.connection mocker.result(None) with mocker: yield self.service.stopService() yield self.service.startService()
def test_execute_action_will_not_execute_itself(): mocker = Mocker() class DoSomethingRecursiveAction(ActionBase): regex = r'^(And )?I do "(?P<what>\w+)" stuff$' def execute(self, context, getter_mock, *args, **kwargs): self.execute_action('And I do "recursive" stuff', context, getter=getter_mock) language_getter_mock = mocker.mock() language_getter_mock.get(ANY) mocker.count(min=1, max=None) mocker.result("^$") context_mock = Object(settings=mocker.mock()) context_mock.settings.default_culture mocker.result("en-us") with mocker: dosaction = DoSomethingRecursiveAction() args = [] kwargs = dict(what="nothing") dosaction.execute(context_mock, getter_mock=language_getter_mock, *args, **kwargs)
def test_make_content(self): """Make content.""" mocker = Mocker() # node 'old gen' node = mocker.mock() expect(node.generation).result('new_generation') expect(node.make_content('original_hash', 'hash_hint', 'crc32_hint', 'inflated_size_hint', 'deflated_size_hint', 'storage_key', 'magic_hash')) # user user = mocker.mock() expect(user.volume('volume_id').get_node('node_id')).result(node) self.dal._get_user = lambda *a: user with mocker: d = dict(user_id='user_id', volume_id='volume_id', node_id='node_id', original_hash='original_hash', hash_hint='hash_hint', crc32_hint='crc32_hint', inflated_size_hint='inflated_size_hint', deflated_size_hint='deflated_size_hint', storage_key='storage_key', magic_hash='magic_hash', session_id=None) result = self.dal.make_content(**d) self.assertEqual(result, dict(generation='new_generation'))
def test_move(self): """Move.""" mocker = Mocker() # node, with a generation attribute node = mocker.mock() expect(node.generation).result(123) expect(node.mimetype).result("mime") # user, with the chained calls to the operation user = mocker.mock() new_parent_id = uuid.uuid4() expect(user.volume("vol_id").node("node_id").move(new_parent_id, "new_name")).result(node) self.dal._get_user = lambda *a: user with mocker: kwargs = dict( user_id="user_id", volume_id="vol_id", node_id="node_id", new_parent_id=new_parent_id, new_name="new_name", session_id="session_id", ) result = self.dal.move(**kwargs) self.assertEqual(result, dict(generation=123, mimetype="mime"))
def test(c): if c.eol != "\n": c.input = c.input.replace("\n", c.eol) c.output = c.output.replace("\n", c.eol) result = [] m = Mocker() tv = m.mock(NSTextView) reset = (c.new == "\t") if c.old != c.new or reset: tv.string() >> c.input rng = NSMakeRange(0, len(c.input)) tv.shouldChangeTextInRange_replacementString_(rng, c.output) >> True if reset: doc = tv.doc_view.document >> m.mock(TextDocument) doc.reset_text_attributes(c.size) if c.input != c.output: sel = tv.selectedRange() >> NSRange(*c.sel) ts = tv.textStorage() >> m.mock(NSTextStorage) ts.replaceCharactersInRange_withString_(rng, c.output) if sel.location > len(c.output): sel = NSRange(len(c.output), 0) elif sel.location + sel.length > len(c.output): sel = NSRange(sel.location, len(c.output) - sel.location) tv.setSelectedRange_(sel) tv.didChangeText() with m: mod.change_indentation(tv, c.old, c.new, c.size)
def test_story_runner_returns_a_result_with_the_original_Fixture(): mocker = Mocker() settings = Settings() fixture = Fixture() action = some_action() fixture.append_story(action.scenario.story) runner = StoryRunner() context = Object() context.browser_driver = mocker.mock() context.browser_driver.start_test("http://localhost") context.browser_driver.stop_test() context.settings = mocker.mock() context.settings.on_before_action mocker.result(None) context.settings.on_action_successful mocker.result(None) context.language = mocker.mock() context.language.get('given') mocker.result('Given') context.language.get('when') mocker.result('When') context.language.get('then') mocker.result('Then') with mocker: result = runner.run_stories(settings, fixture, context=context) assert result.fixture == fixture
def test(c): with test_app() as app: m = Mocker() fc = FindController(app) flog = m.replace("editxt.command.find.log") beep = m.replace(mod, "beep") get_editor = m.method(fc.get_editor) sender = m.mock() (sender.tag() << c.tag).count(1, 2) func = None for tag, meth in list(fc.action_registry.items()): fc.action_registry[tag] = temp = m.mock(meth) if tag == c.tag: func = temp if c.fail: flog.info(ANY, c.tag) else: if c.error: err = mod.CommandError("error!") expect(func(sender)).throw(err) beep() editor = get_editor() >> (m.mock() if c.target else None) if c.target: editor.message("error!", msg_type=const.ERROR) else: flog.warn(err) else: func(sender) with m: fc.perform_action(sender)
def test_should_catch_assertion_error(): mocker = Mocker() def action_failed_method(context, *args, **kwargs): assert False, "bla" settings = Settings() runner = StoryRunner() fixture = Fixture() action = some_action() fixture.append_story(action.scenario.story) action.execute_function = action_failed_method context = Object() context.browser_driver = mocker.mock() context.browser_driver.start_test("http://localhost") context.browser_driver.stop_test() context.settings = mocker.mock() context.settings.on_before_action mocker.result(None) context.settings.on_action_error mocker.result(None) context.language = mocker.mock() context.language.get('given') mocker.result('Given') with mocker: result = runner.run_stories(settings=settings, fixture=fixture, context=context) assert isinstance(action.error, AssertionError) assert action.error.message == "bla"
def test_should_handle_action_errors_successfully(): mocker = Mocker() def action_failed_method(context, *args, **kwargs): raise ActionFailedError("bla") settings = Settings() runner = StoryRunner() fixture = Fixture() action = some_action() fixture.append_story(action.scenario.story) action.execute_function = action_failed_method context = Object() context.browser_driver = mocker.mock() context.browser_driver.start_test("http://localhost") context.browser_driver.stop_test() context.settings = mocker.mock() context.settings.on_before_action mocker.result(None) context.settings.on_action_error mocker.result(None) context.language = mocker.mock() context.language.get('given') mocker.result('Given') with mocker: result = runner.run_stories(settings=settings, fixture=fixture, context=context) assert fixture.get_status() == Status.Failed
def test_should_execute_scenarios_successfully(): mocker = Mocker() settings = Settings() runner = StoryRunner() fixture = Fixture() fixture.append_story(some_action().scenario.story) context = Object() context.browser_driver = mocker.mock() context.browser_driver.start_test("http://localhost") context.browser_driver.stop_test() context.settings = mocker.mock() context.settings.on_before_action mocker.result(None) context.settings.on_action_successful mocker.result(None) context.language = mocker.mock() context.language.get('given') mocker.result('Given') context.language.get('when') mocker.result('When') context.language.get('then') mocker.result('Then') with mocker: result = runner.run_stories(settings=settings, fixture=fixture, context=context) assert fixture.get_status() == Status.Successful
def test_create_share(self): """Create a share.""" mocker = Mocker() # patch the DAL method to get the other user id from the username to_user = mocker.mock() expect(to_user.id).result('to_user_id') fake = mocker.mock() expect(fake(username='******')).result(to_user) self.patch(dal_backend.services, 'get_storage_user', fake) # share share = mocker.mock() expect(share.id).result('share_id') # user, with the chained calls to the operation user = mocker.mock() expect(user.volume().dir('node_id').share( 'to_user_id', 'name', True)).result(share) self.dal._get_user = lambda *a: user with mocker: result = self.dal.create_share('user_id', 'node_id', 'to_username', 'name', True) self.assertEqual(result, dict(share_id='share_id'))
def test_closeAllDocumentsWithDelegate_didCloseAllSelector_contextInfo_(): import editxt.util as util context = 42 dc = ak.NSDocumentController.sharedDocumentController() m = Mocker() app = m.replace(editxt, 'app') def perf_sel(delegate, selector, *args): should_term(*args) dsd_class = m.replace(mod, 'DocumentSavingDelegate', spec=False) docs = m.mock() app.iter_dirty_documents() >> docs selector = "_docController:shouldTerminate:context:" delegate = m.mock() def test_callback(callback): callback("<result>") return True should_term = delegate._docController_shouldTerminate_context_ should_term(dc, "<result>", context) saver = m.mock(DocumentSavingDelegate) dsd_class.alloc() >> saver saver.init_callback_(docs, MATCH(test_callback)) >> saver saver.save_next_document() with replattr(mod, 'perform_selector', perf_sel), m: dc.closeAllDocumentsWithDelegate_didCloseAllSelector_contextInfo_( delegate, selector, context)
def test_get_share(self): """Get a share.""" mocker = Mocker() # the share share = mocker.mock() expect(share.id).result('share_id') expect(share.root_id).result('share_root_id') expect(share.name).result('name') expect(share.shared_by_id).result('shared_by_id') expect(share.shared_to_id).result('shared_to_id') expect(share.accepted).result(True) expect(share.access).result(1) # user user = mocker.mock() self.dal._get_user = lambda *a: user expect(user.get_share('share_id')).result(share) with mocker: result = self.dal.get_share('user_id', 'share_id') should = dict(share_id='share_id', share_root_id='share_root_id', name='name', shared_by_id='shared_by_id', accepted=True, shared_to_id='shared_to_id', access=1) self.assertEqual(result, should)
def test_pyccuracy_core_run_tests(): mocker = Mocker() context_mock, fso_mock = make_context_and_fso_mocks(mocker) context_mock.settings.write_report mocker.result(False) suite_mock = mocker.mock() suite_mock.no_story_header mocker.result([]) suite_mock.stories mocker.result(['some story']) runner_mock = mocker.mock() parser_mock = mocker.mock() parser_mock.used_actions mocker.count(min=1, max=None) mocker.result([]) results_mock = mocker.mock() results_mock.summary_for('en-us') mocker.result('my results') parser_mock.get_stories(ANY) mocker.result(suite_mock) runner_mock.run_stories(KWARGS) mocker.result(results_mock) with mocker: pc = PyccuracyCore(parser_mock, runner_mock) #TODO: falha results = pc.run_tests(should_throw=False, context=context_mock, fso=fso_mock) assert results == results_mock, results
def do_test(editors_template): app = Application() m = Mocker() seen = set() dirty_docs = [] eds = [] for ecfg in editors_template: projects = [] for pcfg in ecfg: proj = m.mock(Project) projects.append(proj) documents = [] has_dirty = False for doc_id in pcfg: dv = m.mock(TextDocumentView) documents.append(dv) (dv.document.id << doc_id).count(1, 2) if doc_id not in seen: seen.add(doc_id) dirty_docs.append(dv) has_dirty = True proj.dirty_documents() >> documents if has_dirty: dirty_docs.append(proj) ed = m.mock(Editor) ed.projects >> projects eds.append(ed) m.method(app.iter_editors)() >> eds with m: result = list(app.iter_dirty_documents()) eq_(result, dirty_docs)
def test(c): if c.eol != "\n": c.input = c.input.replace("\n", c.eol) c.output = c.output.replace("\n", c.eol) result = TestConfig() default = False m = Mocker() tv = m.mock(ak.NSTextView) (tv.doc_view.document.indent_mode << c.mode).count(0, None) (tv.doc_view.document.indent_size << c.size).count(0, None) (tv.doc_view.document.eol << c.eol).count(0, None) sel = fn.NSMakeRange(*c.oldsel); (tv.selectedRange() << sel).count(0, None) (tv.string() << fn.NSString.stringWithString_(c.input)).count(0, None) (tv.shouldChangeTextInRange_replacementString_(ANY, ANY) << True).count(0, None) ts = m.mock(ak.NSTextStorage); (tv.textStorage() << ts).count(0, None) c.setup(m, c, TestConfig(locals())) def do_text(sel, repl): result.text = c.input[:sel[0]] + repl + c.input[sel[0] + sel[1]:] expect(ts.replaceCharactersInRange_withString_(ANY, ANY)).call(do_text).count(0, None) def do_sel(sel): result.sel = sel expect(tv.setSelectedRange_(ANY)).call(do_sel).count(0, None) expect(tv.didChangeText()).count(0, None) if c.scroll: tv.scrollRangeToVisible_(ANY) with m: c.method(tv, None, None) if "text" in result: eq_(result.text, c.output) else: eq_(c.output, SAME) if "sel" in result: eq_(result.sel, c.newsel)
def test(app, c): m = Mocker() doc = TextDocument(app) with m.off_the_record(): doc.text_storage = ts = m.mock(ak.NSTextStorage) app.syntax_factory = m.mock(SyntaxFactory) m.property(doc, "syntaxdef") m.property(doc, "props") syn = doc.syntaxer = m.mock(Highlighter) color_text = m.method(doc.color_text) syn.filename >> "<filename %s>" % ("0" if c.namechange else "1") new = doc.file_path = "<filename 1>" colored = False if c.namechange: syn.filename = new sdef = app.syntax_factory.get_definition(new) >> m.mock(SyntaxDefinition) doc.syntaxdef >> (None if c.newdef else sdef) if c.newdef: doc.props.syntaxdef = sdef color_text() colored = True doc.syntax_needs_color = c.needs_color if c.needs_color and not colored: color_text() with m: doc.update_syntaxer() eq_(doc.syntax_needs_color, False)
def test(c): m = Mocker() fc = FindController.shared_controller() beep = m.replace(ak, 'NSBeep') dobeep = True tv = m.replace(fc.finder, 'find_target')() >> (m.mock(TextView) if c.has_tv else None) options = m.replace(fc.finder, "options") ftext = options.find_text >> c.ftext range = ( tv.selectedRange() >> fn.NSRange(*c.sel)) if c.has_tv else None if c.has_tv and c.ftext and ((c.sel_only and c.sel[1] > 0) or not c.sel_only): text = tv.string() >> c.text if not c.sel_only: if (options.wrap_around >> c.wrap): range = fn.NSMakeRange(0, 0) else: range = fn.NSMakeRange(range[0], len(text) - range[0]) if options.regular_expression >> c.regex: finditer = m.method(fc.finder.regexfinditer) elif options.match_entire_word >> c.mword: ftext = "\\b" + re.escape(ftext) + "\\b" finditer = m.method(fc.finder.regexfinditer) else: finditer = m.method(fc.finder.simplefinditer) rtext = options.replace_text >> c.rtext found = None ranges = [] rtexts = [] items = [] FoundRange = make_found_range_factory( FindOptions(regular_expression=c.regex, match_entire_word=c.mword)) for r in c.ranges: found = FoundRange(fn.NSMakeRange(*r)) if ranges: rtexts.append(text[sum(ranges[-1]):r[0]]) ranges.append(found.range) rtexts.append(rtext) items.append(found) finditer(text, ftext, range, FORWARD, False) >> items if ranges: start = c.ranges[0][0] range = fn.NSMakeRange(start, sum(c.ranges[-1]) - start) value = "".join(rtexts) if tv.shouldChangeTextInRange_replacementString_( range, value) >> c.replace: ts = tv.textStorage() >> m.mock(ak.NSTextStorage) ts.replaceCharactersInRange_withString_(range, value) tv.didChangeText() tv.setNeedsDisplay_(True) dobeep = False eq_(dobeep, c.beep) if dobeep: beep() with m: fc.finder._replace_all(c.sel_only)
def test_TextView_doCommandBySelector_(): from editxt.textcommand import TextCommandController m = Mocker() tv = TextView.alloc().init() tc = m.replace(mod, "app").text_commander >> m.mock(TextCommandController) selector = m.mock() tc.do_textview_command_by_selector(tv, selector) >> True # omit super call with m: tv.doCommandBySelector_(selector)
def test_reload_config(): from editxt import app from editxt.config import Config m = Mocker() config = m.mock(Config) config.reload() tv = m.mock(ak.NSTextView) with m, replattr(app, "config", config): mod.reload_config(tv, "<sender>", None)
def test_TextView_performFindPanelAction_(): from editxt.command.find import FindController m = Mocker() tv = TextView.alloc().init() fc = m.replace(mod, "FindController") sender = m.mock() (fc.shared_controller() >> m.mock(FindController)).perform_action(sender) with m: tv.performFindPanelAction_(sender)
def test_applicationWillTerminate(): dc = ak.NSDocumentController.sharedDocumentController() m = Mocker() app = m.replace(editxt, 'app') notif = m.mock() # ak.NSApplicationWillTerminateNotification nsapp = m.mock(ak.NSApplication) app.app_will_terminate(notif.object() >> nsapp) with m: dc.applicationWillTerminate_(notif)
def test_TextView_performTextCommand_(): from editxt.textcommand import TextCommandController m = Mocker() tv = TextView.alloc().init() tc = m.replace(mod, "app").text_commander >> m.mock(TextCommandController) sender = m.mock() tc.do_textview_command(tv, sender) with m: tv.performTextCommand_(sender)
def test_set_current_document_view(): ac = Application() m = Mocker() dv = m.mock(TextDocumentView) ac.find_editor_with_document_view = m.method( ac.find_editor_with_document_view) ed = ac.find_editor_with_document_view(dv) >> m.mock(Editor) ed.current_view = dv with m: ac.set_current_document_view(dv)
def test(c): m = Mocker() app = m.replace(editxt, 'app') opc = OpenPathController.alloc().init() paths = m.property(opc, "paths").value >> m.mock(ak.NSTextView) paths.textStorage().string() >> c.text app.open_documents_with_paths(c.paths) (m.method(opc.window)() >> m.mock(ak.NSWindow)).orderOut_(opc) with m: opc.open_(None)
def test_register_undo(): from editxt.util import register_undo_callback m = Mocker() inv_class = m.replace(mod, 'Invoker') cb = m.mock() und = m.mock(fn.NSUndoManager) inv = inv_class.alloc().init(cb) >> m.mock(mod.Invoker) und.registerUndoWithTarget_selector_object_(inv_class, "invoke:", inv) with m: register_undo_callback(und, cb)
def test(command, size, mode): m = Mocker() tv = m.mock(TextView) view = tv.doc_view >> m.mock(TextDocumentView) props = view.props >> m.mock() setattr(props, "indent_size", size) setattr(props, "indent_mode", mode) do = CommandTester(mod.set_variable, textview=tv) with m: do(command)
def test_ChangeIndentationController_save_options(): m = Mocker() tv = m.mock(TextView) dv = tv.doc_view >> m.mock(TextDocumentView) with m.order(): mode = dv.indent_mode >> "<indent mode>" size = dv.indent_size >> "<indent size>" with m: ctl = ChangeIndentationController(tv) ctl.save_options()
def test(c): m = Mocker() app = Application() ctype = 0 item = m.mock(TextDocument if c.item_type == "d" else Project) for e in range(c.eds): ed = m.mock(Editor) ed.item_changed(item, ctype) app.add_editor(ed) with m: app.item_changed(item, ctype)
def test_make_upload_job(self): """Make an upload_job.""" mocker = Mocker() # upload job uj = mocker.mock() expect(uj.id).result('uj_id') expect(uj.uploaded_bytes).result('uploaded_bytes') expect(uj.multipart_id).result('multipart_id') expect(uj.multipart_key).result('multipart_key') expect(uj.chunk_count).result('chunk_count') expect(uj.hash_context).result('hash_context') expect(uj.magic_hash_context).result('magic_hash_context') expect(uj.decompress_context).result('decompress_context') expect(uj.inflated_size).result('inflated_size') expect(uj.crc32).result('crc32') expect(uj.when_last_active).result('when_last_active') # user user = mocker.mock() self.dal._get_user = lambda *a: user expect( user.volume('volume_id').get_node('node_id').make_uploadjob( 'previous_hash', 'hash_value', 'crc32', 'inflated_size', 'deflated_size', multipart_key='multipart_key')).result(uj) with mocker: d = dict(user_id='user_id', volume_id='volume_id', node_id='node_id', previous_hash='previous_hash', hash_value='hash_value', crc32='crc32', inflated_size='inflated_size', deflated_size='deflated_size', multipart_key='multipart_key') result = self.dal.make_uploadjob(**d) should = dict(uploadjob_id='uj_id', uploaded_bytes='uploaded_bytes', multipart_id='multipart_id', multipart_key='multipart_key', chunk_count='chunk_count', hash_context='hash_context', magic_hash_context='magic_hash_context', decompress_context='decompress_context', inflated_size='inflated_size', crc32='crc32', when_last_active='when_last_active') self.assertEqual(result, should)
def test(command, attribute, value=None): m = Mocker() tv = m.mock(TextView) view = tv.doc_view >> m.mock(TextDocumentView) do = CommandTester(mod.set_variable, textview=tv) if isinstance(attribute, Exception): with assert_raises(type(attribute), msg=str(attribute)), m: do(command) else: setattr(view.props >> m.mock(), attribute, value) with m: do(command)
def test_get_node_ok(self): """Get a node.""" mocker = Mocker() # node node = mocker.mock() expect(node.id).result('node_id') expect(node.path).result('path') expect(node.name).result('name') expect(node.vol_id).result('volume_id') expect(node.parent_id).result('parent_id') expect(node.status).result(model.STATUS_LIVE) expect(node.generation).result('generation') expect(node.is_public).result(False) expect(node.content_hash).result('content_hash') expect(node.kind).result('File') expect(node.when_last_modified).result('last_modified') content = mocker.mock() expect(content.size).result('size') expect(content.crc32).result('crc32') expect(content.deflated_size).result('deflated_size') expect(content.storage_key).result('storage_key') expect(node.content).count(1).result(content) # user user = mocker.mock() self.dal._get_user = lambda *a: user expect( user.volume('volume_id').get_node('node_id', with_content=True)).result(node) with mocker: result = self.dal.get_node(user_id='user_id', node_id='node_id', volume_id='volume_id') should = dict(id='node_id', name='name', parent_id='parent_id', is_public=False, is_live=True, is_file=True, size='size', last_modified='last_modified', crc32='crc32', generation='generation', content_hash='content_hash', deflated_size='deflated_size', storage_key='storage_key', volume_id='volume_id', path='path', has_content=True) self.assertEqual(result, should)