def test_aunit_program(self):
connection = Connection([
Response(status_code=200,
text=AUNIT_NO_TEST_RESULTS_XML,
headers={})
])
with patch('sap.cli.aunit.print') as mock_print:
sap.cli.aunit.run(
connection,
SimpleNamespace(type='program',
name='yprogram',
output='human'))
self.assertEqual(len(connection.execs), 1)
self.assertIn('programs/programs/yprogram', connection.execs[0].body)
self.assert_print_no_test_classes(mock_print)
def test_adt_wb_activate_object_fail(self):
adt_object = self.create_fake_object(FIXTURES_EXP_FULL_ADT_URI,
FIXTURES_EXP_OBJECT_NAME)
adt_object.connection = Connection([
Response(status_code=200,
text=FIXTURES_EXP_ERROR_RESPONSE,
headers={})
])
with self.assertRaises(SAPCliError) as caught:
sap.adt.wb.activate(adt_object)
self.assert_single_request(adt_object)
self.assertEqual(
str(caught.exception),
f'Could not activate the object {FIXTURES_EXP_OBJECT_NAME}: {FIXTURES_EXP_ERROR_RESPONSE}'
)
def test_create_with_config_update_instance(self):
self.conn.set_responses(
Response.with_json(status_code=201,
json={'repository': self.repo_server_data}))
repo = sap.rest.gcts.Repository(self.conn,
self.repo_name,
data={
'config': [{
'key': 'first_key',
'value': 'first_value'
}, {
'key': 'third_key',
'value': 'third_value'
}]
})
repo.create(self.repo_url,
self.repo_vsid,
config={
'second_key': 'second_value',
'third_key': 'fourth_value'
})
repo_request = dict(self.repo_request)
repo_request['data']['config'] = [
{
'key': 'first_key',
'value': 'first_value'
},
{
'key': 'third_key',
'value': 'fourth_value'
},
{
'key': 'second_key',
'value': 'second_value'
},
]
self.maxDiff = None
self.assertEqual(len(self.conn.execs), 1)
self.conn.execs[0].assertEqual(Request.post_json(
uri=f'repository', body=repo_request, accept='application/json'),
self,
json_body=True)
def test_get_config_no_config_ok(self):
self.conn.set_responses(
Response.with_json(status_code=200,
json={'result': self.repo_server_data}))
repo = sap.rest.gcts.Repository(self.conn, self.repo_name)
# This will fetch repo data from the server
value = repo.get_config('VCS_CONNECTION')
self.assertEqual(value, 'SSL')
# The second request does not causes an HTTP request
value = repo.get_config('VCS_CONNECTION')
self.assertEqual(value, 'SSL')
self.assertEqual(len(self.conn.execs), 1)
self.conn.execs[0].assertEqual(
Request.get_json(uri=f'repository/{self.repo_name}'), self)
def test_adt_program_fetch(self):
conn = Connection([
Response(text=GET_EXECUTABLE_PROGRAM_ADT_XML,
status_code=200,
headers={})
])
program = sap.adt.Program(conn, 'ZHELLO_WORLD')
program.fetch()
self.assertEqual(program.name, 'ZHELLO_WORLD')
self.assertEqual(program.active, 'active')
self.assertEqual(program.program_type, '1')
self.assertEqual(program.master_language, 'EN')
self.assertEqual(program.description, 'Say hello!')
self.assertEqual(program.logical_database.reference.name, 'D$S')
self.assertEqual(program.fix_point_arithmetic, True)
self.assertEqual(program.case_sensitive, True)
self.assertEqual(program.application_database, 'S')
def test_log_ok(self):
exp_commits = [{'id': '123'}]
self.conn.set_responses(
Response.with_json(status_code=200, json={'commits': exp_commits}))
repo = sap.rest.gcts.Repository(self.conn,
self.repo_name,
data=self.repo_server_data)
act_commits = repo.log()
self.assertIsNotNone(repo._data)
self.assertEqual(act_commits, exp_commits)
self.assertEqual(len(self.conn.execs), 1)
self.conn.execs[0].assertEqual(
Request.get_json(uri=f'repository/{self.repo_name}/getCommit'),
self)
def test_adt_wb_activate_children(self):
adt_object = self.create_fake_object(
'/sap/bc/adt/oo/classes/cl_hello_world', 'cl_hello_world', [
Response(
status_code=200,
text=INACTIVE_OBJECTS_XML,
headers={
'Content-Type':
'application/vnd.sap.adt.inactivectsobjects.v1+xml'
}), EMPTY_RESPONSE_OK
])
sap.adt.wb.activate(adt_object)
conn = adt_object.connection
self.assertEqual(conn.mock_methods(),
[('POST', '/sap/bc/adt/activation')] * 2)
self.assertEqual(sorted(conn.execs[0].headers),
['Accept', 'Content-Type'])
self.assertEqual(conn.execs[0].headers['Accept'], 'application/xml')
self.assertEqual(conn.execs[0].headers['Content-Type'],
'application/xml')
self.assertEqual(sorted(conn.execs[0].params),
['method', 'preauditRequested'])
self.assertEqual(conn.execs[0].params['method'], 'activate')
self.assertEqual(conn.execs[0].params['preauditRequested'], 'true')
self.assertEqual(sorted(conn.execs[1].headers),
['Accept', 'Content-Type'])
self.assertEqual(conn.execs[1].headers['Accept'], 'application/xml')
self.assertEqual(conn.execs[1].headers['Content-Type'],
'application/xml')
self.assertEqual(sorted(conn.execs[1].params),
['method', 'preauditRequested'])
self.assertEqual(conn.execs[1].params['method'], 'activate')
self.assertEqual(conn.execs[1].params['preauditRequested'], 'false')
self.maxDiff = None
self.assertEqual(conn.execs[0].body, PREAUDIT_ACTIVATION_XML)
self.assertEqual(conn.execs[1].body, ACTIVATION_REFERENCES_XML)
def test_adt_ddl_read(self):
conn = Connection([Response(text=FIXTURE_CDS_CODE,
status_code=200,
headers={'Content-Type': 'text/plain; charset=utf-8'})])
ddl = sap.adt.DataDefinition(conn, name='MyUsers')
code = ddl.text
self.assertEqual(conn.mock_methods(), [('GET', '/sap/bc/adt/ddic/ddl/sources/myusers/source/main')])
get_request = conn.execs[0]
self.assertEqual(sorted(get_request.headers), ['Accept'])
self.assertEqual(get_request.headers['Accept'], 'text/plain')
self.assertIsNone(get_request.params)
self.assertIsNone(get_request.body)
self.maxDiff = None
self.assertEqual(code, FIXTURE_CDS_CODE)
def test_workbench_list_transport(self):
connection = Connection([Response(SHORTENED_WORKBENCH_XML, 200, {})],
user='******')
with patch('sys.stdout', new_callable=StringIO) as fake_output:
sap.cli.cts.print_list(
connection,
SimpleNamespace(type='transport',
recursive=0,
owner=None,
number=None))
self.assertEqual([(request.adt_uri, request.params['user'])
for request in connection.execs],
[('/sap/bc/adt/cts/transportrequests', 'ANZEIGER')])
self.assertEqual(
fake_output.getvalue(),
f'{TRANSPORT_NUMBER} D FILAK Transport Description\n')
def test_simple_clone_without_params_create_exists(self):
log_builder = LogBuilder()
log_builder.log_error(
make_gcts_log_error(
'20200923111743: Error action CREATE_REPOSITORY Repository already exists'
))
log_builder.log_exception('Cannot create', 'EEXIST').get_contents()
messages = log_builder.get_contents()
self.conn.set_responses(
[Response.with_json(status_code=500, json=messages)])
with self.assertRaises(
sap.rest.gcts.GCTSRepoAlreadyExistsError) as caught:
sap.rest.gcts.simple_clone(self.conn, self.repo_url,
self.repo_name)
self.assertEqual(str(caught.exception),
'gCTS exception: Cannot create')
def test_create_task(self):
self.connection.set_responses(
Response(status_code=201, text=TASK_CREATE_OK_RESPONSE))
self.task_1._number = None
self.task_1._transport = self.transport.number
self.task_1.create()
self.maxDiff = None
self.assertEqual(len(self.connection.execs), 1)
self.connection.execs[0].assertEqual(Request.post_text(
uri=
f'/sap/bc/adt/cts/transportrequests/{self.task_1.transport}/tasks',
accept='application/vnd.sap.adt.transportorganizer.v1+xml',
body=f'''<?xml version="1.0" encoding="ASCII"?>
<tm:root xmlns:tm="http://www.sap.com/cts/adt/tm" tm:number="{self.task_1.transport}" tm:targetuser="******" tm:useraction="newtask"/>
'''),
asserter=self)
self.assertEqual(self.task_1.number, TASK_NUMBER)
def test_create_with_role_and_type(self):
self.conn.set_responses(
Response.with_json(status_code=201,
json={'repository': self.repo_server_data}))
repo = sap.rest.gcts.Repository(self.conn, self.repo_name)
repo.create(self.repo_url, self.repo_vsid, role='TARGET', typ='GIT')
repo_request = dict(self.repo_request)
repo_request['data']['role'] = 'TARGET'
repo_request['data']['type'] = 'GIT'
self.maxDiff = None
self.assertEqual(len(self.conn.execs), 1)
self.conn.execs[0].assertEqual(Request.post_json(
uri=f'repository', body=repo_request, accept='application/json'),
self,
json_body=True)
def test_adt_class_fetch(self):
conn = Connection([
Response(
text=GET_INTERFACE_ADT_XML,
status_code=200,
headers={
'Content-Type':
'application/vnd.sap.adt.oo.interfaces.v2+xml; charset=utf-8'
})
])
intf = sap.adt.Interface(conn, 'ZIF_HELLO_WORLD')
intf.fetch()
self.assertEqual(intf.name, 'ZIF_HELLO_WORLD')
self.assertEqual(intf.active, 'active')
self.assertEqual(intf.master_language, 'EN')
self.assertEqual(intf.description, 'You cannot stop me!')
self.assertEqual(intf.modeled, False)
def test_fmod_chattr_rfc(self):
connection = Connection([
Response(
text=GET_FUNCTION_MODULE_ADT_XML,
status_code=200,
headers={
'Content-Type':
'application/vnd.sap.adt.functions.fmodules.v2+xml; charset=utf-8'
}), LOCK_RESPONSE_OK, EMPTY_RESPONSE_OK, EMPTY_RESPONSE_OK
])
args = fm_parse_args('chattr', 'ZFG_HELLO_WORLD', 'Z_FN_HELLO_WORLD',
'-t', 'rfc')
args.execute(connection, args)
self.assertEqual([
(e.method, e.adt_uri) for e in connection.execs
], [(
'GET',
'/sap/bc/adt/functions/groups/zfg_hello_world/fmodules/z_fn_hello_world'
),
('POST',
'/sap/bc/adt/functions/groups/zfg_hello_world/fmodules/z_fn_hello_world'
),
('PUT',
'/sap/bc/adt/functions/groups/zfg_hello_world/fmodules/z_fn_hello_world'
),
('POST',
'/sap/bc/adt/functions/groups/zfg_hello_world/fmodules/z_fn_hello_world'
)])
put_req = connection.execs[2]
self.assertEqual(sorted(put_req.headers.keys()), ['Content-Type'])
self.assertEqual(put_req.headers['Content-Type'],
'application/vnd.sap.adt.functions.fmodules.v2+xml')
self.assertEqual(sorted(put_req.params.keys()), ['lockHandle'])
self.assertEqual(put_req.params['lockHandle'], 'win')
self.maxDiff = None
self.assertEqual(put_req.body, PUT_FUNCITON_MODULE_ADT_XML)
def test_lock_modify_invalid(self):
response = Response(text='invalid',
status_code=200,
headers={'Content-Type': 'text/plain'})
connection = Connection([response, response])
victory = DummyADTObject(connection=connection)
try:
victory.lock()
self.assertFail('Exception was expected')
except SAPCliError as ex:
self.assertEquals(str(ex), f'Object {victory.uri}: lock response does not have lock result\ninvalid')
try:
victory.lock()
self.assertFail('Exception was expected')
except SAPCliError as ex:
self.assertEquals(str(ex), f'Object {victory.uri}: lock response does not have lock result\ninvalid')
def test_fetch_transport(self):
self.connection.set_responses(
Response(status_code=200, text=SHORTENED_TRANSPORT_XML))
transport = sap.adt.cts.WorkbenchTransport([], self.connection,
TRANSPORT_NUMBER)
transport.fetch()
self.assertEqual(transport.description, 'Transport Description')
self.assertEqual(transport.owner, 'FILAK')
self.assertEqual(transport._status, 'D')
self.assertEqual(transport.target, 'CTS_TARGET')
self.assertEqual(len(transport.tasks), 1)
task = transport.tasks[0]
self.assertEqual(task.description, 'Task Description')
self.assertEqual(task.owner, 'FILAK')
self.assertEqual(task._status, 'D')
self.assertIsNone(task.target)
def test_create_transport(self):
self.connection.set_responses(
Response(status_code=201, text=TRANSPORT_CREATE_OK_RESPONSE))
self.transport._number = None
self.transport.create()
self.maxDiff = None
self.assertEqual(self.connection.execs, [
Request.post_text(
uri='/sap/bc/adt/cts/transportrequests',
accept='application/vnd.sap.adt.transportorganizer.v1+xml',
body=f'''<?xml version="1.0" encoding="UTF-8"?>
<tm:root xmlns:tm="http://www.sap.com/cts/adt/tm" tm:useraction="newrequest">
<tm:request tm:desc="{self.transport.description}" tm:type="K" tm:target="{self.transport.target}" tm:cts_project="">
<tm:task tm:owner="{self.transport.owner}"/>
</tm:request>
</tm:root>
''')
])
self.assertEqual(self.transport.number, TRANSPORT_NUMBER)
def test_fetch_profiles(self):
conn = Connection(
[Response(status_code=200, text=ADT_XML_PROFILES_TABLE)])
profiles = sap.adt.atc.fetch_profiles(conn)
self.assertEqual(
profiles, {
'PROFILE1': {
'changed': '20080415161735',
'changed_by': 'CHGUSER1',
'created': '20010309180000',
'created_by': 'CREUSER1'
},
'PROFILE2': {
'changed': '00000000000000',
'changed_by': '',
'created': '20010328100000',
'created_by': 'CREUSER2'
}
})
def test_stat_existing(self):
conn = Connection(
[Response(status_code=200, headers={}, text=GET_PACKAGE_ADT_XML)])
args = parse_args('stat', '$IAMTHEKING')
exit_code = args.execute(conn, args)
self.assertEqual(exit_code, sap.cli.core.EXIT_CODE_OK)
self.assertEqual(len(conn.execs), 1)
self.assertConsoleContents(
self.console,
stdout='''Name :$IAMTHEKING
Active :active
Application Component :-
Software Component :LOCAL
Transport Layer :
Package Type :development
''')
def test_adt_package_fetch(self):
conn = Connection([
Response(
text=GET_PACKAGE_ADT_XML,
status_code=200,
headers={
'Content-Type':
'application/vnd.sap.adt.packages.v1+xml; charset=utf-8'
})
])
package = sap.adt.Package(conn, '$IAMTHEKING')
package.fetch()
self.assertEqual(len(conn.execs), 1)
self.assertEqual(conn.mock_methods(),
[('GET', '/sap/bc/adt/packages/%24iamtheking')])
self.maxDiff = None
self.assertEqual(package.description, 'This is a package')
def do_check_release(self, factory):
"""Check it correctly builds the URL with parameters and returns
the expected data.
"""
connection = Connection([Response(TASK_RELEASE_OK_RESPONSE, 200, {})])
wbr = factory(connection, TASK_NUMBER)
resp = wbr.release()
self.assertEqual(connection.execs, [
Request(
'POST',
f'/sap/bc/adt/cts/transportrequests/{TASK_NUMBER}/newreleasejobs',
{
'Accept':
'application/vnd.sap.adt.transportorganizer.v1+xml'
}, None, None)
])
self.assertEqual(resp, TASK_RELEASE_OK_RESPONSE)
def test_create_with_config_instance_none(self):
self.conn.set_responses(
Response.with_json(status_code=201,
json={'repository': self.repo_server_data}))
repo = sap.rest.gcts.Repository(self.conn, self.repo_name)
repo.create(self.repo_url,
self.repo_vsid,
config={'THE_KEY': 'THE_VALUE'})
repo_request = dict(self.repo_request)
repo_request['data']['config'] = [{
'key': 'THE_KEY',
'value': 'THE_VALUE'
}]
self.assertEqual(len(self.conn.execs), 1)
self.conn.execs[0].assertEqual(Request.post_json(
uri=f'repository', body=repo_request, accept='application/json'),
self,
json_body=True)
def test_adt_include_fetch(self):
conn = Connection([
Response(text=GET_INCLUDE_PROGRAM_ADT_XML,
status_code=200,
headers={})
])
include = sap.adt.Include(conn, 'ZHELLO_INCLUDE')
include.fetch()
self.assertEqual(
conn.mock_methods(),
[('GET', '/sap/bc/adt/programs/includes/zhello_include')])
get_request = conn.execs[0]
self.assertIsNone(get_request.params)
self.assertIsNone(get_request.headers)
self.assertEqual(include.name, 'ZHELLO_INCLUDE')
self.assertEqual(include.active, 'inactive')
self.assertEqual(include.master_language, 'EN')
self.assertEqual(include.description, 'Hello include!')
self.assertEqual(include.fix_point_arithmetic, False)
def test_checkout_ok(self):
self.conn.set_responses(
Response.with_json(
status_code=200,
json={'result': {
'fromCommit': '123',
'toCommit': '456'
}}))
repo = sap.rest.gcts.Repository(self.conn,
self.repo_name,
data=self.repo_server_data)
repo.checkout('the_other_branch')
self.assertIsNone(repo._data)
self.assertEqual(len(self.conn.execs), 1)
self.conn.execs[0].assertEqual(
Request.get(
adt_uri=
f'repository/{self.repo_name}/branches/the_branch/switch',
params={'branch': 'the_other_branch'}), self)
def test_fech_reporters_ok(self):
connection = Connection([
Response(status_code=200,
headers={
'Content-Type':
'application/vnd.sap.adt.reporters+xml'
},
text=ADT_XML_CHECK_REPORTERS)
])
result = sap.adt.checks.fetch_reporters(connection)
self.assertIsInstance(result, list)
self.assertEqual(3, len(result))
self.assertEqual(result[0].name, 'abapCheckRun')
self.assertEqual(result[1].name, 'abapPackageCheck')
self.assertEqual(result[2].name, 'tableStatusCheck')
self.assertEqual(result[0].supported_types, ['WDYN*', 'CLAS*', 'WGRP'])
self.assertEqual(result[1].supported_types, ['PROG*', 'INTF*', 'HTTP'])
self.assertEqual(result[2].supported_types, ['TABL/DT'])
def test_fetch(self):
connection = Connection([
Response(text=GET_DUMMY_OBJECT_ADT_XML,
status_code=200,
headers={})
])
victory = DummyADTObject(connection=connection,
name='SOFTWARE_ENGINEER')
victory.fetch()
self.assertEqual(
connection.mock_methods(),
[('GET', '/sap/bc/adt/awesome/success/software_engineer')])
self.assertEqual(victory.description, 'You cannot stop me!')
self.assertEqual(victory.language, 'CZ')
self.assertEqual(victory.name, 'SOFTWARE_ENGINEER')
self.assertEqual(victory.master_language, 'EN')
self.assertEqual(victory.master_system, 'NPL')
self.assertEqual(victory.responsible, 'DEVELOPER')
self.assertEqual(victory.active, 'active')
self.assertEqual(victory.reference.name, 'UNIVERSE')
def test_simple_fetch_ok(self):
REPO_ONE_ID = 0
repo_one = dict(self.repo_server_data)
repo_one['name'] = repo_one['rid'] = 'one'
REPO_TWO_ID = 1
repo_two = dict(self.repo_server_data)
repo_two['name'] = repo_two['rid'] = 'two'
self.conn.set_responses(
Response.with_json(status_code=200,
json={'result': [repo_one, repo_two]}))
repos = sap.rest.gcts.simple_fetch_repos(self.conn)
self.assertEqual(len(repos), 2)
self.assertEqual(repos[REPO_ONE_ID].name, 'one')
self.assertEqual(repos[REPO_TWO_ID].name, 'two')
self.assertEqual(len(self.conn.execs), 1)
self.conn.execs[0].assertEqual(Request.get_json(uri=f'repository'),
self)
def test_adt_wb_activation_warnings(self):
adt_object = self.create_fake_object(
'/sap/bc/adt/oo/classes/cl_hello_world', 'cl_hello_world', [
Response(
status_code=200, text=ACTIVATION_WARNING_XML, headers={})
])
results = sap.adt.wb.activate(adt_object)
self.assertTrue(results.generated)
self.assertTrue(results.has_warnings)
self.assertFalse(results.has_errors)
messages = results.messages
self.assertEqual(len(messages), 2)
self.assertEqual(messages[0].typ, 'W')
self.assertEqual(messages[0].short_text, 'Message 1')
self.assertEqual(messages[0].force_supported, 'true')
self.assertEqual(messages[1].typ, 'W')
self.assertEqual(messages[1].short_text, 'Warning 2')
self.assertEqual(messages[1].force_supported, 'true')
def test_fetch_task(self):
self.connection.set_responses(
Response(status_code=200, text=SHORTENED_TASK_XML))
task = sap.adt.cts.WorkbenchTask(None, [], self.connection,
TASK_NUMBER)
task.fetch()
self.assertEqual(task.transport, TRANSPORT_NUMBER)
self.assertEqual(task.description, 'Task Description')
self.assertEqual(task.owner, 'FILAK')
self.assertEqual(task.objects, [
WorkbenchABAPObject(
pgmid='LIMU',
type='FUNC',
name='TR_REQ_CHECK_OBJECTS_AND_KEYS',
wbtype='FUGR/FF',
description='Prüfe Objekte und Schlüssel in einem Auftrag',
locked=True,
position='000001')
])
self.assertEqual(task._status, 'D')
self.assertIsNone(task.target)
import sap.adt
from sap.adt.objects import xmlns_adtcore_ancestor
from sap.adt.annotations import xml_element, XmlElementKind
from mock import Response
OBJECT_METADATA = sap.adt.ADTCoreData(language='EN', master_language='EN', master_system='NPL', responsible='FILAK')
EMPTY_RESPONSE_OK = Response(text='', status_code=200, headers={})
LOCK_RESPONSE_OK = Response(text='<sap><LOCK_HANDLE>win</LOCK_HANDLE></sap>',
status_code=200,
headers={'Content-Type': 'dataname=com.sap.adt.lock.Result'})
DEFINITIONS_READ_RESPONSE_OK = Response(text='* definitions',
status_code=200,
headers={'Content-Type': 'text/plain; charset=utf-8'})
IMPLEMENTATIONS_READ_RESPONSE_OK = Response(text='* implementations',
status_code=200,
headers={'Content-Type': 'text/plain; charset=utf-8'})
TEST_CLASSES_READ_RESPONSE_OK = Response(text='* test classes',
status_code=200,
headers={'Content-Type': 'text/plain; charset=utf-8'})
TASK_NUMBER='1A2B3C4D5E'
TRANSPORT_NUMBER='E5D4C3B2A1'
TASK_RELEASE_OK_RESPONSE = f'''<?xml version="1.0" encoding="UTF-8"?>
<tm:root xmlns:tm="http://www.sap.com/cts/adt/tm" tm:useraction="newreleasejobs" tm:releasetimestamp="20190212191502 " tm:number="{TASK_NUMBER}">