def test_orderrun_delete(self):
mock_api = DKCloudAPIMock(self._cr_config)
rs = DKCloudCommandRunner.delete_orderrun(mock_api, 'good')
self.assertTrue(rs.ok())
rs = DKCloudCommandRunner.delete_orderrun(mock_api, 'bad')
self.assertFalse(rs.ok())
def test_orderrun_delete(self):
mock_api = DKCloudAPIMock(self._cr_config)
rs = DKCloudCommandRunner.delete_orderrun(mock_api, 'good')
self.assertTrue(rs.ok())
rs = DKCloudCommandRunner.delete_orderrun(mock_api, 'bad')
self.assertFalse(rs.ok())
def test_delete_file(self):
# setup
parent_kitchen = 'CLI-Top'
test_kitchen = 'Runner-test_delete_file'
test_kitchen = self._add_my_guid(test_kitchen)
recipe_name = 'simple'
recipe_file_key = recipe_name
file_name = 'description.json'
message = 'test Delete Runner-test_delete_file'
self._delete_and_clean_kitchen(test_kitchen)
temp_dir, kitchen_dir = self._make_kitchen_dir(test_kitchen, change_dir=True)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, test_kitchen)
self.assertTrue(rs.ok())
os.chdir(kitchen_dir)
self.assertTrue(self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name) is not None)
rv = DKCloudCommandRunner.get_recipe(self._api, test_kitchen, recipe_name)
self.assertTrue(recipe_name in rv.get_message())
target_file = os.path.join(kitchen_dir, os.path.join(recipe_file_key, file_name))
self.assertTrue(os.path.isfile(target_file)) # the file is there
os.remove(target_file)
rs = DKCloudCommandRunner.delete_file(self._api, test_kitchen, recipe_name,
message, file_name)
self.assertTrue(rs.ok())
self.assertTrue(self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name) is None,
"Gone check")
# cleanup
self._delete_and_clean_kitchen(test_kitchen)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_order_list_with_filters(self):
parent_kitchen = 'CLI-Top'
# Don't use a guid for this. Don't
kitchen = self._add_my_guid('test_order_list_with_filters')
recipe1 = 'parallel-recipe-test'
recipe1_variation = self._get_run_variation_for_recipe(recipe1)
recipe2 = 'simple'
recipe2_variation = 'simple-variation-now'
setup = True
if setup:
self._delete_and_clean_kitchen(kitchen)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, kitchen)
self.assertTrue(rv.ok())
rv = DKCloudCommandRunner.create_order(self._api, kitchen, recipe1, recipe1_variation)
self.assertTrue(rv.ok())
first_order = rv.get_payload()
rv = DKCloudCommandRunner.create_order(self._api, kitchen, recipe1, recipe1_variation)
self.assertTrue(rv.ok())
time.sleep(20)
rs = DKCloudCommandRunner.list_order(self._api, kitchen)
self.assertTrue(rs.ok())
message = rs.rc['message']
self.assertTrue(
'OrderRun is Planned' in message or 'OrderRun Completed' in message or 'OrderRun is Active' in message)
# cleanup
self._delete_and_clean_kitchen(kitchen)
def test_recipe_get_complex(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
rc = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
recipe_path = os.path.join(kitchen_dir, recipe_name)
self.assertTrue(os.path.exists(recipe_path))
# Modify the local file.
with open(os.path.join(recipe_path, "simple-file.txt"), 'a') as modify_file:
modify_file.write('new line\n')
modify_file.flush()
# Delete something local, so it's remote only.
os.remove(os.path.join(recipe_path, 'variations.json'))
os.remove(os.path.join(recipe_path, 'node1', 'data_sources', 'DKDataSource_NoOp.json'))
# Create a new file, so there is a local only file.
with open(os.path.join(recipe_path, "new_local_file.txt"), 'w') as new_local_file:
new_local_file.write('peccary\n')
new_local_file.flush()
subdir = os.path.join(recipe_path, 'subdir')
os.mkdir(subdir)
with open(os.path.join(subdir, "new_local_file_in_subdir.txt"), 'w') as new_local_file:
new_local_file.write('peccary\n')
new_local_file.flush()
rc = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name, recipe_path)
self.assertTrue(rc.ok())
msg = rc.get_message()
self.assertTrue('Auto-merging' in msg)
self.assertTrue('2 new or missing files' in msg)
if False:
shutil.rmtree(temp_dir, ignore_errors=True)
def test_add_file(self):
parent_kitchen = 'CLI-Top'
test_kitchen = 'test_create_file-Runner'
test_kitchen = self._add_my_guid(test_kitchen)
recipe_name = 'simple'
file_name = 'added.sql'
filedir = 'resources'
recipe_file_key = os.path.join(recipe_name, filedir)
api_file_key = os.path.join(filedir, file_name)
file_contents = '--\n-- sql for you\n--\n\nselect 1024\n\n'
message = 'test update test_create_file-API'
# test negative
rc = DKCloudCommandRunner.add_file(self._api, test_kitchen, recipe_name, message, 'badfile.txt')
self.assertFalse(rc.ok())
# create test kitchen
self._delete_and_clean_kitchen(test_kitchen)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, test_kitchen)
self.assertTrue(rs.ok())
# make and cd to kitchen dir and get the recipe to disk
temp_dir, kitchen_dir = self._make_kitchen_dir(test_kitchen, change_dir=True)
os.chdir(kitchen_dir)
self._get_recipe(test_kitchen, recipe_name)
# create new file on disk
try:
os.chdir(recipe_name)
with open(api_file_key, 'w') as f:
f.write(file_contents)
except ValueError, e:
print('could not write file %s.' % e)
self.assertTrue(False)
def test_order_list_with_filters(self):
parent_kitchen = 'CLI-Top'
# Don't use a guid for this. Don't
kitchen = self._add_my_guid('test_order_list_with_filters')
recipe1 = 'parallel-recipe-test'
recipe1_variation = self._get_run_variation_for_recipe(recipe1)
recipe2 = 'simple'
recipe2_variation = 'simple-variation-now'
setup = True
if setup:
self._delete_and_clean_kitchen(kitchen)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, kitchen)
self.assertTrue(rv.ok())
rv = DKCloudCommandRunner.create_order(self._api, kitchen, recipe1, recipe1_variation)
self.assertTrue(rv.ok())
first_order = rv.get_payload()
rv = DKCloudCommandRunner.create_order(self._api, kitchen, recipe1, recipe1_variation)
self.assertTrue(rv.ok())
time.sleep(20)
rs = DKCloudCommandRunner.list_order(self._api, kitchen)
self.assertTrue(rs.ok())
message = rs.rc['message']
self.assertTrue(
'OrderRun is Planned' in message or 'OrderRun Completed' in message or 'OrderRun is Active' in message)
# cleanup
self._delete_and_clean_kitchen(kitchen)
def test_order_list_for_repeating_order(self):
parent_kitchen = 'master'
recipe_name = 'parallel-recipe-test'
variation_name = self._get_run_variation_for_recipe(recipe_name, repeater=True)
new_kitchen = 'test_order_list_for_repeating_order'
new_kitchen = self._add_my_guid(new_kitchen)
self._delete_and_clean_kitchen(new_kitchen)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rs.ok())
rs = DKCloudCommandRunner.create_order(self._api, new_kitchen, recipe_name, variation_name)
new_order_id_1 = rs.get_payload()
self.assertTrue(rs.ok())
found_completed_serving = False
wait_time = [10,61,61,61,61]
for wt in wait_time:
rs = DKCloudCommandRunner.list_order(self._api, new_kitchen)
output_string = rs.rc['message']
n = output_string.count(new_order_id_1)
if n >= 3 and ('OrderRun Completed' in output_string):
found_completed_serving = True
break
time.sleep(wt)
self.assertTrue(found_completed_serving)
# cleanup
self._delete_and_clean_kitchen(new_kitchen)
def test_delete_file(self):
# setup
parent_kitchen = 'CLI-Top'
test_kitchen = 'Runner-test_delete_file'
test_kitchen = self._add_my_guid(test_kitchen)
recipe_name = 'simple'
recipe_file_key = recipe_name
file_name = 'description.json'
message = 'test Delete Runner-test_delete_file'
self._delete_and_clean_kitchen(test_kitchen)
temp_dir, kitchen_dir = self._make_kitchen_dir(test_kitchen, change_dir=True)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, test_kitchen)
self.assertTrue(rs.ok())
os.chdir(kitchen_dir)
self.assertTrue(self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name) is not None)
rv = DKCloudCommandRunner.get_recipe(self._api, test_kitchen, recipe_name)
self.assertTrue(recipe_name in rv.get_message())
target_file = os.path.join(kitchen_dir, os.path.join(recipe_file_key, file_name))
self.assertTrue(os.path.isfile(target_file)) # the file is there
os.remove(target_file)
rs = DKCloudCommandRunner.delete_file(self._api, test_kitchen, recipe_name,
message, file_name)
self.assertTrue(rs.ok())
self.assertTrue(self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name) is None,
"Gone check")
# cleanup
self._delete_and_clean_kitchen(test_kitchen)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_add_file(self):
parent_kitchen = 'CLI-Top'
test_kitchen = 'test_create_file-Runner'
test_kitchen = self._add_my_guid(test_kitchen)
recipe_name = 'simple'
file_name = 'added.sql'
filedir = 'resources'
recipe_file_key = os.path.join(recipe_name, filedir)
api_file_key = os.path.join(filedir, file_name)
file_contents = '--\n-- sql for you\n--\n\nselect 1024\n\n'
message = 'test update test_create_file-API'
# test negative
rc = DKCloudCommandRunner.add_file(self._api, test_kitchen, recipe_name, message, 'badfile.txt')
self.assertFalse(rc.ok())
# create test kitchen
self._delete_and_clean_kitchen(test_kitchen)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, test_kitchen)
self.assertTrue(rs.ok())
# make and cd to kitchen dir and get the recipe to disk
temp_dir, kitchen_dir = self._make_kitchen_dir(test_kitchen, change_dir=True)
os.chdir(kitchen_dir)
self._get_recipe(test_kitchen, recipe_name)
# create new file on disk
try:
os.chdir(recipe_name)
with open(api_file_key, 'w') as f:
f.write(file_contents)
except ValueError, e:
print('could not write file %s.' % e)
self.assertTrue(False)
def test_recipe_get_complex(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
rc = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
recipe_path = os.path.join(kitchen_dir, recipe_name)
self.assertTrue(os.path.exists(recipe_path))
# Modify the local file.
with open(os.path.join(recipe_path, "simple-file.txt"), 'a') as modify_file:
modify_file.write('new line\n')
modify_file.flush()
# Delete something local, so it's remote only.
os.remove(os.path.join(recipe_path, 'variations.json'))
os.remove(os.path.join(recipe_path, 'node1', 'data_sources', 'DKDataSource_NoOp.json'))
# Create a new file, so there is a local only file.
with open(os.path.join(recipe_path, "new_local_file.txt"), 'w') as new_local_file:
new_local_file.write('peccary\n')
new_local_file.flush()
subdir = os.path.join(recipe_path, 'subdir')
os.mkdir(subdir)
with open(os.path.join(subdir, "new_local_file_in_subdir.txt"), 'w') as new_local_file:
new_local_file.write('peccary\n')
new_local_file.flush()
rc = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name, recipe_path)
self.assertTrue(rc.ok())
msg = rc.get_message()
self.assertTrue('Auto-merging' in msg)
self.assertTrue('2 new or missing files' in msg)
if False:
shutil.rmtree(temp_dir, ignore_errors=True)
def test_order_list(self):
parent_kitchen = 'CLI-Top'
recipe_name = 'parallel-recipe-test'
variation_name = self._get_run_variation_for_recipe(recipe_name)
new_kitchen = 'test_order_list'
new_kitchen = self._add_my_guid(new_kitchen)
self._delete_and_clean_kitchen(new_kitchen)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rs.ok())
rs = DKCloudCommandRunner.create_order(self._api, new_kitchen, recipe_name, variation_name)
new_order_id_1 = rs.get_payload()['serving_chronos_id']
self.assertTrue(rs.ok())
rs = DKCloudCommandRunner.list_order(self._api, new_kitchen)
output_string = rs.rc['message']
self.assertTrue(new_order_id_1 in output_string)
found_completed_serving = False
wait_time = [.2, .5, .5, .5, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 10, 10]
for wt in wait_time:
rs = DKCloudCommandRunner.list_order(self._api, new_kitchen)
output_string = rs.rc['message']
n = output_string.count(new_order_id_1)
if n == 2 and ('OrderRun Completed' in output_string):
found_completed_serving = True
break
time.sleep(wt)
self.assertTrue(found_completed_serving)
# cleanup
self._delete_and_clean_kitchen(new_kitchen)
def test_order_list_for_repeating_order(self):
parent_kitchen = 'master'
recipe_name = 'parallel-recipe-test'
variation_name = self._get_run_variation_for_recipe(recipe_name, repeater=True)
new_kitchen = 'test_order_list_for_repeating_order'
new_kitchen = self._add_my_guid(new_kitchen)
self._delete_and_clean_kitchen(new_kitchen)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rs.ok())
rs = DKCloudCommandRunner.create_order(self._api, new_kitchen, recipe_name, variation_name)
new_order_id_1 = rs.get_payload()
self.assertTrue(rs.ok())
found_completed_serving = False
wait_time = [10,61,61,61,61]
for wt in wait_time:
rs = DKCloudCommandRunner.list_order(self._api, new_kitchen)
output_string = rs.rc['message']
n = output_string.count(new_order_id_1)
if n >= 3 and ('OrderRun Completed' in output_string):
found_completed_serving = True
break
time.sleep(wt)
self.assertTrue(found_completed_serving)
# cleanup
self._delete_and_clean_kitchen(new_kitchen)
def test_rude(self):
tv = 'DKCloudCommand.rude = **rude**\n'
rv = DKCloudCommandRunner.rude(self._api)
self.assertIsNotNone(rv)
self.assertEqual(rv, tv)
rv = DKCloudCommandRunner.rude(BaseTestCloud)
self.assertIn('ERROR', rv)
def test_rude(self):
tv = 'DKCloudCommand.rude = **rude**\n'
rv = DKCloudCommandRunner.rude(self._api)
self.assertIsNotNone(rv)
self.assertEqual(rv, tv)
rv = DKCloudCommandRunner.rude(BaseTestCloud)
self.assertIn('ERROR', rv)
def test_create_kitchen(self):
parent = 'CLI-Top'
kitchen = 'temp-create-kitchen-Runner'
kitchen = self._add_my_guid(kitchen)
rv = DKCloudCommandRunner.delete_kitchen(self._api, kitchen)
self.assertIsNotNone(rv)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent, kitchen)
self.assertTrue(rv.ok())
rc = DKCloudCommandRunner.list_kitchen(self._api)
rv2 = rc.get_message()
self.assertTrue(kitchen in rv2)
# cleanup
rv = DKCloudCommandRunner.delete_kitchen(self._api, kitchen)
self.assertIsNotNone(rv)
def test_get_compiled_serving_from_recipe(self):
# setup
parent_kitchen = 'master'
new_kitchen = 'test_get_compiled_serving_from_recipe=API'
new_kitchen = self._add_my_guid(new_kitchen)
recipe_name = 'parallel-recipe-test'
variation_name = 'variation-test'
self._delete_and_clean_kitchen(new_kitchen)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rs.ok())
# test
resp = DKCloudCommandRunner.get_compiled_serving(self._api, parent_kitchen, recipe_name, variation_name)
self.assertTrue(resp.ok())
# cleanup
self._delete_and_clean_kitchen(new_kitchen)
def test_get_compiled_serving_from_recipe(self):
# setup
parent_kitchen = 'master'
new_kitchen = 'test_get_compiled_serving_from_recipe=API'
new_kitchen = self._add_my_guid(new_kitchen)
recipe_name = 'parallel-recipe-test'
variation_name = 'variation-test'
self._delete_and_clean_kitchen(new_kitchen)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rs.ok())
# test
resp = DKCloudCommandRunner.get_compiled_serving(self._api, parent_kitchen, recipe_name, variation_name)
self.assertTrue(resp.ok())
# cleanup
self._delete_and_clean_kitchen(new_kitchen)
def test_update_file(self):
# setup
parent_kitchen = 'CLI-Top'
test_kitchen = 'CLI-test_update_file'
test_kitchen = self._add_my_guid(test_kitchen)
recipe_name = 'simple'
recipe_file_key = recipe_name
file_name = 'description.json'
message = 'test update CLI-test_update_file'
api_file_key = file_name
update_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
# Cleanup old state
self._delete_and_clean_kitchen(test_kitchen)
# Get the original file. Helper function handles the directories.
original_file = self._get_recipe_file(parent_kitchen, recipe_name, recipe_file_key, file_name)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, test_kitchen)
self.assertTrue(rs.ok())
# Get the new kitchen to a temp folder
temp_dir, test_kitchen_dir = self._make_kitchen_dir(test_kitchen, change_dir=True)
new_kitchen_file = self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name,
test_kitchen_dir)
self.assertEqual(original_file, new_kitchen_file)
new_kitchen_file_dict = self._get_the_dict(new_kitchen_file)
new_kitchen_file_abspath = os.path.join(test_kitchen_dir, os.path.join(recipe_file_key, file_name))
new_kitchen_file_dict[test_kitchen] = update_str
new_kitchen_file2 = self._get_the_json_str(new_kitchen_file_dict)
with open(new_kitchen_file_abspath, 'w') as rfile:
rfile.seek(0)
rfile.truncate()
rfile.write(new_kitchen_file2)
# test
working_dir = os.path.join(test_kitchen_dir, recipe_name)
os.chdir(working_dir)
rc = DKCloudCommandRunner.update_file(self._api, test_kitchen, recipe_name, working_dir, message, api_file_key)
self.assertTrue(rc.ok())
new_kitchen_file3 = self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name)
self.assertEqual(new_kitchen_file2, new_kitchen_file3)
# cleanup
self._delete_and_clean_kitchen(test_kitchen)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_update_file(self):
# setup
parent_kitchen = 'CLI-Top'
test_kitchen = 'CLI-test_update_file'
test_kitchen = self._add_my_guid(test_kitchen)
recipe_name = 'simple'
recipe_file_key = recipe_name
file_name = 'description.json'
message = 'test update CLI-test_update_file'
api_file_key = file_name
update_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
# Cleanup old state
self._delete_and_clean_kitchen(test_kitchen)
# Get the original file. Helper function handles the directories.
original_file = self._get_recipe_file(parent_kitchen, recipe_name, recipe_file_key, file_name)
rs = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, test_kitchen)
self.assertTrue(rs.ok())
# Get the new kitchen to a temp folder
temp_dir, test_kitchen_dir = self._make_kitchen_dir(test_kitchen, change_dir=True)
new_kitchen_file = self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name,
test_kitchen_dir)
self.assertEqual(original_file, new_kitchen_file)
new_kitchen_file_dict = self._get_the_dict(new_kitchen_file)
new_kitchen_file_abspath = os.path.join(test_kitchen_dir, os.path.join(recipe_file_key, file_name))
new_kitchen_file_dict[test_kitchen] = update_str
new_kitchen_file2 = self._get_the_json_str(new_kitchen_file_dict)
with open(new_kitchen_file_abspath, 'w') as rfile:
rfile.seek(0)
rfile.truncate()
rfile.write(new_kitchen_file2)
# test
working_dir = os.path.join(test_kitchen_dir, recipe_name)
os.chdir(working_dir)
rc = DKCloudCommandRunner.update_file(self._api, test_kitchen, recipe_name, message, api_file_key)
self.assertTrue(rc.ok())
new_kitchen_file3 = self._get_recipe_file(test_kitchen, recipe_name, recipe_file_key, file_name)
self.assertEqual(new_kitchen_file2, new_kitchen_file3)
# cleanup
self._delete_and_clean_kitchen(test_kitchen)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_recipe_get_negative(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple_fogfogkfok'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
rc = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
self.assertFalse(rc.ok())
self.assertTrue('not in kitchen' in rc.get_message().lower())
shutil.rmtree(temp_dir, ignore_errors=True)
def test_recipe_get_negative(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple_fogfogkfok'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
rc = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
self.assertFalse(rc.ok())
self.assertTrue('Unable to find recipe %s' % recipe_name in rc.get_message())
shutil.rmtree(temp_dir, ignore_errors=True)
def test_print_test_results(self):
# good for more than acive
rdict = pickle.loads(open("files/completed_serving_rdict.p", "rb").read().replace('\r', ''))
# rdict = pickle.load(open("files/completed_serving_rdict_eg.p", "rb"))
rs = DKCloudCommandRunner._print_test_results(rdict)
# look for some strings so you know it worked
# but don't look for too much so the test breaks if we re-format
print rs
self.assertTrue('File' in rs)
def test_print_test_results(self):
# good for more than acive
rdict = pickle.loads(open("files/completed_serving_rdict.p", "rb").read().replace('\r', ''))
# rdict = pickle.load(open("files/completed_serving_rdict_eg.p", "rb"))
rs = DKCloudCommandRunner._print_test_results(rdict)
# look for some strings so you know it worked
# but don't look for too much so the test breaks if we re-format
print rs
self.assertTrue('File' in rs)
def test_which_kitchen(self):
temp_dir = tempfile.mkdtemp(prefix='unit-tests', dir=self._TEMPFILE_LOCATION)
kn = 'fake'
kp = os.path.join(temp_dir, kn)
os.makedirs(kp)
dk = os.path.join(kp, '.dk')
os.makedirs(dk)
with open(os.path.join(dk, 'KITCHEN_META'), 'w') as meta:
meta.write(kn)
rv = DKCloudCommandRunner.which_kitchen(self._api, path=kp)
self.assertIn('You are in', rv.get_message())
rv = DKCloudCommandRunner.which_kitchen(self._api, kp)
self.assertIn('You are in', rv.get_message())
rv = DKCloudCommandRunner.which_kitchen(temp_dir)
self.assertFalse(rv.ok())
def test_which_kitchen(self):
temp_dir = tempfile.mkdtemp(prefix='unit-tests', dir=self._TEMPFILE_LOCATION)
kn = 'fake'
kp = os.path.join(temp_dir, kn)
os.makedirs(kp)
dk = os.path.join(kp, '.dk')
os.makedirs(dk)
with open(os.path.join(dk, 'KITCHEN_META'), 'w') as meta:
meta.write(kn)
rv = DKCloudCommandRunner.which_kitchen(self._api, path=kp)
self.assertIn('You are in', rv.get_message())
rv = DKCloudCommandRunner.which_kitchen(self._api, kp)
self.assertIn('You are in', rv.get_message())
rv = DKCloudCommandRunner.which_kitchen(temp_dir)
self.assertFalse(rv.ok())
def test_recipe_list(self):
tv1 = 's3-small-recipe'
tv2 = 'simple'
tv3 = 'parallel-recipe-test'
rc = DKCloudCommandRunner.list_recipe(self._api, 'CLI-Top')
rv = rc.get_message()
self.assertTrue(tv1 in rv)
self.assertTrue(tv2 in rv)
self.assertTrue(tv3 in rv)
def test_recipe_get(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
rv = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
self.assertTrue(recipe_name in rv.get_message())
self.assertTrue('sections' in rv.get_message())
self.assertTrue(os.path.exists(os.path.join(kitchen_dir, recipe_name)))
shutil.rmtree(temp_dir, ignore_errors=True)
def test_recipe_get(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
rv = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
self.assertTrue(recipe_name in rv.get_message())
self.assertTrue('sections' in rv.get_message())
self.assertTrue(os.path.exists(os.path.join(kitchen_dir, recipe_name)))
shutil.rmtree(temp_dir, ignore_errors=True)
def test_recipe_list(self):
tv1 = 's3-small-recipe'
tv2 = 'simple'
tv3 = 'parallel-recipe-test'
rc = DKCloudCommandRunner.list_recipe(self._api, 'CLI-Top')
rv = rc.get_message()
self.assertTrue(tv1 in rv)
self.assertTrue(tv2 in rv)
self.assertTrue(tv3 in rv)
def test_kitchen_config(self):
parent_kitchen = 'CLI-Top'
child_kitchen = self._add_my_guid('modify_kitchen_settings_runner')
setup = True
if setup:
self._delete_and_clean_kitchen(child_kitchen)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, child_kitchen)
self.assertTrue(rv.ok())
add = (('newvar1', 'newval1'),)
unset = ('newvar1')
get = ('newvar1')
listall = True
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, add=add)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
self.assertTrue('newvar1 added' in message)
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, get=get)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
self.assertTrue(message == 'newval1\n')
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, unset=unset)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, listall=listall)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
self.assertTrue('newvar1' not in message)
cleanup = False
if cleanup:
self._delete_and_clean_kitchen(child_kitchen)
def test_kitchen_config(self):
parent_kitchen = 'CLI-Top'
child_kitchen = self._add_my_guid('modify_kitchen_settings_runner')
setup = True
if setup:
self._delete_and_clean_kitchen(child_kitchen)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, child_kitchen)
self.assertTrue(rv.ok())
add = (('newvar1', 'newval1'),)
unset = ('newvar1')
get = ('newvar1')
listall = True
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, add=add)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
self.assertTrue('newvar1 added' in message)
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, get=get)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
self.assertTrue(message == 'newval1\n')
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, unset=unset)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
rs = DKCloudCommandRunner.config_kitchen(self._api, child_kitchen, listall=listall)
self.assertTrue(rs.ok())
payload = rs.get_payload()
self.assertIsNotNone(payload)
message = rs.get_message()
self.assertTrue('newvar1' not in message)
cleanup = False
if cleanup:
self._delete_and_clean_kitchen(child_kitchen)
def test_merge_kitchens_improved_success(self):
to_kitchen = 'dummy'
from_kitchen = 'merge_success'
mock_api = DKCloudAPIMock(self._cr_config)
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, from_kitchen, to_kitchen)
self.assertTrue('1 files changed' in rv.get_message())
self.assertTrue('1 insertions(+)' in rv.get_message())
self.assertTrue('0 deletions(-)' in rv.get_message())
def test_merge_kitchens_improved_conflicts(self):
to_kitchen_pickle = 'dummy'
from_kitchen_pickle = 'merge_conflicts'
mock_api = DKCloudAPIMock(self._cr_config)
# This one tests just a print
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, from_kitchen_pickle, to_kitchen_pickle)
self.assertTrue('1 conflict found' in rv.get_message())
self.assertTrue('conflicted-file.txt' in rv.get_message())
# Do the merge and put it down into a folder
parent_kitchen = 'merge-parent_ut_6d887fc6'
child_kitchen = 'merge-child_ut_6d887fc6'
recipe_name = 'simple'
temp_dir, kitchen_dir, recipe_dir = self._make_recipe_dir(recipe_name, child_kitchen)
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, child_kitchen, parent_kitchen)
msg = rv.get_message()
self.assertTrue('1 conflict found' in msg)
self.assertTrue('conflicted-file.txt' in msg)
with open(os.path.join(recipe_dir, 'conflicted-file.txt'), 'r') as conflicted_file:
contents = conflicted_file.read()
self.assertTrue('<<<<<<< your conflicted-file.txt' in contents)
self.assertTrue('>>>>>>> their conflicted-file.txt' in contents)
self.assertTrue('=======' in contents)
# Now make sure it tells use there are unresolved conflicts the next time we try and merge
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, child_kitchen, parent_kitchen)
self.assertTrue('Unresolved conflicts' in rv.rc['message'])
self.assertTrue('conflicted-file.txt' in rv.rc['message'])
# Resolve the conflict
rc = DKCloudCommandRunner.resolve_conflict('conflicted-file.txt')
self.assertTrue(rc.ok())
# Now the conflict should be gone, and we should be back to the found conflicts and written to disk message.
rc = DKCloudCommandRunner.merge_kitchens_improved(mock_api, child_kitchen, parent_kitchen)
msg = rc.get_message()
self.assertTrue('Unresolved conflicts' not in msg)
self.assertTrue('1 conflict found' in msg)
self.assertTrue('conflicted-file.txt' in msg)
if temp_dir is not None and temp_dir != '/':
shutil.rmtree(temp_dir)
def test_merge_kitchens_improved_conflicts(self):
to_kitchen_pickle = 'dummy'
from_kitchen_pickle = 'merge_conflicts'
mock_api = DKCloudAPIMock(self._cr_config)
# This one tests just a print
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, from_kitchen_pickle, to_kitchen_pickle)
self.assertTrue('1 conflict found' in rv.get_message())
self.assertTrue('conflicted-file.txt' in rv.get_message())
# Do the merge and put it down into a folder
parent_kitchen = 'merge-parent_ut_6d887fc6'
child_kitchen = 'merge-child_ut_6d887fc6'
recipe_name = 'simple'
temp_dir, kitchen_dir, recipe_dir = self._make_recipe_dir(recipe_name, child_kitchen)
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, child_kitchen, parent_kitchen)
msg = rv.get_message()
self.assertTrue('1 conflict found' in msg)
self.assertTrue('conflicted-file.txt' in msg)
with open(os.path.join(recipe_dir, 'conflicted-file.txt'), 'r') as conflicted_file:
contents = conflicted_file.read()
self.assertTrue('<<<<<<< your conflicted-file.txt' in contents)
self.assertTrue('>>>>>>> their conflicted-file.txt' in contents)
self.assertTrue('=======' in contents)
# Now make sure it tells use there are unresolved conflicts the next time we try and merge
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, child_kitchen, parent_kitchen)
self.assertTrue('Unresolved conflicts' in rv.rc['message'])
self.assertTrue('conflicted-file.txt' in rv.rc['message'])
# Resolve the conflict
rc = DKCloudCommandRunner.resolve_conflict('conflicted-file.txt')
self.assertTrue(rc.ok())
# Now the conflict should be gone, and we should be back to the found conflicts and written to disk message.
rc = DKCloudCommandRunner.merge_kitchens_improved(mock_api, child_kitchen, parent_kitchen)
msg = rc.get_message()
self.assertTrue('Unresolved conflicts' not in msg)
self.assertTrue('1 conflict found' in msg)
self.assertTrue('conflicted-file.txt' in msg)
if temp_dir is not None and temp_dir != '/':
shutil.rmtree(temp_dir)
def test_merge_kitchens_improved_success(self):
to_kitchen = 'dummy'
from_kitchen = 'merge_success'
mock_api = DKCloudAPIMock(self._cr_config)
rv = DKCloudCommandRunner.merge_kitchens_improved(mock_api, from_kitchen, to_kitchen)
self.assertTrue('1 files changed' in rv.get_message())
self.assertTrue('1 insertions(+)' in rv.get_message())
self.assertTrue('0 deletions(-)' in rv.get_message())
def test_active_serving_watcher(self):
# setup
parent = 'master'
kitchen = 'test_active_serving_watcher'
kitchen = self._add_my_guid(kitchen)
recipe_name = 'test-everything-recipe'
variation_name = self._get_run_variation()
self._delete_and_clean_kitchen(kitchen)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent, kitchen)
self.assertTrue(rv.ok())
# start watcher
DKActiveServingWatcherSingleton().set_sleep_time(2)
DKActiveServingWatcherSingleton().set_api(self._api)
DKActiveServingWatcherSingleton().set_kitchen(kitchen)
self.assertTrue(DKActiveServingWatcherSingleton().start_watcher())
# cook one
rs = DKCloudCommandRunner.create_order(self._api, kitchen, recipe_name, variation_name)
self.assertTrue(rs.ok())
wait_time = [.1, 1, 3, 3, 3, 3, 9, 18]
found_active_serving = False
wait_generator = (wt for wt in wait_time if found_active_serving is False)
print 'test_active_serving_watcher: found_active_serving, trying ... '
for wt in wait_generator:
time.sleep(wt)
resp1 = DKCloudCommandRunner.orderrun_detail(self._api, kitchen, {'summary': True})
print 'test_active_serving_watcher: found_active_serving is False (%s)' % wt
# print 'got', resp1.get_message()
message = resp1.get_message()
if resp1.ok():
message_split = message.split('\n')
if message_split is not None and len(message_split) > 10 and \
'ORDER RUN SUMMARY' in message_split[1] and \
'Order ID' in message_split[3] and 'DKRecipe#dk#test-everything-recipe#variation-test#' in message_split[3] and \
'Order Run ID' in message_split[4] and 'ct:' in message_split[4] and 'DKRecipe#dk#test-everything-recipe#variation-test#' in message_split[4] and \
'Status' in message_split[5] and 'COMPLETED_SERVING' in message_split[5]:
found_active_serving = True
self.assertTrue(found_active_serving)
# cleanup
self._delete_and_clean_kitchen(kitchen)
def test_recipe_status(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
new_path = os.path.join(kitchen_dir, recipe_name)
os.chdir(new_path)
rc = DKCloudCommandRunner.recipe_status(self._api, kitchen_name, recipe_name)
rs = rc.get_message()
self.assertNotRegexpMatches(rs, '^ERROR')
matches = re.match(r"([0-9]*) files are unchanged", rs)
self.assertTrue(int(matches.group(1)) >= 16)
self.assertTrue('files are unchanged' in rs)
# Modify existing file
with open(os.path.join(new_path, 'node1/description.json'), 'w') as f:
f.write('BooGa BooGa')
# Add a new file
with open(os.path.join(new_path, 'node1/newfile.json'), 'w') as f:
f.write('This is my new file. Hooray!')
# Delete a file
os.remove(os.path.join(new_path, 'node1/post_condition.json'))
# Remove a directory
shutil.rmtree(os.path.join(new_path, 'node1/data_sinks'))
rc = DKCloudCommandRunner.recipe_status(self._api, kitchen_name, recipe_name)
rs = rc.get_message()
self.assertNotRegexpMatches(rs, '^ERROR')
match = re.search(r"([0-9]*) files are unchanged", rs)
self.assertTrue(int(match.group(1)) >= 15)
self.assertTrue('files are unchanged' in rs)
self.assertTrue('1 files are modified' in rs)
self.assertTrue('1 files are local only' in rs)
self.assertTrue('2 files are remote only' in rs)
self.assertTrue('1 directories are remote only' in rs)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_recipe_status(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir = self._make_kitchen_dir(kitchen_name, change_dir=True)
DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
new_path = os.path.join(kitchen_dir, recipe_name)
os.chdir(new_path)
rc = DKCloudCommandRunner.recipe_status(self._api, kitchen_name, recipe_name)
rs = rc.get_message()
self.assertNotRegexpMatches(rs, '^ERROR')
matches = re.match(r"([0-9]*) files are unchanged", rs)
self.assertTrue(int(matches.group(1)) >= 16)
self.assertTrue('files are unchanged' in rs)
# Modify existing file
with open(os.path.join(new_path, 'node1/description.json'), 'w') as f:
f.write('BooGa BooGa')
# Add a new file
with open(os.path.join(new_path, 'node1/newfile.json'), 'w') as f:
f.write('This is my new file. Hooray!')
# Delete a file
os.remove(os.path.join(new_path, 'node1/post_condition.json'))
# Remove a directory
shutil.rmtree(os.path.join(new_path, 'node1/data_sinks'))
rc = DKCloudCommandRunner.recipe_status(self._api, kitchen_name, recipe_name)
rs = rc.get_message()
self.assertNotRegexpMatches(rs, '^ERROR')
match = re.search(r"([0-9]*) files are unchanged", rs)
self.assertTrue(int(match.group(1)) >= 15)
self.assertTrue('files are unchanged' in rs)
self.assertTrue('1 files are modified' in rs)
self.assertTrue('1 files are local only' in rs)
self.assertTrue('1 files are remote only' in rs)
self.assertTrue('1 directories are remote only' in rs)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_recipe_get_dir_exists(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir, recipe_dir = self._make_recipe_dir(recipe_name, kitchen_name, change_dir=True)
rv = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
msg = rv.get_message()
self.assertTrue(recipe_name in msg)
matches = re.match(r"([0-9]*) new or missing files", msg)
self.assertTrue(int(matches.group(1)) >= 16)
self.assertTrue('new or missing files' in msg)
self.assertTrue(os.path.exists(os.path.join(kitchen_dir, recipe_name)))
shutil.rmtree(temp_dir, ignore_errors=True)
def test_a_list_kitchens(self):
tv1 = 'CLI-Top'
tv2 = 'kitchens-plus'
tv3 = 'master'
# tv = 'DKCloudCommand.kitchens returned 3 kitchens\n base-test-kitchen \n kitchens-plus \n master \n'
rc = DKCloudCommandRunner.list_kitchen(self._api)
self.assertTrue(rc.ok())
rv = rc.get_message()
self.assertTrue(isinstance(rv, basestring))
self.assertTrue(tv1 in rv)
self.assertTrue(tv2 in rv)
self.assertTrue(tv3 in rv)
def test_a_list_kitchens(self):
tv1 = 'CLI-Top'
tv2 = 'kitchens-plus'
tv3 = 'master'
# tv = 'DKCloudCommand.kitchens returned 3 kitchens\n base-test-kitchen \n kitchens-plus \n master \n'
rc = DKCloudCommandRunner.list_kitchen(self._api)
self.assertTrue(rc.ok())
rv = rc.get_message()
self.assertTrue(isinstance(rv, basestring))
self.assertTrue(tv1 in rv)
self.assertTrue(tv2 in rv)
self.assertTrue(tv3 in rv)
def test_recipe_get_dir_exists(self):
kitchen_name = 'CLI-Top'
recipe_name = 'simple'
temp_dir, kitchen_dir, recipe_dir = self._make_recipe_dir(recipe_name, kitchen_name, change_dir=True)
rv = DKCloudCommandRunner.get_recipe(self._api, kitchen_name, recipe_name)
msg = rv.get_message()
self.assertTrue(recipe_name in msg)
matches = re.match(r"([0-9]*) new or missing files", msg)
self.assertTrue(int(matches.group(1)) >= 16)
self.assertTrue('new or missing files' in msg)
self.assertTrue(os.path.exists(os.path.join(kitchen_dir, recipe_name)))
shutil.rmtree(temp_dir, ignore_errors=True)
def test_active_serving_watcher(self):
# setup
parent = 'master'
kitchen = 'test_active_serving_watcher'
kitchen = self._add_my_guid(kitchen)
recipe_name = 'test-everything-recipe'
variation_name = self._get_run_variation()
self._delete_and_clean_kitchen(kitchen)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent, kitchen)
self.assertTrue(rv.ok())
# start watcher
DKActiveServingWatcherSingleton().set_sleep_time(2)
DKActiveServingWatcherSingleton().set_api(self._api)
DKActiveServingWatcherSingleton().set_kitchen(kitchen)
self.assertTrue(DKActiveServingWatcherSingleton().start_watcher())
# cook one
rs = DKCloudCommandRunner.create_order(self._api, kitchen, recipe_name, variation_name)
self.assertTrue(rs.ok())
wait_time = [.1, 1, 3, 3, 3, 3, 9, 18]
found_active_serving = False
wait_generator = (wt for wt in wait_time if found_active_serving is False)
print 'test_active_serving_watcher: found_active_serving, trying ... '
for wt in wait_generator:
time.sleep(wt)
resp1 = DKCloudCommandRunner.orderrun_detail(self._api, kitchen, {'summary': True})
print 'test_active_serving_watcher: found_active_serving is False (%s)' % wt
# print 'got', resp1.get_message()
message = resp1.get_message()
if resp1.ok() and ('OrderRun is Planned' in message or 'OrderRun Completed' in message
or 'OrderRun is Active' in message):
found_active_serving = True
self.assertTrue(found_active_serving)
# cleanup
self._delete_and_clean_kitchen(kitchen)
def test_active_serving_watcher(self):
# setup
parent = 'master'
kitchen = 'test_active_serving_watcher'
kitchen = self._add_my_guid(kitchen)
recipe_name = 'test-everything-recipe'
variation_name = self._get_run_variation()
self._delete_and_clean_kitchen(kitchen)
rv = DKCloudCommandRunner.create_kitchen(self._api, parent, kitchen)
self.assertTrue(rv.ok())
# start watcher
DKActiveServingWatcherSingleton().set_sleep_time(2)
DKActiveServingWatcherSingleton().set_api(self._api)
DKActiveServingWatcherSingleton().set_kitchen(kitchen)
self.assertTrue(DKActiveServingWatcherSingleton().start_watcher())
# cook one
rs = DKCloudCommandRunner.create_order(self._api, kitchen, recipe_name, variation_name)
self.assertTrue(rs.ok())
wait_time = [.1, 1, 3, 3, 3, 3, 9, 18]
found_active_serving = False
wait_generator = (wt for wt in wait_time if found_active_serving is False)
print('test_active_serving_watcher: found_active_serving, trying ... ')
for wt in wait_generator:
time.sleep(wt)
resp1 = DKCloudCommandRunner.orderrun_detail(self._api, kitchen, {'summary': True})
print('test_active_serving_watcher: found_active_serving is False (%s)' % wt)
# print 'got', resp1.get_message()
message = resp1.get_message()
if resp1.ok() and ('OrderRun is Planned' in message or 'OrderRun Completed' in message
or 'OrderRun is Active' in message):
found_active_serving = True
self.assertTrue(found_active_serving)
# cleanup
self._delete_and_clean_kitchen(kitchen)
def test_merge_kitchens_success(self):
existing_kitchen_name = 'master'
base_test_kitchen_name = 'base-test-kitchen'
branched_test_kitchen_name = 'branched-from-base-test-kitchen'
base_test_kitchen_name = self._add_my_guid(base_test_kitchen_name)
branched_test_kitchen_name = self._add_my_guid(branched_test_kitchen_name)
# setup
self._delete_and_clean_kitchen(branched_test_kitchen_name)
self._delete_and_clean_kitchen(base_test_kitchen_name)
# test
# create base kitchen
rs = DKCloudCommandRunner.create_kitchen(self._api, existing_kitchen_name, base_test_kitchen_name)
self.assertTrue(rs.ok())
# create branch kitchen from base kitchen
rs = DKCloudCommandRunner.create_kitchen(self._api, base_test_kitchen_name, branched_test_kitchen_name)
self.assertTrue(rs.ok())
# do merge
rd = DKCloudCommandRunner.merge_kitchens_improved(self._api, branched_test_kitchen_name, base_test_kitchen_name)
self._check_no_merge_conflicts(rd)
# cleanup
self._delete_and_clean_kitchen(branched_test_kitchen_name)
self._delete_and_clean_kitchen(base_test_kitchen_name)
def test_get_kitchen(self):
tk = 'CLI-Top'
temp_dir = tempfile.mkdtemp(prefix='unit-tests', dir=self._TEMPFILE_LOCATION)
kitchen_path = os.path.join(temp_dir, tk)
os.makedirs(kitchen_path)
# kitchen dir already has a folder in it.
bad_path = os.path.join(kitchen_path, 'bad')
os.makedirs(bad_path)
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertFalse(rv.ok())
shutil.rmtree(bad_path, ignore_errors=True)
# kitchen dir already has a file in it.
with open(os.path.join(kitchen_path, 'bad.txt'), 'w') as bad_file:
bad_file.write('bad.txt')
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertFalse(rv.ok())
shutil.rmtree(kitchen_path, ignore_errors=True)
# kitchen dir exists, but is empty
kitchen_path = os.path.join(temp_dir, tk)
os.makedirs(kitchen_path)
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertTrue(rv.ok())
self.assertEqual(os.path.isdir(os.path.join(kitchen_path, '.dk')), True)
shutil.rmtree(kitchen_path, ignore_errors=True)
# kitchen dir does not exists.
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertTrue(rv.ok())
self.assertEqual(os.path.isdir(os.path.join(kitchen_path, '.dk')), True)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_get_kitchen(self):
tk = 'CLI-Top'
temp_dir = tempfile.mkdtemp(prefix='unit-tests', dir=self._TEMPFILE_LOCATION)
kitchen_path = os.path.join(temp_dir, tk)
os.makedirs(kitchen_path)
# kitchen dir already has a folder in it.
bad_path = os.path.join(kitchen_path, 'bad')
os.makedirs(bad_path)
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertFalse(rv.ok())
shutil.rmtree(bad_path, ignore_errors=True)
# kitchen dir already has a file in it.
with open(os.path.join(kitchen_path, 'bad.txt'), 'w') as bad_file:
bad_file.write('bad.txt')
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertFalse(rv.ok())
shutil.rmtree(kitchen_path, ignore_errors=True)
# kitchen dir exists, but is empty
kitchen_path = os.path.join(temp_dir, tk)
os.makedirs(kitchen_path)
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertTrue(rv.ok())
self.assertEqual(os.path.isdir(os.path.join(kitchen_path, '.dk')), True)
shutil.rmtree(kitchen_path, ignore_errors=True)
# kitchen dir does not exists.
rv = DKCloudCommandRunner.get_kitchen(self._api, tk, temp_dir)
self.assertTrue(rv.ok())
self.assertEqual(os.path.isdir(os.path.join(kitchen_path, '.dk')), True)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_merge_kitchens_success(self):
existing_kitchen_name = 'master'
base_test_kitchen_name = 'base-test-kitchen'
branched_test_kitchen_name = 'branched-from-base-test-kitchen'
base_test_kitchen_name = self._add_my_guid(base_test_kitchen_name)
branched_test_kitchen_name = self._add_my_guid(branched_test_kitchen_name)
# setup
self._delete_and_clean_kitchen(branched_test_kitchen_name)
self._delete_and_clean_kitchen(base_test_kitchen_name)
# test
# create base kitchen
rs = DKCloudCommandRunner.create_kitchen(self._api, existing_kitchen_name, base_test_kitchen_name)
self.assertTrue(rs.ok())
# create branch kitchen from base kitchen
rs = DKCloudCommandRunner.create_kitchen(self._api, base_test_kitchen_name, branched_test_kitchen_name)
self.assertTrue(rs.ok())
# do merge
rd = DKCloudCommandRunner.merge_kitchens_improved(self._api, branched_test_kitchen_name, base_test_kitchen_name)
self._check_no_merge_conflicts(rd)
# cleanup
self._delete_and_clean_kitchen(branched_test_kitchen_name)
self._delete_and_clean_kitchen(base_test_kitchen_name)
def _get_recipe_file(self, kitchen, recipe_name, file_path, file_name, temp_dir=None):
delete_temp_dir = td = False
if temp_dir is None:
td, kitchen_dir = self._make_kitchen_dir(kitchen, change_dir=False)
delete_temp_dir = True
else:
kitchen_dir = temp_dir
rs = DKCloudCommandRunner.get_recipe(self._api, kitchen, recipe_name, kitchen_dir)
self.assertTrue(rs.ok())
the_path = os.path.join(kitchen_dir, os.path.join(file_path, file_name))
if os.path.isfile(the_path):
with open(the_path, 'r') as rfile:
rfile.seek(0)
the_file = rfile.read()
rc = the_file
else:
rc = None
if delete_temp_dir is True:
shutil.rmtree(td, ignore_errors=True)
return rc
def _get_recipe_file(self, kitchen, recipe_name, file_path, file_name, temp_dir=None):
delete_temp_dir = td = False
if temp_dir is None:
td, kitchen_dir = self._make_kitchen_dir(kitchen, change_dir=False)
delete_temp_dir = True
else:
kitchen_dir = temp_dir
rs = DKCloudCommandRunner.get_recipe(self._api, kitchen, recipe_name, kitchen_dir)
self.assertTrue(rs.ok())
the_path = os.path.join(kitchen_dir, os.path.join(file_path, file_name))
if os.path.isfile(the_path):
with open(the_path, 'r') as rfile:
rfile.seek(0)
the_file = rfile.read()
rc = the_file
else:
rc = None
if delete_temp_dir is True:
shutil.rmtree(td, ignore_errors=True)
return rc
def test_delete_one_order(self):
# setup
parent_kitchen = 'CLI-Top'
new_kitchen = 'test_deleteall_order-RUN'
new_kitchen = self._add_my_guid(new_kitchen)
recipe = 'simple'
variation = 'simple-variation-now'
DKCloudCommandRunner.delete_kitchen(self._api, new_kitchen) # clean up junk
rc = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rc.ok())
rv = DKCloudCommandRunner.create_order(self._api, new_kitchen, recipe, variation)
self.assertIsNotNone(rv)
order_id = rv.get_payload()
self.assertIsNotNone(variation in order_id)
# test
rc = DKCloudCommandRunner.delete_one_order(self._api, order_id)
self.assertTrue(rc.ok())
# cleanup
DKCloudCommandRunner.delete_kitchen(self._api, new_kitchen)
def test_delete_one_order(self):
# setup
parent_kitchen = 'CLI-Top'
new_kitchen = 'test_deleteall_order-RUN'
new_kitchen = self._add_my_guid(new_kitchen)
recipe = 'simple'
variation = 'simple-variation-now'
DKCloudCommandRunner.delete_kitchen(self._api, new_kitchen) # clean up junk
rc = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rc.ok())
rv = DKCloudCommandRunner.create_order(self._api, new_kitchen, recipe, variation)
self.assertIsNotNone(rv)
order_id = rv.get_payload()['serving_chronos_id']
self.assertIsNotNone(variation in order_id)
# test
rc = DKCloudCommandRunner.delete_one_order(self._api, order_id)
self.assertTrue(rc.ok())
# cleanup
DKCloudCommandRunner.delete_kitchen(self._api, new_kitchen)
def test_stop_order(self):
# setup
parent_kitchen = 'CLI-Top'
new_kitchen = 'test_stop_order-RUN'
new_kitchen = self._add_my_guid(new_kitchen)
recipe = 'simple'
variation = 'simple-variation-now'
DKCloudCommandRunner.delete_kitchen(self._api, new_kitchen) # clean up junk
rc = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen, new_kitchen)
self.assertTrue(rc.ok())
rv = DKCloudCommandRunner.create_order(self._api, new_kitchen, recipe, variation)
self.assertIsNotNone(rv)
order_id = rv.get_payload()
self.assertIsNotNone(variation in order_id)
# test
rc = DKCloudCommandRunner.stop_order(self._api, order_id)
# todo: need to find a way for this to succeed
self.assertTrue(rc.ok())
# cleanup
DKCloudCommandRunner.delete_kitchen(self._api, new_kitchen)
def test_create_order(self):
kitchen = 'CLI-Top'
recipe = 'simple'
variation = 'simple-variation-now'
rv = DKCloudCommandRunner.create_order(self._api, kitchen, recipe, variation)
self.assertTrue('simple' in rv.get_message())
def test_merge_resolution(self):
self.assertTrue(True)
base_kitchen = 'CLI-Top'
parent_kitchen = 'merge_resolve_parent'
parent_kitchen = self._add_my_guid(parent_kitchen)
child_kitchen = 'merge_resolve_child'
child_kitchen = self._add_my_guid(child_kitchen)
recipe = 'simple'
conflicted_file = 'conflicted-file.txt'
temp_dir_child, kitchen_dir_child, recipe_dir_child = self._make_recipe_dir(recipe, child_kitchen)
temp_dir_parent, kitchen_dir_parent, recipe_dir_parent = self._make_recipe_dir(recipe, parent_kitchen)
setup = True
cleanup = True
if setup:
rc = DKCloudCommandRunner.delete_kitchen(self._api, child_kitchen)
rc = DKCloudCommandRunner.delete_kitchen(self._api, parent_kitchen)
rc = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen=base_kitchen, new_kitchen=parent_kitchen)
self.assertTrue(rc.ok())
rc = DKCloudCommandRunner.create_kitchen(self._api, parent_kitchen=parent_kitchen, new_kitchen=child_kitchen)
self.assertTrue(rc.ok())
os.chdir(recipe_dir_parent)
# parent_file = os.path.join(recipe, conflicted_file)
with open(conflicted_file, 'w') as f:
f.write('line1\nparent\nline2\n')
rc = DKCloudCommandRunner.add_file(self._api, parent_kitchen, recipe, 'adding %s to %s' % (conflicted_file, parent_kitchen), conflicted_file)
self.assertTrue(rc.ok())
os.chdir(recipe_dir_child)
# child_file = os.path.join(recipe, conflicted_file)
with open(conflicted_file, 'w') as f:
f.write('line1\nchild\nline2\n')
rc = DKCloudCommandRunner.add_file(self._api, child_kitchen, recipe, 'adding %s to %s' % (conflicted_file, child_kitchen), conflicted_file)
self.assertTrue(rc.ok())
# Make sure we are in the recipe folder before merging
os.chdir(recipe_dir_child)
rc = DKCloudCommandRunner.merge_kitchens_improved(self._api, child_kitchen, parent_kitchen)
self.assertTrue('1 conflict found' in rc.get_message())
self.assertTrue('simple/conflicted-file.txt' in rc.get_message())
rc = DKCloudCommandRunner.merge_kitchens_improved(self._api, child_kitchen, parent_kitchen)
self.assertTrue('Unresolved conflicts' in rc.get_message())
self.assertTrue('conflicted-file.txt' in rc.get_message())
rc = DKCloudCommandRunner.get_unresolved_conflicts(recipe, recipe_dir_child)
self.assertTrue(rc.ok())
self.assertTrue('Unresolved conflicts' in rc.get_message())
rc = DKCloudCommandRunner.resolve_conflict(conflicted_file)
self.assertTrue(rc.ok())
self.assertTrue('Conflict resolved' in rc.get_message())
rc = DKCloudCommandRunner.get_unresolved_conflicts(recipe, recipe_dir_child)
self.assertTrue(rc.ok())
self.assertTrue('No conflicts found' in rc.get_message())
rc = DKCloudCommandRunner.merge_kitchens_improved(self._api, child_kitchen, parent_kitchen)
self.assertTrue('Unresolved conflicts' not in rc.get_message())
if cleanup:
DKCloudCommandRunner.delete_kitchen(self._api, child_kitchen)
DKCloudCommandRunner.delete_kitchen(self._api, parent_kitchen)
shutil.rmtree(temp_dir_child, ignore_errors=True)
shutil.rmtree(temp_dir_parent, ignore_errors=True)
def test_user_info(self):
rc = DKCloudCommandRunner.user_info(self._api)
self.assertTrue(rc.ok())
def _delete_and_clean_kitchen(self, kitchen_name):
DKCloudCommandRunner.delete_kitchen(self._api, kitchen_name)
