def test_result_is_cached(self):
viewlet = self.get_viewlet()
viewlet.update()
self.assertNotIn('purple', viewlet.generate_css(),
'Unexpectedly found "purple" in the CSS')
# Setting a custom style automatically invalidates the cache.
# For testing that things are cached, we stub the cache invalidation,
# so that the cache persists.
mocker = Mocker()
invalidate_cache_mock = mocker.replace(invalidate_cache)
expect(invalidate_cache_mock()).count(1, None)
mocker.replay()
ICustomStyles(self.layer['portal']).set('css.body-background', 'purple')
self.assertNotIn('purple', viewlet.generate_css(),
'The result was not cached.')
# Removing the stub and invalidating the cache should update the result.
mocker.restore()
mocker.verify()
invalidate_cache()
self.assertIn('purple', viewlet.generate_css(),
'Expected "purple" in CSS - does the style'
' css.body-background no longer work?')
def should_build_objects_with_dependencies_from_factories(self):
factory = self.mockery.mock()
expect(factory(arg_of_type(no_deps))).result(12345)
with self.mockery:
self.assembler.register(int, requires=[no_deps], factory=factory)
instance = self.assembler.provide(int)
assert instance == 12345
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_informed_metrics(self):
"""Check how stats are reported."""
# prepare a lot of fake info that will be "collected"
machine_info = dict(foo=3, bar=5)
process_info = {
1: dict(some=1234, other=4567),
2: dict(some=9876, other=6543),
}
self.worker._collect_process = lambda pid, name: process_info[pid]
self.worker._collect_machine = lambda: machine_info
processes = [
dict(name="proc1", group="", pid="1", state=RUNNING),
dict(name="proc2", group="", pid="2", state=RUNNING),
]
expect(self.rpc.supervisor.getAllProcessInfo()).result(processes)
# patch the metric reporter to see what is sent
reported = set()
self.worker.metrics.gauge = lambda *a: reported.add(a)
# what we should get is...
should = set([
('foo', 3),
('bar', 5),
('some', 1234),
('other', 4567),
('some', 9876),
('other', 6543),
])
with self.mocker:
self.worker.collect_stats()
self.assertEqual(reported, should)
def test_connecting_gets_new_cursor(self):
expect(self.mock_driver.connect()).result(self.mock_conn)
self.mock_conn.cursor()
self.mocker.replay()
conn = db.Connection(driver=self.mock_driver)
conn.connect()
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 do(m, c, fc, sender):
beep = m.replace(ak, 'NSBeep')
dobeep = True
tv = m.replace(fc.finder, 'find_target')() >> (m.mock(TextView) if c.has_tv else None)
if c.has_tv:
options = m.replace(fc.finder, "options")
rtext = options.replace_text >> "abc"
options.regular_expression >> c.regex
FoundRange = make_found_range_factory(FindOptions(regular_expression=False))
if c.regex:
if c.rfr:
tv._Finder__recently_found_range >> FoundRange(None)
elif c.rfr is None:
expect(tv._Finder__recently_found_range).throw(AttributeError)
else:
tv._Finder__recently_found_range >> None
range = tv.selectedRange() >> m.mock()
tv.shouldChangeTextInRange_replacementString_(range, rtext) >> c.act
if c.act:
tv.textStorage().replaceCharactersInRange_withString_(range, rtext)
tv.didChangeText()
tv.setNeedsDisplay_(True)
dobeep = False
if dobeep:
beep()
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_deserialize_failure_leaves_trace(self):
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False)).throw(Exception("boom"))
self.mocker.replay()
self.bundle.deserialize(False)
self.assertFalse(self.bundle.is_deserialized)
self.assertEqual(self.bundle.deserialization_error.error_message, "boom")
def __enter__(self):
if type(self.new_now) != datetime:
raise ValueError(
'The freeze_date argument must be a datetime.datetime'
' instance, got %s' % type(self.new_now).__name__)
self.mocker = Mocker()
# Replace "datetime.datetime.now" classmethod
self._previous_datetime_now = datetime.now
@classmethod
def freezed_now(klass, tz=None):
if not tz:
return self.new_now.replace(tzinfo=None)
elif self.new_now.tzinfo != tz:
return tz.normalize(self.new_now.astimezone(tz))
else:
return self.new_now
curse(datetime, 'now', freezed_now)
# Replace "time.time" function
new_time = (calendar.timegm(self.new_now.timetuple()) +
(self.new_now.timetuple().tm_isdst * 60 * 60) +
(self.new_now.microsecond * 0.000001))
time_class = self.mocker.replace('time.time')
expect(time_class()).call(lambda: new_time).count(0, None)
self.mocker.replay()
return self
def set_parent(self, context, parent_context):
"""Set the acquisition parent of `context` to `parent_context`.
"""
self._check_super_setup()
expect(aq_parent(aq_inner(context))).result(parent_context).count(
0, None)
return context
def test(c):
m = Mocker()
options = make_options(c)
tv = m.mock(TextView)
tv.selectedRange() >> fn.NSMakeRange(0, 16)
tv.string() >> fn.NSString.alloc().initWithString_(c.text)
if not isinstance(c.expect, Exception):
result = [c.text]
def replace(range, value):
start, end = range
text = result[0]
result[0] = text[:start] + value + text[start + end:]
tv.shouldChangeTextInRange_replacementString_(ANY, ANY) >> True
expect(tv.textStorage().replaceCharactersInRange_withString_(
ANY, ANY)).call(replace)
tv.didChangeText()
tv.setNeedsDisplay_(True)
finder = Finder((lambda: tv), options)
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)
eq_(result[0], c.expect)
def test_valid_login(self):
authenticator = self.mocker.mock()
request = self.mocker.mock()
expect(authenticator.authenticate(request)).result(True)
with self.mocker:
self.assertEqual(
None, HttpDigestMiddleware(authenticator=authenticator).process_request(request))
def do(m, c, fc, sender):
beep = m.replace(ak, 'NSBeep')
dobeep = True
tv = m.replace(fc.finder, 'find_target')() >> (m.mock(TextView)
if c.has_tv else None)
if c.has_tv:
options = m.replace(fc.finder, "options")
rtext = options.replace_text >> "abc"
options.regular_expression >> c.regex
FoundRange = make_found_range_factory(
FindOptions(regular_expression=False))
if c.regex:
if c.rfr:
tv._Finder__recently_found_range >> FoundRange(None)
elif c.rfr is None:
expect(
tv._Finder__recently_found_range).throw(AttributeError)
else:
tv._Finder__recently_found_range >> None
range = tv.selectedRange() >> m.mock()
tv.shouldChangeTextInRange_replacementString_(range,
rtext) >> c.act
if c.act:
tv.textStorage().replaceCharactersInRange_withString_(
range, rtext)
tv.didChangeText()
tv.setNeedsDisplay_(True)
dobeep = False
if dobeep:
beep()
def set_parent(self, context, parent_context):
"""Set the acquisition parent of `context` to `parent_context`.
"""
self._check_super_setup()
expect(aq_parent(aq_inner(context))).result(
parent_context).count(0, None)
return context
def should_build_objects_with_dependencies_from_factories(self):
factory = self.mockery.mock()
expect(factory(arg_of_type(no_deps))).result(12345)
with self.mockery:
self.assembler.register(int, requires=[no_deps], factory=factory)
instance = self.assembler.provide(int)
assert instance == 12345
def test_check_processes(self):
"""Test the check_processes method."""
# add the fake process to the process list
self.processes.append(
dict(name="foo", group="foo", pid="42", state=RUNNING))
self.processes.append(
dict(name="bar", group="bar", pid="43", state=RUNNING))
self.listener.processes = ['bar']
# 2 process to restart
self.listener.data['foo'] = {
'time': time.time() - (self.listener.timeout + 2)
}
self.listener.data['bar'] = {
'time': time.time() - (self.listener.timeout + 3)
}
self.listener.data['p-1'] = {
'time': time.time() - (self.listener.timeout - 1)
}
expect(self.rpc.supervisor.getAllProcessInfo()).result(self.processes)
expect(self.rpc.supervisor.stopProcess("foo:"))
expect(self.rpc.supervisor.startProcess("foo:"))
expect(self.rpc.supervisor.stopProcess("bar:bar"))
expect(self.rpc.supervisor.startProcess("bar:bar"))
with self.mocker:
self.listener.check_processes()
def test_check_processes_not_running(self):
"""Test the check_processes method if the proccess isn't running."""
# add the fake process to the process list
self.processes.append(
dict(name="foo",
group="foo",
pid="42",
state=states.ProcessStates.STARTING))
# add a new tracked process from an untracked group
self.processes.append(
dict(name="bar",
group="bar",
pid="43",
state=states.ProcessStates.STARTING))
self.listener.processes = ['bar']
# 2 processes to restart
self.listener.data['foo'] = {
'time': time.time() - (self.listener.timeout + 2)
}
self.listener.data['bar'] = {
'time': time.time() - (self.listener.timeout + 2)
}
expect(self.rpc.supervisor.getAllProcessInfo()).result(self.processes)
with self.mocker:
self.listener.check_processes()
self.assertTrue(
self.handler.check_info("Ignoring foo:foo (42) as isn't running."))
self.assertTrue(
self.handler.check_info("Ignoring bar:bar (43) as isn't running."))
def test_closeAllDocumentsWithDelegate_didCloseAllSelector_contextInfo_():
context = 42
dc = NSDocumentController.sharedDocumentController()
m = Mocker()
app = m.replace("editxt.app", type=Application)
perf_sel = m.replace("editxt.util.perform_selector", passthrough=False)
dsd_class = m.replace("editxt.application.DocumentSavingDelegate",
spec=False, passthrough=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_
expect(perf_sel(delegate, selector, dc, "<result>", context)).call(
lambda *a:should_term(dc, "<result>", 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 m:
dc.closeAllDocumentsWithDelegate_didCloseAllSelector_contextInfo_(
delegate, selector, context)
def test_user_registration_executes_query_on_db(self):
conn = db.Connection()
mock_connection = self.mocker.patch(conn)
expect(mock_connection.execute(mocker.ARGS)).count(1, None)
self.mocker.replay()
register_user('*****@*****.**', 'password', mock_connection)
def test_authenticate_non_existent_email_raises(self):
mock_conn = self.mocker.mock()
expect(mock_conn.get_user('*****@*****.**')).result(None)
self.mocker.replay()
self.assertRaises(AuthenticationError, authenticate,
'*****@*****.**', 'password', mock_conn)
def test(c):
opts = SortOptions(
**{opt: c.opts[abbr]
for abbr, opt in optmap if abbr in c.opts})
m = Mocker()
tv = m.mock(TextView)
ts = tv.textStorage() >> m.mock(ak.NSTextStorage)
text = tv.string() >> fn.NSString.stringWithString_(c.text)
if opts.selection:
sel = tv.selectedRange() >> c.sel
sel = text.lineRangeForRange_(sel)
else:
sel = c.sel
tv.shouldChangeTextInRange_replacementString_(sel, ANY) >> True
output = []
def callback(range, text):
output.append(text)
expect(ts.replaceCharactersInRange_withString_(sel,
ANY)).call(callback)
tv.didChangeText()
if opts.selection:
tv.setSelectedRange_(sel)
with m:
sortlines(tv, opts)
eq_(sort_result(output[0]), c.result, output[0])
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(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(app, path, prompt=False):
prompt = (True,) if prompt else ()
initial_content = None if "missing" in path else "initial"
with make_file(path, content=initial_content) as real_path:
m = Mocker()
window = app.windows[0]
editor = window.projects[0].editors[0]
document = editor.document
save_document_as = m.method(window.save_document_as)
prompt_to_overwrite = m.method(window.prompt_to_overwrite)
has_path_changed = m.method(document.file_changed_since_save)
if os.path.isabs(path):
document.file_path = path = real_path
elif path:
document.file_path = path
document.text = "saved text"
def save_prompt(document, callback):
if "nodir" in path:
os.mkdir(os.path.dirname(real_path))
print("saving as", real_path)
callback(real_path)
if prompt or path != real_path or "nodir" in path or "missing" in path:
expect(save_document_as(editor, ANY)).call(save_prompt)
elif has_path_changed() >> ("moved" in path):
expect(prompt_to_overwrite(editor, ANY)).call(save_prompt)
calls = []
def callback(saved):
calls.append(saved)
with m:
editor.save(*prompt, callback=callback)
eq_(get_content(real_path), "saved text")
eq_(calls, [True])
def test_activate_with_non_existent_key_raises(self):
mock_conn = self.mocker.mock()
expect(mock_conn.get_pending_user_by_key(mocker.ANY)).result([])
self.mocker.replay()
self.assertRaises(InvalidRegistrationKeyError,
activate, 'some key', mock_conn)
def test(c):
opts = TestConfig(
sort_selection=c.opts._get("sel", False),
reverse_sort=c.opts._get("rev", False),
ignore_leading_ws=c.opts._get("ign", False),
numeric_match=c.opts._get("num", False),
regex_sort=c.opts._get("reg", False),
search_pattern=c.opts._get("sch", ""),
match_pattern=c.opts._get("mch", ""),
)
m = Mocker()
tv = m.mock(TextView)
ts = tv.textStorage() >> m.mock(NSTextStorage)
text = tv.string() >> NSString.stringWithString_(c.text)
if opts.sort_selection:
sel = tv.selectedRange() >> c.sel
sel = text.lineRangeForRange_(sel)
else:
sel = c.sel
tv.shouldChangeTextInRange_replacementString_(sel, ANY) >> True
output = []
def callback(range, text):
output.append(text)
expect(ts.replaceCharactersInRange_withString_(sel, ANY)).call(callback)
tv.didChangeText()
if opts.sort_selection:
tv.setSelectedRange_(sel)
with m:
sortlines(tv, opts)
def ch(line):
value = line.lstrip(" ")
return value[0] if value else "|%i" % len(line)
eq_(c.result, "".join(ch(line) for line in output[0].split("\n")), output[0])
def test_result_is_cached(self):
view = self.get_view()
self.assertNotIn('purple', view.generate_css(),
'Unexpectedly found "purple" in the CSS')
# Setting a custom style automatically invalidates the cache.
# For testing that things are cached, we stub the cache invalidation,
# so that the cache persists.
mocker = Mocker()
invalidate_cache_mock = mocker.replace(invalidate_cache)
expect(invalidate_cache_mock()).count(1, None)
mocker.replay()
ICustomStyles(self.layer['portal']).set('css.body-background',
'purple')
self.assertNotIn('purple', view.generate_css(),
'The result was not cached.')
# Removing the stub and invalidating the cache should update the result.
mocker.restore()
mocker.verify()
invalidate_cache()
self.assertIn(
'purple', view.generate_css(),
'Expected "purple" in CSS - does the style'
' css.body-background no longer work?')
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 __rshift__(self, value, act=False):
"""syntax sugar for more concise expect/result expression syntax
old: expect(mock.func(arg)).result(value)
new: mock.func(arg) >> value
This variation has a subtle difference from the 'sour' code above as
well as the << operator. It returns 'value' rather than the expect
object, which allows us to construct expressions while "injecing"
return values into sub-expressions. For example:
(mock.func(arg) >> value).value_func()
Equivalent to:
expect(mock.func(arg)).result(value)
value.value_func()
Note: to mock a real right-shift operation use the following code in
your test case:
mock.func(arg).__rshift__(value, act=True)
"""
if self.__mocker__.is_recording() and not act:
mocker.expect(self).result(value)
return value
return self.__mocker_act__("__rshift__", (value,))
def test_informed_metrics(self):
"""Check how stats are reported."""
# prepare a lot of fake info that will be "collected"
machine_info = dict(foo=3, bar=5)
process_info = {
1: dict(some=1234, other=4567),
2: dict(some=9876, other=6543),
}
self.worker._collect_process = lambda pid, name: process_info[pid]
self.worker._collect_machine = lambda: machine_info
processes = [
dict(name="proc1", group="", pid="1", state=RUNNING),
dict(name="proc2", group="", pid="2", state=RUNNING),
]
expect(self.rpc.supervisor.getAllProcessInfo()).result(processes)
# patch the metric reporter to see what is sent
reported = set()
self.worker.metrics.gauge = lambda *a: reported.add(a)
# what we should get is...
should = set([
('foo', 3),
('bar', 5),
('some', 1234),
('other', 4567),
('some', 9876),
('other', 6543),
])
with self.mocker:
self.worker.collect_stats()
self.assertEqual(reported, should)
def test_fetching_data_retry_on_ConnectionError(self):
from scieloapi.exceptions import ConnectionError
mock_httpbroker = self.mocker.proxy(httpbroker)
mocker.expect(mock_httpbroker.post).passthrough()
mock_httpbroker.get('http://manager.scielo.org/api/v1/',
endpoint='journals',
params={},
resource_id=1,
check_ca=mocker.ANY,
auth=('any.username', 'any.apikey'))
self.mocker.throw(ConnectionError)
mock_httpbroker.get('http://manager.scielo.org/api/v1/',
endpoint='journals',
params={},
resource_id=1,
check_ca=mocker.ANY,
auth=('any.username', 'any.apikey'))
self.mocker.result(self.valid_microset)
self.mocker.replay()
conn = self._makeOne('any.username', 'any.apikey', http_broker=mock_httpbroker)
res = conn.fetch_data('journals', resource_id=1)
self.assertIn('title', res)
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_unlink_node(self):
"""Unlink a node."""
mocker = Mocker()
# node, with a generation attribute
node = mocker.mock()
expect(node.generation).result(123)
expect(node.kind).result('File')
expect(node.name).result('foo')
expect(node.mimetype).result('mime')
# user, with the chained calls to the delete
user = mocker.mock()
expect(user.volume('vol_id').node('node_id').delete()).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',
session_id='session_id')
result = self.dal.unlink_node(**kwargs)
d = dict(generation=123, kind='File', name='foo', mimetype='mime')
self.assertEqual(result, d)
def test(c):
m = Mocker()
options = make_options(c)
tv = m.mock(TextView)
tv.selectedRange() >> fn.NSMakeRange(0, 16)
tv.string() >> fn.NSString.alloc().initWithString_(c.text)
if not isinstance(c.expect, Exception):
result = [c.text]
def replace(range, value):
start, end = range
text = result[0]
result[0] = text[:start] + value + text[start + end:]
tv.shouldChangeTextInRange_replacementString_(ANY, ANY) >> True
expect(tv.textStorage().replaceCharactersInRange_withString_(
ANY, ANY)).call(replace)
tv.didChangeText()
tv.setNeedsDisplay_(True)
finder = Finder((lambda: tv), options)
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)
eq_(result[0], c.expect)
def test_valid_login(self):
authenticator = self.mocker.mock()
request = self.mocker.mock()
expect(authenticator.authenticate(request)).result(True)
with self.mocker:
self.assertEqual(
None, HttpDigestMiddleware(authenticator=authenticator).process_request(request))
def test_deserialize_failure_leaves_trace(self):
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False)).throw(Exception("boom"))
self.mocker.replay()
self.bundle.deserialize(False)
self.assertFalse(self.bundle.is_deserialized)
self.assertEqual(self.bundle.deserialization_error.error_message, "boom")
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(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_no_login_and_not_required(self):
authenticator = self.mocker.mock()
request = self.mocker.mock()
expect(authenticator.authenticate(request)).result(False)
expect(authenticator.contains_digest_credentials(request)).result(False)
with self.mocker:
self.assertEqual(
None, HttpDigestMiddleware(authenticator=authenticator).process_request(request))
def test_template_context_does_not_have_RequestContext_things(self):
mocker = Mocker()
report = mocker.patch(DataReport())
expect(report._get_raw_html()).result("{{MEDIA_URL}}")
with mocker:
observed = report.get_html()
expected = ""
self.assertEqual(observed, expected)
def test_template_context_has_API_URL(self):
mocker = Mocker()
report = mocker.patch(DataReport())
expect(report._get_raw_html()).result("{{API_URL}}")
with mocker:
observed = report.get_html()
expected = '/RPC2'
self.assertEqual(observed, expected)
def test_template_context_does_not_have_RequestContext_things(self):
mocker = Mocker()
report = mocker.patch(DataReport())
expect(report._get_raw_html()).result("{{MEDIA_URL}}")
with mocker:
observed = report.get_html()
expected = ""
self.assertEqual(observed, expected)
def test_template_context_has_API_URL(self):
mocker = Mocker()
report = mocker.patch(DataReport())
expect(report._get_raw_html()).result("{{API_URL}}")
with mocker:
observed = report.get_html()
expected = '/RPC2'
self.assertEqual(observed, expected)
def test_no_login_and_not_required(self):
authenticator = self.mocker.mock()
request = self.mocker.mock()
expect(authenticator.authenticate(request)).result(False)
expect(authenticator.contains_digest_credentials(request)).result(False)
with self.mocker:
self.assertEqual(
None, HttpDigestMiddleware(authenticator=authenticator).process_request(request))
def test_db_queries_on_unsupported_paramstyle_raises(self):
mock_driver = self.mocker.mock()
expect(mock_driver.paramstyle).result('pyformat').count(1, None)
self.mocker.replay()
conn = db.Connection(driver=mock_driver)
self.assertRaises(UnsupportedParamStyle,
conn.get_user, '*****@*****.**')
def test_restart(self):
"""Test the restart method."""
expect(self.rpc.supervisor.stopProcess("foo"))
expect(self.rpc.supervisor.startProcess("foo"))
with self.mocker:
self.listener.restart("foo", "testing")
self.assertTrue(self.handler.check_info("Restarting foo (last "
"hearbeat: testing)"))
def test_new_volume_generation_not_connected(self):
"""Test new volume generation delivery for a not connected user."""
expect(self.content.get_user_by_id('user_id')
).count(1).result(succeed(None))
# test
self.mocker.replay()
notif = VolumeNewGeneration('user_id', 'vol_id', 23)
yield self.factory.deliver_volume_new_generation(notif)
def test_restart(self):
"""Test the restart method."""
expect(self.rpc.supervisor.stopProcess("foo"))
expect(self.rpc.supervisor.startProcess("foo"))
with self.mocker:
self.listener.restart("foo", "testing")
self.assertTrue(
self.handler.check_info("Restarting foo (last "
"hearbeat: testing)"))
def test_new_volume_generation_not_connected(self):
"""Test new volume generation delivery for a not connected user."""
expect(self.content.get_user_by_id('user_id')).count(1).result(
succeed(None))
# test
self.mocker.replay()
notif = VolumeNewGeneration('user_id', 'vol_id', 23)
yield self.factory.deliver_volume_new_generation(notif)
def testSetUp(self):
self['pypi'] = {'foo': '2', 'bar': '2'}
self['mocker'] = mocker = Mocker()
fetcher = mocker.replace(
'ftw.recipe.checkversions.pypi.get_newest_release')
expect(fetcher(ANY)).call(self.fetcher).count(0, None)
expect(fetcher(ANY, index=ANY)).call(self.fetcher).count(0, None)
mocker.replay()
def testValueUnchanged(self):
v = trellis.Value(42)
ctrl = self.mocker.replace(self.ctrl)
ctrl.lock(v)
mocker.expect(ctrl.changed(v)).count(0)
self.mocker.replay()
trellis.install_controller(ctrl)
v.value = 42
self.assertEqual(v.value, 42)
def test_process_response_404(self):
authenticator = self.mocker.mock(count=False)
request = self.mocker.mock()
response = self.mocker.mock(count=False)
expect(response.status_code).result(404)
with self.mocker:
self.assertEqual(
response,
HttpDigestMiddleware(authenticator=authenticator).process_response(
request, response))
def test_new_volume_generation_ok(self):
"""Test new volume generation delivery ok."""
user = self.mocker.mock()
expect(self.content.get_user_by_id('user_id')).count(1).result(
succeed(user))
expect(user.broadcast).count(1).result(lambda *a, **kw: None)
# test
self.mocker.replay()
notif = VolumeNewGeneration('user_id', 'vol_id', 23)
yield self.factory.deliver_volume_new_generation(notif)
def test_collect_stats_no_data(self):
"""Test the collect_stats method with no data of a process."""
called = []
self.worker._collect_process = \
lambda p, n: called.append(('proc', p, n)) or {}
self.worker._collect_machine = lambda: called.append('machine') or {}
expect(self.rpc.supervisor.getAllProcessInfo()).result([])
with self.mocker:
self.worker.collect_stats()
self.assertEqual(called, ['machine'])
self.assertTrue(self.handler.check_info("Collecting machine stats"))
def test(c):
m = Mocker()
nh = NoHighlight("Test", "")
setcolor = m.mock()
def check(x, arg, y, z):
assert isinstance(arg, fn.NSRange), "wrong value: %r" % (arg,)
eq_(arg, fn.NSRange(len(c.value) - 1, 0))
if c.offset == 0:
expect(setcolor(None, ANY, 0, None)).call(check)
with m:
nh.scan(c.value, setcolor, c.offset)
def test_check_interval(self):
"""Check that we properly check on the specified interval."""
header = "ver:3.0 server:supervisor serial:1 pool:heartbeat " + \
"poolserial:1 eventname:TICK_5 len:0\n"
expect(self.rpc.supervisor.getAllProcessInfo()).result([])
self.stdin.write(header)
self.stdin.seek(0)
self.listener._handle_event()
self.assertEqual(self.listener.tick_count, 1)
self.stdin.seek(0)
with self.mocker:
self.listener._handle_event()
def test(c):
m = Mocker()
sf = SyntaxFactory()
log = m.replace("editxt.syntax.log")
glob = m.replace("glob.glob")
exists = m.replace("os.path.exists")
load = sf.load_definition = m.mock()
if c.path and exists(c.path) >> c.exists:
info = {
"disabled": dict(name="dis", disabled=True, filepatterns=[]), # should cause info log
# these should cause error log
"incomplete1": {},
"incomplete2": dict(name="none"),
"incomplete3": dict(filepatterns=[]),
# should only register twice despite duplication
"python": dict(name="python", filepatterns=["*.py", "*.py", "*.pyw"]),
"sql": dict(name="sequel", filepatterns=["*.sql"]),
"text": dict(name="text", filepatterns=["*.txt"]),
"text2": dict(name="text", filepatterns=["*.txt", "*.text"]),
"text3": dict(name="text", disabled=True, filepatterns=["*.txt", "*.text"]),
}
glob(os.path.join(c.path, "*" + const.SYNTAX_DEF_EXTENSION)) >> sorted(info)
def do(name):
data = dict(info[name])
if name.startswith("incomplete"):
raise Exception("incomplete definition: %r" % (data,))
data.setdefault("disabled", False)
if "filepatterns" in data:
data["filepatterns"] = set(data["filepatterns"])
return type("sdef", (object,), data)()
expect(load(ANY)).count(len(info)).call(do)
for fname, data in sorted(info.items()):
if fname.startswith("incomplete"):
log.error(ANY, fname, exc_info=True)
else:
pats = ", ".join(sorted(set(data.get("filepatterns", []))))
stat = [data["name"], "[%s]" % pats]
if fname in ("text", "text2", "text4"):
stat.extend(["overrides", "*.txt"])
elif fname in ("disabled", "text3"):
stat.append("DISABLED")
stat.append(fname)
log.info(ANY, " ".join(stat))
patterns = set(["*.py", "*.pyw", "*.sql", "*.text", "*.txt"])
else:
patterns = set(["*.txt"])
with m:
sf.load_definitions(c.path)
eq_(set(sf.registry), patterns)
def test_get_connection_with_sandbox(self):
"""
Test for DataView.get_connection()
"""
# Mock connections['dataview'] to return special connection
mocker = Mocker()
connections = mocker.replace("django.db.connections")
special_connection = mocker.mock()
expect(connections['dataview']).result(special_connection)
with mocker:
observed = DataView.get_connection()
expected = special_connection
self.assertIs(observed, expected)
def test(c):
m = Mocker()
app = Application()
ed = m.mock(Editor)
if c.ed_in_eds:
app.editors.append(ed)
def verify():
assert ed not in app.editors, "ed cannot be in app.editors at this point"
expect(ed.close()).call(verify)
with m:
app.discard_editor(ed)
