def test_directory_creation(self):
"""
This tests assures we always know what is being created
in the framework directory
"""
#assure we have a temp directory as HOME for testing
testUserDir = tempfile.mkdtemp('_es_userdir')
testUser = DummyUser(pw_dir=testUserDir)
#assure we have a home directory setup
self.assertTrue(os.path.isdir(testUser.getUserHome()))
baseDir = testUser.getUserBaseDir()
#check home is completely created
#self.assertFalse(os.path.isdir(baseDir)) Basic dir structure is created when running a tool because of
#history, so this doesn't apply anymore
testUser.prepareDir()
self.assertTrue(os.path.isdir(baseDir))
print "Test user config dir in: ", testUser.getUserBaseDir()
created_dirs = [
testUser.getUserConfigDir(),
testUser.getUserCacheDir(),
testUser.getUserOutputDir(),
testUser.getUserPlotsDir()
]
print created_dirs
for directory in created_dirs:
self.assertTrue(os.path.isdir(directory))
def testDefaultPluginConfigStorage(self):
user = DummyUser(random_home=True, pw_name='test_user')
home = user.getUserHome()
self.assertTrue(os.path.isdir(home))
conf_file = pm.writeSetup('dummyplugin', user=user)
print conf_file
self.assertTrue(os.path.isfile(conf_file))
with open(conf_file, 'r') as f:
print f.read()
def test_write_setup(self):
user = DummyUser(random_home=True, pw_name='test_user')
home = user.getUserHome()
f = pm.writeSetup('DummyPlugin',
dict(number="$the_number", the_number=42), user)
with open(f) as fp:
num_line = [
line for line in fp.read().splitlines()
if line.startswith('number')
][0]
self.assertEqual(num_line, 'number=$the_number')
def test_plugin_config_storage(self):
user = DummyUser(random_home=True, pw_name='test_user')
home = user.getUserHome()
self.assertTrue(os.path.isdir(home))
res = pm.getPluginInstance('dummyplugin').setupConfiguration(
config_dict=dict(the_number=42))
self.assertEquals(res['something'], 'test')
# write down this default
conf_file = pm.writeSetup('dummyplugin',
config_dict=dict(the_number=42),
user=user)
self.assertTrue(os.path.isfile(conf_file))
with open(conf_file, 'r') as f:
config = f.read()
self.assertTrue('\nsomething=test\n' in config)
self.failUnlessRaises(ValidationError, pm.parseArguments,
'dummyplugin', [])
self.failUnlessRaises(ValidationError,
pm.parseArguments,
'dummyplugin', [],
user=user)
res = pm.parseArguments('dummyplugin', [],
use_user_defaults=True,
user=user)
self.assertEquals(
res, {
'other': 1.4,
'number': None,
'the_number': 42,
'something': 'test',
'input': None
})
self.assertEquals(res['something'], 'test')
# now change the stored configuration
config = config.replace('\nsomething=test\n',
'\nsomething=super_test\n')
with open(conf_file, 'w') as f:
f.write(config)
res = pm.parseArguments('dummyplugin', [],
use_user_defaults=True,
user=user)
self.assertEquals(res['something'], 'super_test')
def test_parse_arguments(self):
user = DummyUser(random_home=True, pw_name='test_user')
home = user.getUserHome()
self.assertTrue(os.path.isdir(home))
# direct parsing
for args, result in [("the_number=4", {
'other': 1.3999999999999999,
'the_number': 4,
'something': 'test'
})]:
d = pm.parseArguments('Dummyplugin', args.split(), user=user)
self.assertEquals(d, result)
# parsing requesting user default but without any
for args, result in [("the_number=4", {
'other': 1.3999999999999999,
'the_number': 4,
'something': 'test'
})]:
d = pm.parseArguments('Dummyplugin',
args.split(),
use_user_defaults=True,
user=user)
self.assertEquals(d, result)
pm.writeSetup('DummyPlugin', dict(number=7, the_number=42), user)
for args, result in [("number=4",
dict(number=4,
the_number=42,
something='test',
other=1.4,
input=None))]:
d = pm.parseArguments('Dummyplugin',
args.split(),
use_user_defaults=True,
user=user)
self.assertEquals(d, result)
if os.path.isdir(home) and home.startswith(tempfile.gettempdir()):
# make sure the home is a temporary one!!!
print "Cleaning up %s" % home
shutil.rmtree(home)
def test_get_history(self):
user = DummyUser(random_home=True, pw_name='illing')
home = user.getUserHome()
pm.writeSetup('DummyPlugin', dict(the_number=777), user)
pm.runTool('dummyplugin', user=user)
# DummyPlugin._runs.pop()
res = pm.getHistory(user=user)
print res
# self.assertEqual(len(res), 1)
res = res[0]
import re
mo = re.search('^([0-9]{1,})[)] ([^ ]{1,}) ([^ ]{1,}) ([^ ]{1,})',
res.__str__(compact=False))
self.assertTrue(mo is not None)
g1 = mo.groups()
self.assertTrue(all([g is not None for g in g1]))
mo = re.search('^([0-9]{1,})[)] ([^ ]{1,}) ([^ ]{1,})', res.__str__())
g2 = mo.groups()
self.assertTrue(all([g is not None for g in g2]))
self.assertEqual(g1[0], g2[0])
class Test(unittest.TestCase):
"""Test the User construct used for managing the configuration of a user"""
DUMMY_USER = {'pw_name': 'someone'}
def setUp(self):
os.environ['EVALUATION_SYSTEM_CONFIG_FILE'] = os.path.dirname(
__file__) + '/test.conf'
User.objects.filter(username='******').delete()
self.user = DummyUser(random_home=True, **Test.DUMMY_USER)
self.db_user = User.objects.create(username='******')
self.tool = DummyPlugin()
self.config_dict = {
'the_number': 42,
'number': 12,
'something': 'else',
'other': 'value',
'input': '/folder'
}
self.row_id = self.user.getUserDB().storeHistory(
self.tool,
self.config_dict,
'user',
History.processStatus.not_scheduled,
caption='My caption')
def tearDown(self):
# remove the test entries from the database
#User.objects.all().delete()
History.objects.all().delete()
User.objects.filter(username='******').delete()
home = self.user.getUserHome()
if os.path.isdir(home) and home.startswith(tempfile.gettempdir()):
# make sure the home is a temporary one!!!
print "Cleaning up %s" % home
shutil.rmtree(home)
def test_store_history(self):
row_id = self.user.getUserDB().storeHistory(self.tool,
self.config_dict,
'user',
1,
caption='My caption')
h = History.objects.get(id=row_id)
self.assertTrue(h)
self.assertEqual(h.status_name(), 'finished_no_output')
self.assertEqual(h.caption, 'My caption')
self.assertEqual(h.config_dict(), self.config_dict)
def test_schedule_entry(self):
self.user.getUserDB().scheduleEntry(self.row_id, 'user',
'/slurm/output/file.txt')
h = History.objects.get(id=self.row_id)
self.assertEqual(h.status, History.processStatus.scheduled)
self.assertEqual(h.slurm_output, '/slurm/output/file.txt')
def test_upgrade_status(self):
self.assertRaises(self.user.getUserDB().ExceptionStatusUpgrade,
self.user.getUserDB().upgradeStatus, self.row_id,
'user', 6)
self.user.getUserDB().upgradeStatus(self.row_id, 'user',
History.processStatus.finished)
h = History.objects.get(id=self.row_id)
self.assertEqual(h.status, History.processStatus.finished)
def test_change_flag(self):
self.user.getUserDB().changeFlag(self.row_id, 'user',
History.Flag.deleted)
h = History.objects.get(id=self.row_id)
self.assertEqual(h.flag, History.Flag.deleted)
def test_get_history(self):
# create some values
users = ['user', 'other', 'user', 'test']
for u in users:
self.user.getUserDB().storeHistory(self.tool,
self.config_dict,
u,
1,
caption='My %s' % u)
history = self.user.getUserDB().getHistory()
self.assertEqual(history.count(), 5)
history = self.user.getUserDB().getHistory(uid='user')
self.assertEqual(history.count(), 3)
history = self.user.getUserDB().getHistory(uid='user',
tool_name='dummyplugin',
limit=2)
self.assertEqual(history.count(), 2)
history = self.user.getUserDB().getHistory(uid='user',
entry_ids=self.row_id)
self.assertEqual(history.count(), 1)
def test_add_history_tag(self):
self.user.getUserDB().addHistoryTag(self.row_id,
HistoryTag.tagType.note_public,
'Some note')
h = History.objects.get(id=self.row_id)
tags = h.historytag_set.all()
self.assertEqual(len(tags), 1)
self.assertEqual(tags[0].type, HistoryTag.tagType.note_public)
def test_update_history_tag(self):
self.user.getUserDB().addHistoryTag(self.row_id,
HistoryTag.tagType.note_public,
'Some note',
uid='user')
h_tag = History.objects.get(id=self.row_id).historytag_set.first()
self.user.getUserDB().updateHistoryTag(h_tag.id,
HistoryTag.tagType.note_deleted,
'New text',
uid='user')
h_tag = History.objects.get(id=self.row_id).historytag_set.first()
self.assertEqual(h_tag.type, HistoryTag.tagType.note_deleted)
self.assertEqual(h_tag.text, 'New text')
def test_store_results(self):
results = {
'/some/result.png': {
'type': 'plot',
'caption': 'super plot'
},
'/some/other.eps': {
'type': 'data'
}
}
self.user.getUserDB().storeResults(self.row_id, results)
h = History.objects.get(id=self.row_id)
self.assertEqual(h.result_set.count(), 2)
for key, val in results.iteritems():
self.assertTrue(
h.result_set.filter(history_id_id=self.row_id,
output_file=key).exists())
if val.get('caption', None):
res_tag = h.result_set.get(
output_file=key).resulttag_set.first()
self.assertEqual(res_tag.type, ResultTag.flagType.caption)
self.assertEqual(res_tag.text, val['caption'])
def test_version(self):
Version.objects.all().delete()
# create version entry
version_id = self.user.getUserDB().newVersion('dummyplugin', '1.0',
'git', 'git_number',
'tool_git',
'tool_git_number')
self.assertTrue(Version.objects.filter(id=version_id).exists())
# get version entry
get_version_id = self.user.getUserDB().getVersionId(
'dummyplugin', '1.0', 'git', 'git_number', 'tool_git',
'tool_git_number')
self.assertEqual(version_id, get_version_id)
Version.objects.all().delete()
def test_create_user(self):
User.objects.filter(username='******').delete()
self.user.getUserDB().createUser('new_user', '*****@*****.**', 'Test',
'User')
self.assertTrue(User.objects.filter(username='******').exists())
User.objects.filter(username='******').delete()
def test_create_user_crawl(self):
self.user.getUserDB().create_user_crawl('/some/test/folder', 'user')
self.assertTrue(
UserCrawl.objects.filter(
status='waiting', path_to_crawl='/some/test/folder').exists())
UserCrawl.objects.all().delete()
def test_timestamp_to_string(self):
time = datetime.now()
self.assertEqual(timestamp_to_string(time),
time.strftime('%Y-%m-%d %H:%M:%S.%f'))
def test_timestamp_from_string(self):
time = datetime.now()
time_str = timestamp_to_string(time)
self.assertEqual(time, timestamp_from_string(time_str))
class Test(unittest.TestCase):
"""Test the User construct used for managing the configuratio of a user"""
DUMMY_USER = {'pw_name': 'someone'}
def setUp(self):
os.environ['EVALUATION_SYSTEM_CONFIG_FILE'] = os.path.dirname(
__file__) + '/test.conf'
self.user = DummyUser(random_home=True, **Test.DUMMY_USER)
def tearDown(self):
self.user.cleanRandomHome()
def testd_ummy_user(self):
"""Be sure the dummy user is created as expected"""
dummy_name = 'non-existing name'
self.failUnlessRaises(Exception,
DummyUser,
random_home=True,
pw_dir='anything')
d_user = DummyUser(random_home=True, pw_name=dummy_name)
#populate the test directory as required
d_user.prepareDir()
self.assertEqual(dummy_name, d_user.getName())
cfg_file = os.path.join(d_user.getUserBaseDir(), User.EVAL_SYS_CONFIG)
#check configuration file writing
self.assertFalse(os.path.isfile(cfg_file))
cnfg = d_user.getUserConfig()
cnfg.add_section("test_section")
cnfg.set("test_section", 'some_key', 'a text value\nwith many\nlines!')
d_user.writeConfig()
self.assertTrue(os.path.isfile(cfg_file))
fp = open(cfg_file, 'r')
print fp.read()
fp.close()
#check configuration file reading
fp = open(cfg_file, 'w')
##Note multi line values in the configuration file need to be indented...
fp.write(
"[test2]\nkey1 = 42\nkey2=Some\n\tmany\n\tlines=2\nkey3=%(key1)s0\n"
)
fp.close()
cnfg = d_user.reloadConfig()
self.assertTrue(cnfg.getint('test2', 'key1') == 42)
#...but the indentation disappears when returned directly
self.assertTrue(cnfg.get('test2', 'key2') == 'Some\nmany\nlines=2')
self.assertTrue(cnfg.getint('test2', 'key3') == 420)
d_user.cleanRandomHome()
def test_getters(self):
"""Test the object creation and some basic return functions"""
self.assertEqual(Test.DUMMY_USER['pw_name'], self.user.getName())
self.assertTrue(self.user.getUserHome().startswith(
tempfile.gettempdir()))
self.assertEqual(int(Test.runCmd('id -u')), self.user.getUserID())
db = self.user.getUserDB()
self.assertTrue(db is not None)
baseDir = '/'.join(
[self.user.getUserHome(),
config.get(config.BASE_DIR)])
self.assertEqual(baseDir, self.user.getUserBaseDir())
tool1_cnfDir = os.path.join(baseDir, User.CONFIG_DIR, 'tool1')
tool1_chDir = os.path.join(baseDir, User.CACHE_DIR, 'tool1')
tool1_outDir = os.path.join(baseDir, User.OUTPUT_DIR, 'tool1')
tool1_plotDir = os.path.join(baseDir, User.PLOTS_DIR, 'tool1')
self.assertEqual(self.user.getUserScratch(),
'/tmp/scratch/%s' % self.user.getName())
#check we get the configuration directory of the given tool
self.assertEqual(tool1_cnfDir, self.user.getUserConfigDir('tool1'))
self.assertEqual(tool1_chDir, self.user.getUserCacheDir('tool1'))
self.assertEqual(tool1_outDir, self.user.getUserOutputDir('tool1'))
self.assertEqual(tool1_plotDir, self.user.getUserPlotsDir('tool1'))
#check we get the general directory of the tools (should be the parent of the previous one)
self.assertEqual(os.path.dirname(tool1_cnfDir),
self.user.getUserConfigDir())
self.assertEqual(os.path.dirname(tool1_chDir),
self.user.getUserCacheDir())
self.assertEqual(os.path.dirname(tool1_outDir),
self.user.getUserOutputDir())
self.assertEqual(os.path.dirname(tool1_plotDir),
self.user.getUserPlotsDir())
def test_directory_creation(self):
"""
This tests assures we always know what is being created
in the framework directory
"""
#assure we have a temp directory as HOME for testing
testUserDir = tempfile.mkdtemp('_es_userdir')
testUser = DummyUser(pw_dir=testUserDir)
#assure we have a home directory setup
self.assertTrue(os.path.isdir(testUser.getUserHome()))
baseDir = testUser.getUserBaseDir()
#check home is completely created
#self.assertFalse(os.path.isdir(baseDir)) Basic dir structure is created when running a tool because of
#history, so this doesn't apply anymore
testUser.prepareDir()
self.assertTrue(os.path.isdir(baseDir))
print "Test user config dir in: ", testUser.getUserBaseDir()
created_dirs = [
testUser.getUserConfigDir(),
testUser.getUserCacheDir(),
testUser.getUserOutputDir(),
testUser.getUserPlotsDir()
]
print created_dirs
for directory in created_dirs:
self.assertTrue(os.path.isdir(directory))
def test_directory_creation2(self):
testUser = self.user
#assure we have a home directory setup
self.assertTrue(os.path.isdir(testUser.getUserHome()))
dir1 = testUser.getUserConfigDir('test_tool')
print dir1
self.assertFalse(os.path.isdir(dir1))
dir2 = testUser.getUserConfigDir('test_tool', create=True)
self.assertEquals(dir1, dir2)
self.assertTrue(os.path.isdir(dir1))
def test_central_directory_Creation(self):
tmp_dir = tempfile.mkdtemp(__name__)
config._config[config.BASE_DIR_LOCATION] = tmp_dir
config._config[
config.
DIRECTORY_STRUCTURE_TYPE] = config.DIRECTORY_STRUCTURE.CENTRAL
testUser = DummyUser(random_home=False, **Test.DUMMY_USER)
dir1 = testUser.getUserBaseDir()
self.assertEquals(
dir1,
os.path.join(config.get(config.BASE_DIR_LOCATION),
config.get(config.BASE_DIR), str(testUser.getName())))
dir2 = testUser.getUserOutputDir('sometool')
self.assertEquals(
dir2,
os.path.join(config.get(config.BASE_DIR_LOCATION),
config.get(config.BASE_DIR), str(testUser.getName()),
User.OUTPUT_DIR, 'sometool'))
print dir2
config.reloadConfiguration()
if os.path.isdir(tmp_dir) and tmp_dir.startswith(
tempfile.gettempdir()):
#make sure the home is a temporary one!!!
print "Cleaning up %s" % tmp_dir
shutil.rmtree(tmp_dir)
def test_config_file(self):
tool = 'test_tool'
self.assertEquals(
self.user.getUserConfigDir(tool) + '/%s.conf' % tool,
self.user.getUserToolConfig(tool))
@staticmethod
def runCmd(cmd):
if isinstance(cmd, basestring): cmd = cmd.split()
return subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0]