def test_upload_package(stderr, stdout):
with HTTMock(upload_packages_mock):
tool = packages.PackagesTool()
server = Server('localhost')
status = tool.execute(
server, ['packages', 'upload', 'tests/test_data/mock_package.zip'])
eq_(0, status)
eq_('my_packages\tmock-package\t1.0\n', stdout.getvalue())
eq_('', stderr.getvalue())
def test_uninstall_package(stderr, stdout):
with HTTMock(packages_mock):
tool = packages.PackagesTool()
server = Server('localhost')
status = tool.execute(server,
['packages', 'uninstall', 'mock_package'])
eq_(0, status)
eq_('', stdout.getvalue())
eq_('', stderr.getvalue())
def test_download(stderr, stdout):
with HTTMock(packages_mock):
tool = tool_repo.get_tool('package')
server = Server('localhost')
status = tool.execute(server, ['package', 'download', 'mock_package'])
eq_(0, status)
eq_('mock_package-1.6.5.zip\n', stdout.getvalue())
eq_('', stderr.getvalue())
url, request = get_command_stack()[-1]
eq_('/etc/packages/test_packages/mock_package-1.6.5.zip', url.path)
def test_file_does_not_exist(stderr, stdout):
tool = tool_repo.get_tool('config')
server = Server('localhost')
ret = tool.execute(
server, ['config', 'encrypt', '-f', 'thisisnotafile', 'localhost'])
eq_(USER_ERROR, ret)
eq_('error: Requested file thisisnotafile does not exist\n',
stderr.getvalue())
eq_('', stdout.getvalue())
def test_find_stdin(stderr, stdout):
with HTTMock(service_mock):
tool = get_tool('find')
server = Server('localhost')
status = tool.execute(server, ['find'])
eq_(0, status)
eq_(
'/content\n/content/path\n/content/path/node\n/content/path/directory\n',
stdout.getvalue())
eq_('', stderr.getvalue())
def test_set_property(stderr, stdout):
tool = tool_repo.get_tool('user')
server = Server('localhost')
with HTTMock(setprop_service_mock):
status = tool.execute(
server,
['user', 'setprop', 'jdoe', 'prop0=val0,prop1="Quoted value"'])
eq_(OK, status)
eq_('/home/users/j/jdoe\n', stdout.getvalue())
eq_('', stderr.getvalue())
def test_print_help(stderr, stdout):
tool = tool_repo.get_tool('user')
server = Server('localhost')
try:
status = tool.execute(server, ['user', '--help'])
except SystemExit as e:
status = e.code
eq_(0, status)
ok_(len(stdout.getvalue()) > 0)
eq_('', stderr.getvalue())
def test_format_config():
tmp_filepath = create_config()
tool = tool_repo.get_tool('config')
server = Server('localhost')
ret = tool.execute(server, ['config', 'format', '-f', tmp_filepath])
eq_(OK, ret)
new_config = load_config(tmp_filepath)
eq_(PLAINTEXT_CONFIG, new_config)
os.remove(tmp_filepath)
def test_command_does_not_exist(stderr, stdout):
_, tmp_filepath = tempfile.mkstemp(".rc")
tool = tool_repo.get_tool('config')
server = Server('localhost')
ret = tool.execute(server, ['config', 'somethingelse', '-f', tmp_filepath])
eq_(USER_ERROR, ret)
eq_("error: Unknown command 'somethingelse'\n", stderr.getvalue())
eq_('', stdout.getvalue())
os.remove(tmp_filepath)
def test_error_response(stderr, stdout):
with HTTMock(broken_service):
tool = get_tool('groovy')
server = Server('localhost')
status = tool.execute(server,
['groovy', 'tests/test_data/script.groovy'])
eq_(SERVER_ERROR, status)
eq_('', stdout.getvalue())
eq_(
'error: Failed to run script tests/test_data/script.groovy: error message\n',
stderr.getvalue())
def test_setprop_stdin(_, stdout):
service_mock = MockHttpService()
with HTTMock(service_mock):
tool = tool_repo.get_tool('setprop')
server = Server('localhost')
status = tool.execute(server, ['setprop', 'prop0=value0,prop1=value1'])
eq_(0, status)
eq_('/path0\n/path1\n', stdout.getvalue())
eq_(2, len(service_mock.req_log))
eq_({('prop1', 'value1'), ('prop0', 'value0')},
set(service_mock.req_log[0].body.fields))
def test_mv(stderr, stdout):
service_mock = MockHttpService()
with HTTMock(service_mock):
tool = tool_repo.get_tool('mv')
server = Server('localhost')
status = tool.execute(server, ['mv', '/content/src_node', '/content/dst_node'])
eq_(0, status)
eq_('/content/dst_node\n', stdout.getvalue())
eq_(1, len(service_mock.req_log))
eq_('/content/src_node', service_mock.url_log[0].path)
eq_('%3Aoperation=move&%3Adest=%2Fcontent%2Fdst_node', service_mock.req_log[0].body)
def test_list_packages(stdout):
with HTTMock(packages_mock):
tool = PackageTool()
server = Server('localhost')
tool.execute(server, ['package', 'list'])
i = 0
for line in EXPECTED_LIST:
eq_(line, untab(stdout.getvalue())[i])
i += 1
def test_upload_package_raw(stderr, stdout):
with HTTMock(upload_packages_mock):
tool = PackageTool()
server = Server('localhost')
status = tool.execute(
server,
['package', 'upload', '--raw', 'tests/test_data/mock_package.zip'])
eq_(0, status)
eq_('', stderr.getvalue())
eq_(True, len(stdout.getvalue()) > 0)
def test_install_package_raw(stderr, stdout):
with HTTMock(packages_mock):
tool = PackageTool()
server = Server('localhost')
status = tool.execute(server,
['package', 'install', '--raw', 'mock_package'])
eq_(0, status)
eq_('{"success": true, "msg": "Package Installed"}\n',
stdout.getvalue())
eq_('', stderr.getvalue())
def test_start_workflow(stderr, stdout):
wf_service = MockWorkflowsService()
service = MockHttpService(wf_service)
with HTTMock(service):
tool = get_tool('workflows')
server = Server('localhost')
status = tool.execute(server, ['workflows', 'start', '/dam/update_asset', '/content/dam/something/image.png'])
eq_('', stderr.getvalue())
eq_(stdout.getvalue().startswith('/dam/update_asset-'), True)
eq_(0, status)
def test_rcp_rm(stderr, stdout):
task_service = MockTaskService()
task_service.create_task('rcp-0ed9f8', 'rcp-0ed9f8')
service = MockHttpService(task_service)
with HTTMock(service):
tool = get_tool('rcp')
server = Server('localhost')
status = tool.execute(server, ['rcp', 'rm', 'rcp-0ed9f8'])
eq_(0, status)
eq_('', stdout.getvalue())
eq_('', stderr.getvalue())
def test_encrypt_password(random_bytes, getpass):
getpass.return_value = "foobarpass"
random_bytes.return_value = b'0123456789abcdef'
tmp_filepath = create_config()
tool = tool_repo.get_tool('config')
server = Server('localhost')
ret = tool.execute(server, ['config', 'encrypt', '-f', tmp_filepath, 'localhost'])
eq_(OK, ret)
new_config = load_config(tmp_filepath)
eq_(ENCRYPTED_CONFIG, new_config)
os.remove(tmp_filepath)
def test_build_package(stderr, stdout):
with HTTMock(packages_mock):
tool = tool_repo.get_tool('package')
server = Server('localhost')
status = tool.execute(server, ['package', 'build', 'mock_package'])
eq_(0, status)
eq_('', stdout.getvalue())
eq_('', stderr.getvalue())
url, request = get_command_stack()[-1]
eq_(
'/crx/packmgr/service/.json/etc/packages/test_packages/mock_package-1.6.5.zip',
url.path)
eq_('cmd=build', request.body)
def test_upload_package(stderr, stdout):
with HTTMock(upload_packages_mock):
tool = PackageTool()
server = Server('localhost')
status = tool.execute(
server, ['package', 'upload', 'tests/test_data/mock_package.zip'])
eq_(0, status)
eq_([
"my_packages", "mock-package", "1.0",
"Tue, 29 Sep 2015 16:20:59 -0400"
],
untab(stdout.getvalue())[0])
eq_('', stderr.getvalue())
def test_start_workflow(stderr, stdout):
wf_service = MockWorkflowsService()
service = MockWorkflowHttpService(wf_service)
with HTTMock(service):
tool = tool_repo.get_tool('workflow')
server = Server('localhost')
status = tool.execute(server, [
'workflow', 'start', '/dam/update_asset',
'/content/dam/something/image.png/jcr:content/renditions/original'
])
eq_('', stderr.getvalue())
ok_(stdout.getvalue().startswith('/dam/update_asset-'))
eq_(0, status)
def test_cat_stdin(stderr, stdout):
with HTTMock(service_mock):
tool = tool_repo.get_tool('cat')
server = Server('localhost')
status = tool.execute(server, ['cat'])
eq_(0, status)
exp = {
'text': "Something something",
'jcr:primaryType': 'nt:unstructured',
'title': 'Test Title'
}
eq_(exp, parse_cat(stdout.getvalue()))
eq_('', stderr.getvalue())
def test_encrypt_decrypt(random_bytes, getpass):
getpass.return_value = "somepassword"
random_bytes.return_value = b'fedcba0987654321'
tmp_filepath = create_config()
tool = tool_repo.get_tool('config')
server = Server('localhost')
ret = tool.execute(server, ['config', 'encrypt', '-f', tmp_filepath, 'localhost'])
eq_(OK, ret)
ret = tool.execute(server, ['config', 'decrypt', '-f', tmp_filepath, 'localhost'])
eq_(OK, ret)
data = load_config(tmp_filepath)
eq_(PLAINTEXT_CONFIG, data)
os.remove(tmp_filepath)
def test_stop_bundle(stderr, stdout):
global _expected_action
_expected_action = 'stop'
with HTTMock(mock_bundle):
tool = tool_repo.get_tool('bundle')
server = Server('localhost')
ret = tool.execute(server, ['bundle', 'stop', 'mock_bundle'])
eq_('', stdout.getvalue())
eq_('', stderr.getvalue())
eq_(None, ret)
ret = tool.execute(server, ['bundles', 'stop', '--raw', 'mock_bundle'])
eq_('{"fragment":false,"stateRaw":4}\n', stdout.getvalue())
eq_('', stderr.getvalue())
eq_(None, ret)
def test_mv_to_parent(stderr, stdout):
service_mock = MockHttpService()
with HTTMock(service_mock):
tool = tool_repo.get_tool('mv')
server = Server('localhost')
status = tool.execute(server, ['mv', '/content/src_node', '/backup/'])
eq_(0, status)
eq_('/backup/src_node\n', stdout.getvalue())
eq_(1, len(service_mock.req_log))
eq_('/content/src_node', service_mock.url_log[0].path)
exp = {
':operation': 'move',
':dest': '/backup/'
}
eq_(exp, parse_body(service_mock.req_log[0].body))
def test_rcp_stop(stderr, stdout):
task_service = MockTaskService()
task_service.create_task('rcp-0ed9f8', '/content/dam/something')
task_service.start_task('rcp-0ed9f8')
service = MockHttpService(task_service)
with HTTMock(service):
tool = get_tool('rcp')
server = Server('localhost')
# TODO: Run tests without force flag
status = tool.execute(server, ['rcp', 'stop', 'rcp-0ed9f8', '--force'])
eq_(0, status)
eq_('', stdout.getvalue())
eq_('', stderr.getvalue())
eq_('STOPPED', task_service.tasks['rcp-0ed9f8']['status']['state'])
def test_import_asset_directory(stderr, stdout):
http_service = MockHttpService()
lock_dir = tempfile.mkdtemp()
with HTTMock(http_service):
tool = AssetsTool()
server = Server('localhost')
status = tool.execute(server, [
'assets', '--lock-dir={}'.format(lock_dir), 'import',
'tests/test_data/assets'
])
eq_('', stderr.getvalue())
lines = stdout.getvalue().split('\n')
eq_(4, len(lines))
_is_valid_upload_line(lines[0], [
'2016-11-25 13:12:01', '1/3',
'tests/test_data/assets/logo.jpg -> /content/dam/assets', '0.0192'
])
_is_valid_upload_line(lines[1], [
'2016-11-25 13:12:01', '2/3',
'tests/test_data/assets/subdir/graph.jpg -> /content/dam/assets/subdir',
'0.0192'
])
_is_valid_upload_line(lines[2], [
'2016-11-25 13:12:01', '3/3',
'tests/test_data/assets/subdir/graph2.jpg -> /content/dam/assets/subdir',
'0.0192'
])
eq_(OK, status)
eq_(5, len(http_service.req_log))
eq_(http_service.req_log[0].url,
'http://localhost:4502/content/dam/assets')
eq_(http_service.req_log[1].url,
'http://localhost:4502/content/dam/assets.createasset.html')
eq_(http_service.req_log[2].url,
'http://localhost:4502/content/dam/assets/subdir')
eq_(http_service.req_log[3].url,
'http://localhost:4502/content/dam/assets/subdir.createasset.html')
# Skipped creating subdir for the second file
eq_(http_service.req_log[4].url,
'http://localhost:4502/content/dam/assets/subdir.createasset.html')
shutil.rmtree(lock_dir)
def test_rcp_fetch(stderr, stdout):
service = MockHttpService()
with HTTMock(service):
tool = get_tool('rcp')
server = Server('localhost')
# TODO: Run tests without force flag
status = tool.execute(server, [
'rcp', 'fetch', '-s', 'other-server:4502', '-c', '"jdoe:abc123"',
'/content/dam/test-fetch', '--force'
])
eq_('', stdout.getvalue())
eq_('', stderr.getvalue())
eq_(0, status)
eq_(['create', 'list', 'start', 'list', 'remove'],
service.task_service.log)
def test_touch_asset(stderr, stdout):
service = MockWorkflowsService()
http_service = MockWorkflowHttpService(service)
eq_([], http_service.request_log)
with HTTMock(http_service):
tool = AssetTool()
server = Server('localhost')
status = tool.execute(server, ['asset', 'touch', '/hosts/bernard.jpg'])
eq_('', stderr.getvalue())
eq_('/content/dam/hosts/bernard.jpg/jcr:content/renditions/original\n',
stdout.getvalue())
eq_(OK, status)
eq_(1, len(http_service.request_log))
eq_(('POST', '/etc/workflow/instances'),
typeof(http_service.request_log[0]))
eq_([], service.instances)
def test_import_asset_file(stderr, stdout):
http_service = RecordingHttpService()
lock_dir = tempfile.mkdtemp()
with HTTMock(http_service):
tool = AssetTool()
server = Server('localhost')
status = tool.execute(
server, ['asset', 'import', 'tests/test_data/assets/logo.jpg'])
eq_('', stderr.getvalue())
eq_(stdout.getvalue(), 'tests/test_data/assets/logo.jpg -> /assets\n')
eq_(OK, status)
eq_(2, len(http_service.req_log))
eq_(http_service.req_log[0].url, 'http://localhost:4502/api/assets/assets')
eq_(http_service.req_log[1].url,
'http://localhost:4502/api/assets/assets/logo.jpg')
shutil.rmtree(lock_dir)
