def setUp(self):
self.mogilefs = Admin(TRACKERS)
try:
self.mogilefs.delete_class(DOMAIN, CLASS)
self.mogilefs.delete_domain(DOMAIN)
except:
pass
def test_get_server_settings():
moga = Admin(TRACKERS)
res = moga.server_settings()
assert res is not None
assert 'schema_version' in res
try:
version = int(res['schema_version'])
except:
assert False, "schema version must be an integer"
def test_delete_domain():
moga = Admin(TRACKERS)
try:
moga.delete_domain(DOMAIN)
except MogileFSError:
# domain does not exist
pass
else:
assert False, "the domain %s should not exist" % DOMAIN
assert moga.create_domain(DOMAIN)
assert moga.delete_domain(DOMAIN)
def test_get_devices():
moga = Admin(TRACKERS)
devices = moga.get_devices()
assert devices
for d in devices:
assert d.has_key('devid')
assert d.has_key('hostid')
assert d.has_key('status')
assert d.has_key('observed_state')
assert d.has_key('utilization')
assert d.has_key('mb_total')
assert d.has_key('mb_used')
assert d.has_key('weight')
def setUp(self):
self.mogilefs = Admin(TRACKERS)
try:
self.mogilefs.delete_class(DOMAIN, CLASS)
self.mogilefs.delete_domain(DOMAIN)
except:
pass
def test_create_host():
moga = Admin(TRACKERS)
try:
moga.create_host('testhost', '192.168.0.1', 7500)
moga.update_host('testhost', port=7501, status='alive')
finally:
moga.delete_host('testhost')
def test_get_domains():
moga = Admin(TRACKERS)
try:
moga.create_domain(DOMAIN)
moga.create_class(DOMAIN, CLASS, 2)
ret = moga.get_domains()
assert DOMAIN in ret
assert CLASS in ret[DOMAIN], ret
assert ret[DOMAIN][CLASS] == 2, ret
finally:
moga.delete_domain(DOMAIN)
def test_fsck_start():
moga = Admin(TRACKERS)
moga.fsck_start()
status = moga.fsck_status()
assert status['running'] == '1'
moga.fsck_stop()
status = moga.fsck_status()
assert status['running'] == '0'
def test_create_domain():
moga = Admin(TRACKERS)
moga.delete_domain(DOMAIN)
moga.create_domain(DOMAIN)
try:
moga.create_domain(DOMAIN)
except MogileFSError:
# domain exists
pass
else:
assert False, "the domain %s should exist" % DOMAIN
assert moga.delete_domain(DOMAIN)
def test_change_device_weight():
moga = Admin(TRACKERS)
## TODO
moga.change_device_weight('colinux', 1, 80)
moga.change_device_weight('colinux', 1, 100)
try:
moga.change_device_weight('colinux', 1, "SPAM")
except ValueError:
pass
else:
assert False, "ValueError expected for invalid weight"
def test_list_fids():
moga = Admin(TRACKERS)
moga.list_fids(1, 10)
def test_create_host():
moga = Admin(TRACKERS)
try:
moga.create_host('testhost', '192.168.0.1', 7500)
finally:
moga.delete_host('testhost')
class AdminTest(unittest.TestCase):
def setUp(self):
self.mogilefs = Admin(TRACKERS)
try:
self.mogilefs.delete_class(DOMAIN, CLASS)
self.mogilefs.delete_domain(DOMAIN)
except:
pass
def test_create_delete_domain(self):
self.assertEqual(self.mogilefs.delete_domain(DOMAIN), False)
self.assertEqual(self.mogilefs.create_domain(DOMAIN), True)
self.assertEqual(self.mogilefs.create_domain(DOMAIN), False)
self.assertEqual(self.mogilefs.delete_domain(DOMAIN), True)
def test_get_domains(self):
self.mogilefs.create_domain(DOMAIN)
self.mogilefs.create_class(DOMAIN, CLASS, 2)
ret = self.mogilefs.get_domains()
assert DOMAIN in ret
assert CLASS in ret[DOMAIN], ret
assert ret[DOMAIN][CLASS] == 2, ret
self.mogilefs.delete_domain(DOMAIN)
def test_create_delete_class(self):
self.assertEqual(self.mogilefs.create_domain(DOMAIN), True)
self.assertEqual(self.mogilefs.create_class(DOMAIN, CLASS, 2), True)
self.assertEqual(self.mogilefs.create_class(DOMAIN, CLASS, 2), False)
self.assertEqual(self.mogilefs.delete_class(DOMAIN, CLASS), True)
self.assertEqual(self.mogilefs.delete_class(DOMAIN, CLASS), False)
def test_get_server_settings(self):
res = self.mogilefs.server_settings()
assert res is not None
assert 'schema_version' in res
def test_set_server_setting(self):
self.mogilefs.set_server_setting("memcache_servers", "127.0.0.1:11211")
res = self.mogilefs.server_settings()
assert res['memcache_servers'] == '127.0.0.1:11211'
def test_get_devices(self):
devices = self.mogilefs.get_devices()
assert devices
for d in devices:
assert 'devid' in d
assert 'hostid' in d
assert 'status' in d
assert 'observed_state' in d
assert 'utilization' in d
assert 'mb_total' in d
assert 'mb_used' in d
assert 'weight' in d
#assert isinstance(d['mb_total'], six.integer_types)
#assert isinstance(d['mb_used'], six.integer_types)
#assert isinstance(d['weight'], six.integer_types)
def test_create_delete_host(self):
self.assertEqual(self.mogilefs.create_host('testhost', '192.168.0.1', 7500),
{'status': 'down', 'hostid': '1', 'http_port': '7500', 'hostname': 'testhost', 'hostip': '192.168.0.1'})
self.assertEqual(self.mogilefs.update_host('testhost', port=7501, status='alive'),
{'status': 'alive', 'hostid': '1', 'http_port': '7501', 'hostname': 'testhost', 'hostip': '192.168.0.1'})
self.assertEqual(self.mogilefs.delete_host('testhost'), True)
def test_set_server_settings():
moga = Admin(TRACKERS)
moga.set_server_settings("memcache_servers", "127.0.0.1:11211")
res = moga.server_settings()
assert res['memcache_servers'] == '127.0.0.1:11211'
def test_update_device():
moga = Admin(TRACKERS)
## TODO
moga.update_device('colinux', 1, status='down', weight=80)
moga.update_device('colinux', 1, status='alive', weight=100)
def test_create_class():
moga = Admin(TRACKERS)
moga.create_domain(DOMAIN)
moga.create_class(DOMAIN, CLASS, 2)
moga.delete_class(DOMAIN, CLASS)
def test_change_device_state():
moga = Admin(TRACKERS)
## TODO
moga.change_device_state('colinux', 1, 'down')
moga.change_device_state('colinux', 1, 'alive')
class TestClient(unittest.TestCase):
def setUp(self):
self.moga = Admin(HOSTS)
try:
self.moga.create_domain(TEST_NS)
except MogileFSError:
pass
def tearDown(self):
try:
self.moga.delete_domain(TEST_NS)
except MogileFSError:
pass
def test_sleep(self):
client = Client(TEST_NS, HOSTS)
self.assertEqual(client.sleep(1), True)
def test_list_keys(self):
keys = ["spam", "egg", "ham"]
domain = "test:list_keys:%s:%s:%s" % (random.random(), time.time(), TEST_NS)
self.moga.create_domain(domain)
mogc = Client(domain, HOSTS)
for k in keys:
mogc.store_content(k, k)
try:
files = mogc.list_keys()
assert len(files) == 3
files = mogc.list_keys(limit=1)
assert len(files) == 1
files = mogc.list_keys(prefix='sp')
assert len(files) == 1
finally:
for k in keys:
mogc.delete(k)
self.moga.delete_domain(domain)
def test_new_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
assert fp is not None
data = "0123456789" * 50
fp.write(data)
fp.close()
paths = client.get_paths(key)
#assert len(paths) > 1, "should exist in one ore more places"
assert paths
content = client.get_file_data(key)
assert content == data
#
# def test_new_large_file(self):
# client = Client(TEST_NS, HOSTS)
#
# key = 'test_file_%s_%s' % (random.random(), time.time())
# fp = client.new_file(key, largefile=True)
# assert fp is not None
#
# for _ in xrange(50):
# fp.write("0123456789")
# fp.close()
#
# paths = client.get_paths(key)
# #assert len(paths) > 1, "should exist in one ore more places"
# assert paths
#
# content = client.get_file_data(key)
# assert content == "0123456789" * 50
def test_new_file_unexisting_class(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
self.assertRaises(MogileFSError, client.new_file, key, 'unexisting')
def test_new_file_unexisting_domain(self):
client = Client('unexisting_domain', HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
self.assertRaises(MogileFSError, client.new_file, key)
def test_closed_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("spam")
fp.close()
self.assertRaises(ValueError, fp.write, "egg")
self.assertRaises(ValueError, fp.read)
self.assertRaises(ValueError, fp.seek, 0)
self.assertRaises(ValueError, fp.tell)
# def test_readonly_file(self):
# client = Client(TEST_NS, HOSTS)
# key = 'test_file_%s_%s' % (random.random(), time.time())
# client.store_content(key, "SPAM")
#
# fp = client.read_file(key)
# try:
# fp.write("egg")
# except:
# pass
# else:
# assert False, "operation not permitted to read-only file"
def test_seek(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("SPAM")
fp.seek(1)
self.assertEqual(fp.tell(), 1)
fp.write("p")
fp.close()
self.assertEqual(client.get_file_data(key), "SpAM")
def test_seek_negative(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("SPAM")
fp.seek(-10)
self.assertEqual(fp.tell(), 0)
fp.write("s")
fp.close()
self.assertEqual(client.get_file_data(key), "sPAM")
def test_seek_read(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.store_content(key, "0123456789")
fp = client.read_file(key)
fp.seek(1)
self.assertEqual(fp.tell(), 1)
content = fp.read(3)
assert content == "123"
self.assertEqual(fp.tell(), 4)
def test_rename(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.new_file(key).write(key)
paths = client.get_paths(key)
self.assertTrue(paths)
newkey = 'test_file2_%s_%s' % (random.random(), time.time())
client.rename(key, newkey)
paths = client.get_paths(newkey)
self.assertTrue(paths)
content = client.get_file_data(newkey)
assert content == key
def test_rename_dupliate_key(self):
client = Client(TEST_NS, HOSTS)
key1 = 'test_file_%s_%s' % (random.random(), time.time())
key2 = 'key2:' + key1
client.store_content(key1, key1)
client.store_content(key2, key2)
self.assertEqual(client.rename(key1, key2), False)
def test_store_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
data = ''.join(random.choice("0123456789") for _ in xrange(8192 * 2))
fp = StringIO(data)
length = client.store_file(key, fp)
self.assertEqual(length, len(data))
content = client.get_file_data(key)
self.assertEqual(content, data)
def test_store_content(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
data = ''.join(random.choice("0123456789") for _ in xrange(8192 * 2))
length = client.store_content(key, data)
self.assertEqual(length, len(data))
content = client.get_file_data(key)
self.assertEqual(content, data)
def test_read_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.store_content(key, key)
fp = client.read_file(key)
self.assertNotEqual(fp, None)
self.assertEqual(key, fp.read())
def test_delete(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.new_file(key).write("SPAM")
paths = client.get_paths(key)
self.assertTrue(paths)
client.delete(key)
paths = client.get_paths(key)
self.assertFalse(paths)
def test_mkcol(self):
client = Client(TEST_NS, HOSTS)
for x in xrange(0, 10):
key = 'test_file_%s_%s_%d' % (random.random(), time.time(), x)
client.new_file(key).write("SPAM%s" % x)
paths = client.get_paths(key)
self.assertTrue(paths)
def test_edit_file(self):
cl = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
cl.store_content(key, "SPAM")
self.assertTrue(cl.get_paths(key))
self.assertEqual("SPAM", cl.get_file_data(key))
fp = cl.edit_file(key)
self.assertTrue(fp)
fp.write("s")
fp.seek(2)
fp.write("a")
fp.close()
self.assertEqual("sPaM", cl.get_file_data(key))
def test_append_file(self):
cl = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
cl.store_content(key, "SPAM")
self.assertTrue(cl.get_paths(key))
self.assertEqual("SPAM", cl.get_file_data(key))
fp = cl.edit_file(key)
self.assertTrue(fp)
fp.seek(4)
fp.write("HamEggs")
fp.close()
self.assertEqual("SPAMHamEggs", cl.get_file_data(key))
def test_file_like_object(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("spam\negg\nham\n")
fp.seek(0)
line = fp.readline()
self.assertEqual(line, "spam\n")
line = fp.readline()
self.assertEqual(line, "egg\n")
line = fp.readline()
self.assertEqual(line, "ham\n")
line = fp.readline()
self.assertEqual(line, '')
fp.seek(0)
lines = fp.readlines()
self.assertEqual(lines, ["spam\n", "egg\n", "ham\n"])
fp.close()
class TestClient(unittest.TestCase):
def setUp(self):
self.moga = Admin(HOSTS)
try:
self.moga.create_domain(TEST_NS)
except MogileFSError:
pass
def tearDown(self):
try:
self.moga.delete_domain(TEST_NS)
except MogileFSError:
pass
def test_sleep(self):
client = Client(TEST_NS, HOSTS)
self.assertEqual(client.sleep(1), True)
def test_list_keys(self):
keys = ["spam", "egg", "ham"]
domain = "test:list_keys:%s:%s:%s" % (random.random(), time.time(),
TEST_NS)
self.moga.create_domain(domain)
mogc = Client(domain, HOSTS)
for k in keys:
mogc.store_content(k, k)
try:
files = mogc.list_keys()
assert len(files) == 3
files = mogc.list_keys(limit=1)
assert len(files) == 1
files = mogc.list_keys(prefix='sp')
assert len(files) == 1
finally:
for k in keys:
mogc.delete(k)
self.moga.delete_domain(domain)
def test_new_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
assert fp is not None
data = "0123456789" * 50
fp.write(data)
fp.close()
paths = client.get_paths(key)
#assert len(paths) > 1, "should exist in one ore more places"
assert paths
content = client.get_file_data(key)
assert content == data
#
# def test_new_large_file(self):
# client = Client(TEST_NS, HOSTS)
#
# key = 'test_file_%s_%s' % (random.random(), time.time())
# fp = client.new_file(key, largefile=True)
# assert fp is not None
#
# for _ in xrange(50):
# fp.write("0123456789")
# fp.close()
#
# paths = client.get_paths(key)
# #assert len(paths) > 1, "should exist in one ore more places"
# assert paths
#
# content = client.get_file_data(key)
# assert content == "0123456789" * 50
def test_new_file_unexisting_class(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
self.assertRaises(MogileFSError, client.new_file, key, 'unexisting')
def test_new_file_unexisting_domain(self):
client = Client('unexisting_domain', HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
self.assertRaises(MogileFSError, client.new_file, key)
def test_closed_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("spam")
fp.close()
self.assertRaises(ValueError, fp.write, "egg")
self.assertRaises(ValueError, fp.read)
self.assertRaises(ValueError, fp.seek, 0)
self.assertRaises(ValueError, fp.tell)
# def test_readonly_file(self):
# client = Client(TEST_NS, HOSTS)
# key = 'test_file_%s_%s' % (random.random(), time.time())
# client.store_content(key, "SPAM")
#
# fp = client.read_file(key)
# try:
# fp.write("egg")
# except:
# pass
# else:
# assert False, "operation not permitted to read-only file"
def test_seek(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("SPAM")
fp.seek(1)
self.assertEqual(fp.tell(), 1)
fp.write("p")
fp.close()
self.assertEqual(client.get_file_data(key), "SpAM")
def test_seek_negative(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("SPAM")
fp.seek(-10)
self.assertEqual(fp.tell(), 0)
fp.write("s")
fp.close()
self.assertEqual(client.get_file_data(key), "sPAM")
def test_seek_read(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.store_content(key, "0123456789")
fp = client.read_file(key)
fp.seek(1)
self.assertEqual(fp.tell(), 1)
content = fp.read(3)
assert content == "123"
self.assertEqual(fp.tell(), 4)
def test_rename(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.new_file(key).write(key)
paths = client.get_paths(key)
self.assertTrue(paths)
newkey = 'test_file2_%s_%s' % (random.random(), time.time())
client.rename(key, newkey)
paths = client.get_paths(newkey)
self.assertTrue(paths)
content = client.get_file_data(newkey)
assert content == key
def test_rename_dupliate_key(self):
client = Client(TEST_NS, HOSTS)
key1 = 'test_file_%s_%s' % (random.random(), time.time())
key2 = 'key2:' + key1
client.store_content(key1, key1)
client.store_content(key2, key2)
self.assertEqual(client.rename(key1, key2), False)
def test_store_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
data = ''.join(random.choice("0123456789") for _ in xrange(8192 * 2))
fp = StringIO(data)
length = client.store_file(key, fp)
self.assertEqual(length, len(data))
content = client.get_file_data(key)
self.assertEqual(content, data)
def test_store_content(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
data = ''.join(random.choice("0123456789") for _ in xrange(8192 * 2))
length = client.store_content(key, data)
self.assertEqual(length, len(data))
content = client.get_file_data(key)
self.assertEqual(content, data)
def test_read_file(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.store_content(key, key)
fp = client.read_file(key)
self.assertNotEqual(fp, None)
self.assertEqual(key, fp.read())
def test_delete(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
client.new_file(key).write("SPAM")
paths = client.get_paths(key)
self.assertTrue(paths)
client.delete(key)
paths = client.get_paths(key)
self.assertFalse(paths)
def test_mkcol(self):
client = Client(TEST_NS, HOSTS)
for x in xrange(0, 10):
key = 'test_file_%s_%s_%d' % (random.random(), time.time(), x)
client.new_file(key).write("SPAM%s" % x)
paths = client.get_paths(key)
self.assertTrue(paths)
# def test_edit_file(self):
# cl = Client(TEST_NS, HOSTS)
# key = 'test_file_%s_%s' % (random.random(), time.time())
#
# cl.store_content(key, "SPAM")
# assert cl.get_paths(key)
# assert cl.get_file_data(key) == "SPAM"
#
# fp = cl.edit_file(key)
# assert fp
# fp.write("s")
# fp.seek(2)
# fp.write("a")
# fp.close()
#
# assert cl.get_file_data(key) == "sPaM"
def test_file_like_object(self):
client = Client(TEST_NS, HOSTS)
key = 'test_file_%s_%s' % (random.random(), time.time())
fp = client.new_file(key)
fp.write("spam\negg\nham\n")
fp.seek(0)
line = fp.readline()
self.assertEqual(line, "spam\n")
line = fp.readline()
self.assertEqual(line, "egg\n")
line = fp.readline()
self.assertEqual(line, "ham\n")
line = fp.readline()
self.assertEqual(line, '')
fp.seek(0)
lines = fp.readlines()
self.assertEqual(lines, ["spam\n", "egg\n", "ham\n"])
fp.close()
def test_fsck_clearlog():
moga = Admin(TRACKERS)
moga.fsck_clearlog()
def test_fsck_log_rows():
moga = Admin(TRACKERS)
moga.fsck_log_rows()
def test_fsck_reset():
moga = Admin(TRACKERS)
moga.fsck_reset(0, 0)
def setUp(self):
self.moga = Admin(HOSTS)
try:
self.moga.create_domain(TEST_NS)
except MogileFSError:
pass
def test_get_stats():
moga = Admin(TRACKERS)
moga.get_stats()
def setUp(self):
self.moga = Admin(HOSTS)
try:
self.moga.create_domain(TEST_NS)
except MogileFSError:
pass
class AdminTest(unittest.TestCase):
def setUp(self):
self.mogilefs = Admin(TRACKERS)
try:
self.mogilefs.delete_class(DOMAIN, CLASS)
self.mogilefs.delete_domain(DOMAIN)
except:
pass
def test_create_delete_domain(self):
self.assertEqual(self.mogilefs.delete_domain(DOMAIN), False)
self.assertEqual(self.mogilefs.create_domain(DOMAIN), True)
self.assertEqual(self.mogilefs.create_domain(DOMAIN), False)
self.assertEqual(self.mogilefs.delete_domain(DOMAIN), True)
def test_get_domains(self):
self.mogilefs.create_domain(DOMAIN)
self.mogilefs.create_class(DOMAIN, CLASS, 2)
ret = self.mogilefs.get_domains()
assert DOMAIN in ret
assert CLASS in ret[DOMAIN], ret
assert ret[DOMAIN][CLASS] == 2, ret
self.mogilefs.delete_domain(DOMAIN)
def test_create_delete_class(self):
self.assertEqual(self.mogilefs.create_domain(DOMAIN), True)
self.assertEqual(self.mogilefs.create_class(DOMAIN, CLASS, 2), True)
self.assertEqual(self.mogilefs.create_class(DOMAIN, CLASS, 2), False)
self.assertEqual(self.mogilefs.delete_class(DOMAIN, CLASS), True)
self.assertEqual(self.mogilefs.delete_class(DOMAIN, CLASS), False)
def test_get_server_settings(self):
res = self.mogilefs.server_settings()
assert res is not None
assert 'schema_version' in res
def test_set_server_setting(self):
self.mogilefs.set_server_setting("memcache_servers", "127.0.0.1:11211")
res = self.mogilefs.server_settings()
assert res['memcache_servers'] == '127.0.0.1:11211'
def test_get_devices(self):
devices = self.mogilefs.get_devices()
assert devices
for d in devices:
assert d.has_key('devid')
assert d.has_key('hostid')
assert d.has_key('status')
assert d.has_key('observed_state')
assert d.has_key('utilization')
assert d.has_key('mb_total')
assert d.has_key('mb_used')
assert d.has_key('weight')
#assert isinstance(d['mb_total'], (int, long))
#assert isinstance(d['mb_used'], (int, long))
#assert isinstance(d['weight'], (int, long))
def test_create_delete_host(self):
self.assertEqual(self.mogilefs.create_host('testhost', '192.168.0.1', 7500),
{'status': 'down', 'hostid': '1', 'http_port': '7500', 'hostname': 'testhost', 'hostip': '192.168.0.1'})
self.assertEqual(self.mogilefs.update_host('testhost', port=7501, status='alive'),
{'status': 'alive', 'hostid': '1', 'http_port': '7501', 'hostname': 'testhost', 'hostip': '192.168.0.1'})
self.assertEqual(self.mogilefs.delete_host('testhost'), True)
