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_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(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_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_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 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 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)
