def test_usersclient_send_update_info(self):
encrypted = users.encrypt("day")
def _fake_encrypt(passwd):
return encrypted
self.patch(users, "encrypt", _fake_encrypt)
d = runner.users_client(
dict(
master="a:9990",
username="******",
passwd="y",
op="update",
bb_username="******",
bb_password="******",
ids=None,
info=[{"identifier": "x", "svn": "x"}],
)
)
def check(_):
c = self.usersclient
self.assertEqual(
(c.master, c.port, c.username, c.passwd, c.op, c.bb_username, c.bb_password, c.ids, c.info),
("a", 9990, "x", "y", "update", "bud", encrypted, None, [{"identifier": "x", "svn": "x"}]),
)
d.addCallback(check)
return d
def test_usersclient_no_op(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990')))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_no_op(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990')))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_send_ids(self):
d = runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='get', ids=['me', 'you'],
info=None))
def check(_):
c = self.usersclient
self.assertEqual((c.master, c.port, c.username, c.passwd, c.op,
c.ids, c.info),
('a', 9990, "x", "y", 'get', ['me', 'you'], None))
d.addCallback(check)
return d
def test_usersclient_send_ids(self):
d = runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='get', bb_username=None,
bb_password=None, ids=['me', 'you'],
info=None))
def check(_):
c = self.usersclient
self.assertEqual((c.master, c.port, c.username, c.passwd, c.op,
c.ids, c.info),
('a', 9990, "x", "y", 'get', ['me', 'you'], None))
d.addCallback(check)
return d
def test_usersclient_send_add_info(self):
d = runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add', ids=None,
info=[{'git':'x <h@c>'}]))
def check(_):
c = self.usersclient
self.assertEqual((c.master, c.port, c.username, c.passwd, c.op,
c.ids, c.info),
('a', 9990, "x", "y", 'add', None,
[{'identifier':'x <h@c>','git': 'x <h@c>'}]))
d.addCallback(check)
return d
def test_usersclient_update_and_ids(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='update', ids=['me'],
info=None)))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_update_no_identifier(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='update', ids=None,
info=[{'email':'x'}])))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(ValueError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_bad_attr_type(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add', ids=None,
info=[{'b':'y'}])))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(ValueError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_update_and_ids(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='update', ids=['me'],
info=None)))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_remove_get_and_info(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='remove', ids=None,
info=[{'email':'x'}])))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_bb_not_update(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", bb_username='******',
bb_password='******', op='add')))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_remove_get_and_info(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='remove', ids=None,
info=[{'email':'x'}])))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_update_no_identifier(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='update', ids=None,
info=[{'email':'x'}])))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(ValueError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_no_ids_no_info(self):
d = defer.maybeDeferred(lambda: runner.users_client(dict(master="a:9990", username="******", passwd="y", op="add")))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(AssertionError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_bad_attr_type(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add', ids=None,
info=[{'b':'y'}])))
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(ValueError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_send_add_info(self):
d = runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add', bb_username=None,
bb_password=None, ids=None,
info=[{'git':'x <h@c>'}]))
def check(_):
c = self.usersclient
self.assertEqual((c.master, c.port, c.username, c.passwd, c.op,
c.bb_username, c.bb_password, c.ids, c.info),
('a', 9990, "x", "y", 'add', None, None, None,
[{'identifier':'x <h@c>','git': 'x <h@c>'}]))
d.addCallback(check)
return d
def test_usersclient_add_existing_identifier(self):
d = defer.maybeDeferred(
lambda: runner.users_client(
dict(master="a:9990", username="******", passwd="y", op="add", ids=None, info=[{"identifier": "x"}])
)
)
def cb(_):
self.fail("shouldn't succeed")
def eb(f):
f.trap(ValueError)
pass # A-OK
d.addCallbacks(cb, eb)
return d
def test_usersclient_send_update_info(self):
encrypted = users.encrypt("day")
def _fake_encrypt(passwd):
return encrypted
self.patch(users, 'encrypt', _fake_encrypt)
d = runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='update', bb_username='******',
bb_password='******', ids=None,
info=[{'identifier':'x', 'svn':'x'}]))
def check(_):
c = self.usersclient
self.assertEqual((c.master, c.port, c.username, c.passwd, c.op,
c.bb_username, c.bb_password, c.ids, c.info),
('a', 9990, "x", "y", 'update', 'bud', encrypted,
None, [{'identifier':'x', 'svn':'x'}]))
d.addCallback(check)
return d
def test_usersclient_send_ids(self):
d = runner.users_client(
dict(
master="a:9990",
username="******",
passwd="y",
op="get",
bb_username=None,
bb_password=None,
ids=["me", "you"],
info=None,
)
)
def check(_):
c = self.usersclient
self.assertEqual(
(c.master, c.port, c.username, c.passwd, c.op, c.ids, c.info),
("a", 9990, "x", "y", "get", ["me", "you"], None),
)
d.addCallback(check)
return d
def test_usersclient_send_add_info(self):
d = runner.users_client(
dict(
master="a:9990",
username="******",
passwd="y",
op="add",
bb_username=None,
bb_password=None,
ids=None,
info=[{"git": "x <h@c>"}],
)
)
def check(_):
c = self.usersclient
self.assertEqual(
(c.master, c.port, c.username, c.passwd, c.op, c.bb_username, c.bb_password, c.ids, c.info),
("a", 9990, "x", "y", "add", None, None, None, [{"identifier": "x <h@c>", "git": "x <h@c>"}]),
)
d.addCallback(check)
return d
def test_usersclient_ids_and_info(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add', ids=['me'],
info=[{'full_name':'b'}])))
return self.assertFailure(d, AssertionError)
def test_usersclient_bad_attr_type(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add', ids=None,
info=[{'b':'y'}])))
return self.assertFailure(d, ValueError)
def test_usersclient_update_and_ids(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='update', ids=['me'],
info=None)))
return self.assertFailure(d, AssertionError)
def test_usersclient_no_username_password(self):
d = defer.maybeDeferred(
lambda : runner.users_client(dict(master='a:9990', op='add')))
return self.assertFailure(d, AssertionError)
def test_usersclient_no_ids_no_info(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add')))
return self.assertFailure(d, AssertionError)
def test_usersclient_add_existing_identifier(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='add', ids=None,
info=[{'identifier':'x'}])))
return self.assertFailure(d, ValueError)
def test_usersclient_bb_not_update(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", bb_username='******',
bb_password='******', op='add')))
return self.assertFailure(d, AssertionError)
def test_usersclient_no_master(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(op='add')))
return self.assertFailure(d, AssertionError)
def test_usersclient_remove_get_and_info(self):
d = defer.maybeDeferred(lambda :
runner.users_client(dict(master='a:9990', username="******",
passwd="y", op='remove', ids=None,
info=[{'email':'x'}])))
return self.assertFailure(d, AssertionError)
