def setUp(self):
self.mocker = mocker.Mocker()
self.lab_mock = self.mocker.mock()
self.locator = FakeLocator(lab=self.lab_mock)
self.db = FakeDatabase()
self.cfg_manager = ConfigurationManager.ConfigurationManager()
self.cfg_manager.append_module(configuration_module)
self.cfg_manager._set_value(
COORDINATOR_LABORATORY_SERVERS, {
'server:laboratoryserver@labmachine': {
'inst1|ud-dummy|Dummy experiments': 'res_inst@res_type'
}
})
self.commands_store = TemporalInformationStore.CommandsTemporalInformationStore(
)
self.coordinator = coordinator_create(SQLALCHEMY,
self.locator,
self.cfg_manager,
ConfirmerClass=FakeConfirmer)
self.coordinator._clean()
self.coordinator.add_experiment_instance_id(
"server:laboratoryserver@labmachine",
ExperimentInstanceId('inst', 'ud-dummy', 'Dummy experiments'),
Resource("res_type", "res_inst"))
self.processor = UserProcessor.UserProcessor(
self.locator,
{'db_session_id': ValidDatabaseSessionId('my_db_session_id')},
self.cfg_manager, self.coordinator, self.db, self.commands_store)
def test_ldap_user_right(self):
mockr = mocker.Mocker()
LoginAuth._ldap_provider.ldap_module = mockr.mock()
session_id = self.login_server.login(fake_ldap_user,
fake_ldap_passwd)
self.assertEquals(fake_ups_session_id, session_id)
def test_buffers_runtime_info(self):
"""Make sure we send the buffers size info."""
stats_worker = StatsWorker(self.service, 10)
# add some info the all the buffers we know
mock = mocker.Mocker()
producer = mock.mock()
upload.MultipartUploadFactory.buffers_size = 0
mp = upload.MultipartUploadFactory(None, producer, 1024, 2048, 0, 1042,
10)
mp.dataReceived('a' * 10)
client = mock.mock()
http_client.HTTPProducer.buffers_size = 0
http_prod = http_client.HTTPProducer(client)
self.addCleanup(http_prod.timeout_call.cancel)
http_prod.dataReceived('a' * 20)
producers.S3Producer.buffers_size = 0
s3_prod = producers.S3Producer(1024)
s3_prod.dataReceived('a' * 30)
stats_worker.runtime_info()
self.assertIn(('gauge', 'buffers_size.HTTPProducer', 20),
self.metrics.calls)
self.assertIn(('gauge', 'buffers_size.MultipartUploadFactory', 10),
self.metrics.calls)
self.assertIn(('gauge', 'buffers_size.S3Producer', 30),
self.metrics.calls)
def run(obj):
m = mocker.Mocker()
ob2 = object()
# part 1: replace method
if method_as_string:
args = (obj, "isEqualTo_")
else:
args = (obj.isEqualTo_, )
iseq = m.method(*args)
iseq(ob2) >> True
with m:
assert obj.isEqualTo_(ob2)
assert not obj.isEqualTo_(ob2), "%r == %r" % (obj, ob2)
# part 2: check if the original is called after test
func = iseq.replaced.func
try:
class Error(Exception):
pass
def error(self, arg):
assert self is obj, "%r != %r" % (self, obj)
assert arg is ob2, repr(arg)
raise Error("expected error")
iseq.replaced.func = error
assert_raises(Error, obj.isEqualTo_, ob2)
finally:
iseq.replaced.func = func
def setUp(self):
self.coord_address = CoordAddress.CoordAddress.translate_address( "server0:instance0@machine0" )
self.cfg_manager = ConfigurationManager.ConfigurationManager()
self.cfg_manager.append_module(configuration_module)
self.cfg_manager._set_value(CoordinationConfigurationParser.COORDINATOR_LABORATORY_SERVERS,
{ 'server:laboratoryserver@labmachine' : { 'inst|ud-dummy|Dummy experiments' : 'dummy1@dummy boards' } } )
self.mocker = mocker.Mocker()
self.lab_mock = self.mocker.mock()
self.locator = FakeLocator(self.lab_mock)
# Clean the database
coordinator = coordinator_create(SQLALCHEMY, self.locator, self.cfg_manager)
coordinator._clean()
coordinator.stop()
# External server generation
self.ups = WrappedUPS(
self.coord_address,
self.locator,
self.cfg_manager
)
self.ups._db_manager._gateway._delete_all_uses()
def test_ldap_user_right(self):
mockr = mocker.Mocker()
ldap_auth._ldap_provider.ldap_module = mockr.mock()
with wlcontext(self.core_server):
session_id = core_api.login(fake_ldap_user, fake_ldap_passwd)
self.assertTrue( isinstance(session_id, SessionId) )
self.assertTrue( len(session_id.id) > 5 )
def setUp(self):
self.app = app.test_client()
tag = TagCategory()
self.post = Post(title='Primeiro post',
text='<b>Nose test e fd</b>',
tags=tag.string_to_category('python, nose, tdd'))
self.post.put()
self.mocker = mocker.Mocker()
def setUp(self):
self.locator_mocker = mocker.Mocker()
self.locator = self.locator_mocker.mock()
self.coord_addr = CoordAddress.CoordAddress('server:instance@machine')
self.coord_addr2 = CoordAddress.CoordAddress(
'server2:instance@machine')
self.easy_locator = EasyLocator.EasyLocator(self.coord_addr,
self.locator)
def setUp(self):
self.mocker = mocker.Mocker()
self.onelog = Log(self.log_name)
onelogtrace = 'this is an info log trace'
anotherlogtrace = 'this is a debug log trace'
fh = open(self.log_name, 'w')
fh.write(onelogtrace + '\n')
fh.write(anotherlogtrace + '\n')
fh.close()
self.apicture = pjoin(TESTS_DIR, 'apicture.png')
def test_MockExt__lshift__():
def f(x):
return x.meth(), x.meth()
m = mocker.Mocker()
y = m.mock()
(y.meth() << 1).count(2)
with m:
result = f(y)
assert result == (1, 1), "unexpected: %r" % (result, )
def test_MockExt__rshift__():
def f(x):
return x.meth()
obj = object()
m = mocker.Mocker()
y = m.mock()
assert (y.meth() >> obj) is obj
with m:
result = f(y)
assert result is obj, "unexpected: %r" % (result, )
def test_ldap_user_invalid(self):
mockr = mocker.Mocker()
ldap_object = mockr.mock()
ldap_object.simple_bind_s(fake_ldap_user + '@cdk.deusto.es',
fake_ldap_invalid_passwd)
mockr.throw(ldap.INVALID_CREDENTIALS)
ldap_module = mockr.mock()
ldap_module.initialize('ldaps://castor.cdk.deusto.es')
mockr.result(ldap_object)
LoginAuth._ldap_provider.ldap_module = ldap_module
with mockr:
self.assertRaises(LoginErrors.InvalidCredentialsError,
self.login_server.login, fake_ldap_user,
fake_ldap_invalid_passwd)
def test(c):
m = mocker.Mocker()
obj = c.cls.alloc().init()
args = (obj,
c.name) if c.method_as_string else (getattr(obj, c.name), )
mocked = m.method(*args)
mocked(*range(c.targs))
try:
with m:
getattr(obj, c.name)(*range(c.targs))
except AssertionError:
if c.nargs == c.targs:
raise # unexpected error (had correct number of arguments)
else:
assert c.nargs == c.targs, "wrong arg spec : expected MatchError"
def test_premio(self):
from django.utils import simplejson
m = mocker.Mocker()
obj = m.replace('random')
obj.randint(1, 200)
m.result(22)
k = {'movie_id': self.movie.id}
m.replay()
response = self.client.post(reverse('add_review', kwargs=k),
self.post_data)
self.assertEquals(response.status_code, 201)
self.assertEquals(self.movie.moviereview_set.count(), 1)
d = simplejson.loads(response.content)
self.assertTrue(d.has_key('premio'))
def __init__(self):
self.project = mocker.Mocker()
self.project.name = 'test_repo'
self.project.git_url = './test_repo'
self.project.version = '1.0'
self.project.branch = 'master'
self.project.last_tag = ''
self.project.last_commit = ''
self.project.build_cmd = 'python setup.py build'
self.project.install_cmd = 'python setup.py install --root=BUILDROOT'
self.project.replay()
self.git = Git(self.project,
workdir=os.path.join(os.path.dirname(__file__),
'workspace'))
if not os.path.isdir(self.git.workdir):
self.git.clone(self.project.branch)
def test(obj, method_as_string):
m = mocker.Mocker()
ob2 = object()
# part 1: replace method
func = obj.isEqualTo_.__func__
if method_as_string:
args = (obj, "isEqualTo_")
else:
args = (obj.isEqualTo_, )
iseq = m.method(*args)
iseq(ob2) >> True
with m:
assert obj.isEqualTo_(ob2)
assert not obj.isEqualTo_(ob2), "%r == %r" % (obj, ob2)
# part 2: verify that the replaced method is totally removed
def error(self, arg):
assert False, "this function should not be called"
iseq.replaced.func = error
assert not obj.isEqualTo_(ob2)
def setUp(self):
self.configurationManager = ConfigurationManager.ConfigurationManager()
self.configurationManager.append_module(configuration)
self.configurationManager._set_value(configuration_doc.FACADE_TIMEOUT,
0.01)
time.sleep(0.01 * 5)
self.configurationManager._set_value(
AdminFacadeServer.ADMIN_FACADE_JSON_LISTEN, '')
self.mocker = mocker.Mocker()
self.rfm_json = self.mocker.mock()
class WrappedRemoteFacadeServer(
AdminFacadeServer.AdminRemoteFacadeServer):
def _create_smartgwt_remote_facade_manager(inner_self, *args,
**kwargs):
return self.rfm_json
self.rfs = WrappedRemoteFacadeServer(None, self.configurationManager)
def setUp(self):
fh = open('out.log', 'w')
someLogTracesForOutLog = [
'fatal> something went wrong', 'error> not so wrong',
'warn> be careful', 'debug> looking behind the scenes',
'trace> more info than debug', 'info> the app is running',
'fatal> the app is in really bad state'
]
someLogTracesForOut2Log = [
'fatal> something went wrong', 'error> not so wrong',
'warn> be careful', 'debug> looking behind the scenes',
'trace> more info than debug', 'info> the app is running',
'fatal> the app is in really bad state'
]
fh2 = open('out2.log', 'w')
self.writer(fh, someLogTracesForOutLog)
self.writer(fh2, someLogTracesForOut2Log)
fh.close()
fh2.close()
self.mocker = mocker.Mocker()
def setUp(self):
sysoutback = sys.stdout
sys.stdout = MemoryWriter()
self.mocker = mocker.Mocker()
def setUp(self):
self.mockedFeedParserMakerMocker = mocker.Mocker()
self.mockedFeedParserMaker = self.mockedFeedParserMakerMocker.mock()
self.feedParserFactory = WrappedFeedParserFactory(
self.mockedFeedParserMaker)
self.initializeSystem(self.feedParserFactory)
def setUp(self):
self.message_mocker = mox.Mox()
self.options = Options()
self.options.inactivity = 1
self.log = Log('out.log', None, self.options)
self.mocker = mocker.Mocker()
def setUp(self):
self.mocker = mocker.Mocker()
self.SYSOUT = sys.stdout
sys.stdout = MemoryWriter()
def test_OMDGHelper(self):
"""
Test all methods of OMDGHelper view
"""
view1 = get_object(oid='reponse1',
ptype='dmsoutgoingmail').unrestrictedTraverse('@@document_generation_helper_view')
# Test fmt method
self.assertEqual(view1.fmt(None), '')
self.assertEqual(view1.fmt('Test'), 'Test ')
self.assertEqual(view1.fmt('Test', fmt='(%s)'), '(Test)')
# Test get_ctct_det method
self.assertDictEqual(view1.get_ctct_det(''), {})
det = {'address': {}, 'website': '', 'fax': '', 'phone': '', 'im_handle': '', 'cell_phone': '', 'email': ''}
self.assertDictEqual(view1.get_ctct_det(self.jc), det)
# get address from linked organization
det = {'address': {'city': u'E-ville', 'country': '', 'region': '', 'additional_address_details': '',
'number': u'1', 'street': u"Rue de l'électron", 'zip_code': u'0020'},
'im_handle': '', 'cell_phone': '', 'email': u'*****@*****.**', 'website': '', 'fax': '',
'phone': u'012345678'}
self.assertDictEqual(view1.get_ctct_det(self.jc['agent-electrabel']), det)
# Test get_sender method
sender = {'person': self.chef, 'hp': self.resp_grh, 'org_full_title': u'Direction générale - GRH',
'org': self.grh}
self.assertDictEqual(view1.get_sender(), sender)
backup = view1.real_context.sender
view1.real_context.sender = ''
self.assertDictEqual(view1.get_sender(), {})
view1.real_context.sender = backup
# Test mailing_list method
self.assertListEqual(view1.mailing_list(), [self.ctct['electrabel']])
view1.real_context.recipients.append(RelationValue(self.intids.getId(self.electrabel)))
self.assertListEqual(view1.mailing_list(), [self.ctct['electrabel'], self.electrabel])
backup = view1.real_context.recipients[0]
view1.real_context.recipients = None
self.assertListEqual(view1.mailing_list(), [])
view1.real_context.recipients = [backup]
# Test get_full_title method
self.assertEqual(view1.get_full_title(None), '')
self.assertEqual(view1.get_full_title(self.electrabel), u'Electrabel')
self.assertEqual(view1.get_full_title(self.grh), u'Mon organisation / Direction générale / GRH')
self.assertEqual(view1.get_full_title(self.grh, separator=' - ', first_index=1), u'Direction générale - GRH')
self.assertEqual(view1.get_full_title(self.jc), u'Monsieur Jean Courant')
self.assertEqual(view1.get_full_title(self.agent), u'Monsieur Jean Courant, Agent (Electrabel)')
# Test get_separate_titles method
self.assertListEqual(view1.get_separate_titles(None), [u'', u''])
self.assertListEqual(view1.get_separate_titles(self.electrabel), [u'Electrabel', u''])
self.assertListEqual(view1.get_separate_titles(self.grh), [u'Mon organisation / Direction générale / GRH', ''])
self.assertListEqual(view1.get_separate_titles(self.grh, separator=' - ', first_index=1),
[u'Direction générale - GRH', ''])
self.assertListEqual(view1.get_separate_titles(self.jc), ['', u'Monsieur Jean Courant'])
self.assertListEqual(view1.get_separate_titles(self.agent), [u'Electrabel', u'Monsieur Jean Courant'])
self.assertListEqual(view1.get_separate_titles(self.resp_grh),
[u'Mon organisation / Direction générale / GRH', u'Monsieur Michel Chef'])
# Test person_title
self.assertEqual(view1.person_title(None), '')
self.assertEqual(view1.person_title(self.jc), u'Monsieur')
self.assertEqual(view1.person_title(self.jc, with_name=True), u'Monsieur Courant')
self.assertEqual(view1.person_title(self.jc, with_name=True, upper_name=True), u'Monsieur COURANT')
self.jc.person_title = None
self.assertEqual(view1.person_title(self.jc), u'Monsieur')
self.assertEqual(view1.person_title(self.jc, pers_dft=u'Madame'), u'Madame')
self.assertEqual(view1.person_title(self.jc, pers_dft=u'Madame', with_name=True), u'Madame Courant')
self.assertEqual(view1.person_title(self.jc, pers_dft=u'Madame', with_name=True, upper_name=True),
u'Madame COURANT')
self.assertEqual(view1.person_title(self.electrabel), u'Madame, Monsieur')
self.assertEqual(view1.person_title(self.electrabel, org_dft=u'Messieurs'), u'Messieurs')
self.assertEqual(view1.person_title(self.agent), u'Monsieur')
self.assertEqual(view1.person_title(self.agent, with_name=True), u'Monsieur Courant')
self.assertEqual(view1.person_title(self.agent, with_name=True, upper_name=True), u'Monsieur COURANT')
# Test is_first_doc
mock = mocker.Mocker()
res = {}
view1.appy_renderer = mock.mock()
mocker.expect(view1.appy_renderer.contentParser.env.context).result(res).replay()
self.assertTrue(view1.is_first_doc())
mock2 = mocker.Mocker()
res['loop'] = mock2.mock()
mocker.expect(res['loop'].mailed_data.first).result(False).replay()
mock.replay()
self.assertFalse(view1.is_first_doc())
# Test separate_full_title
self.assertListEqual(view1.separate_full_title(None), [u'', u''])
self.assertListEqual(view1.separate_full_title(u''), [u'', u''])
self.assertListEqual(view1.separate_full_title(u'Direction générale'),
[u'Direction générale', u''])
self.assertListEqual(view1.separate_full_title(u'Direction générale - Secrétariat'),
[u'Direction générale', u'Secrétariat'])
self.assertListEqual(view1.separate_full_title(u'Direction générale - Secrétariat - Michèle'),
[u'Direction générale', u'Secrétariat - Michèle'])
self.assertListEqual(view1.separate_full_title(u'Direction générale - Secrétariat - Michèle', nb=3),
[u'Direction générale', u'Secrétariat', u'Michèle'])
self.assertRaises(IndexError, view1.separate_full_title, u'Direction', nb=0)
def setUp(self):
self.overlay = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.overlay)
self.mocker = mocker.Mocker()
def setUp(self):
self.mocker = mocker.Mocker()
self.user = self.mocker.mock()
self.b1 = bbcode.BbCode(self.user)
def setUp(self):
self.mocker = mocker.Mocker()
class Test(object):
pass
def func(arg):
pass
t = Test()
t.func = func
m = MockerExt()
m.replace(t, "func")(*args)
def check(err):
assert msg in str(err), "{!r} not in {!r}".format(msg, err)
with m, assert_raises(AssertionError, msg=check):
t.func(*args)
yield test, (1, 2), "Specification is func(arg): too many args provided"
yield test, (), "Specification is func(arg): 'arg' not provided"
if __name__ == "__main__":
test_MockExt__lshift__()
test_MockExt__rshift__()
test_MockExt_property()
m = mocker.Mocker()
t = m.mock(object)
print(t)
print(t.y())
