def setUpModule():
logger.debug('setting up')
# Set up folder hierarchy
pathutil.create_folder('etc/repose')
pathutil.create_folder('var/repose')
pathutil.create_folder('var/log/repose')
# Download Repose artifacts if needed
snapshot = True
if ('IS_RELEASE_BUILD' in os.environ and os.environ['IS_RELEASE_BUILD']):
snapshot = False
if not os.path.exists('usr/share/repose/repose-valve.jar'):
rmc = ReposeMavenConnector()
logger.debug('Downloading valve jar')
rmc.get_repose(valve_dest='usr/share/repose/repose-valve.jar',
get_filter=False,
get_ext_filter=False,
snapshot=snapshot)
if not glob.glob('usr/share/repose/filter-bundle*.ear'):
rmc = ReposeMavenConnector()
logger.debug('Downloading filter bundle')
rmc.get_repose(filter_dest='usr/share/repose/filter-bundle.ear',
get_valve=False,
get_ext_filter=False,
snapshot=snapshot)
# set up the deproxy, fake origin service and fake identity service, to be
# re-used by all test cases
globalvars.identity_port = get_next_open_port()
globalvars.deproxy_port = get_next_open_port()
logger.info('identity port: {0}'.format(globalvars.identity_port))
logger.info('origin port: {0}'.format(globalvars.deproxy_port))
globalvars.deproxy = deproxy.Deproxy()
# our fake origin service always returns 606
def fake_origin_handler(request):
"""
Always returns a 606 status code. This is not a calid code, and so we
can always know that if we receive it, it came from the fake origin
service and not from Repose.
"""
return make_response(606, 'Something')
globalvars.origin_endpoint = (globalvars.deproxy.add_endpoint(
globalvars.deproxy_port,
'origin service',
default_handler=fake_origin_handler))
globalvars.identity = FakeIdentityService(
port=globalvars.identity_port,
origin_service_port=globalvars.deproxy_port)
globalvars.identity_endpoint = (globalvars.deproxy.add_endpoint(
port=globalvars.identity_port,
name='identity service',
default_handler=globalvars.identity.handler))
def setUp(self):
logger.debug('setUp')
deproxy_port = deproxy_port_base - 3
self.deproxy = deproxy.Deproxy()
self.end_point = self.deproxy.add_endpoint(('localhost', deproxy_port))
pathutil.clear_folder(config_dir)
params = {
'port1': repose_port,
'port2': repose_port + 1,
'target_hostname': 'localhost',
'target_port': deproxy_port,
'deployment_dir': deployment_dir,
'artifact_dir': artifact_dir,
'log_file': log_file
}
apply_config_set('configs/two-nodes/.config-set.xml', params=params)
self.valve = repose.ReposeValve(config_dir=config_dir,
stop_port=stop_port)
repose.wait_for_node_to_start(port=repose_port)
repose.wait_for_node_to_start(port=repose_port + 1)
time.sleep(startup_wait_time)
def setUp(self):
logger.debug('setUp')
self.repose_port = get_next_open_port()
self.stop_port = get_next_open_port()
self.deproxy_port = get_next_open_port()
logger.debug('repose port: %s' % self.repose_port)
logger.debug('stop port: %s' % self.stop_port)
logger.debug('deproxy port: %s' % self.deproxy_port)
self.deproxy = deproxy.Deproxy()
self.deproxy.add_endpoint(('localhost', self.deproxy_port))
pathutil.clear_folder(config_dir)
self.params = {
'proto': 'http',
'target_hostname': 'localhost',
'target_port': self.deproxy_port,
'deployment_dir': deploy_dir,
'artifact_dir': artifact_dir,
'log_file': log_file,
'port': self.repose_port,
}
apply_configs('configs', params=self.params)
self.valve = valve.Valve(config_dir=config_dir,
stop_port=self.stop_port,
port=self.repose_port,
wait_on_start=True,
conn_fw='jersey')
def setUp(self):
self.deproxy = deproxy.Deproxy()
self.port = get_next_deproxy_port()
self.deproxy.add_endpoint(self.port,
ssl_enable=True,
ssl_certs={'certfile': './test.crt',
'keyfile': './test.key'})
self.url = 'https://localhost:{0}/'.format(self.port)
def create_mock():
# create a simple HTTP server that returns a 200 response to all requests
logger.debug('create_mock')
global mock_service
if mock_service is not None:
return
mock_service = deproxy.Deproxy()
mock_service.add_endpoint(('localhost', mock_port))
def setUpModule():
# Set up folder hierarchy
logger.debug('setUpModule')
pathutil.create_folder(deployment_dir)
pathutil.create_folder(os.path.dirname(log_file))
global d
if d is None:
d = deproxy.Deproxy()
d.add_endpoint(('localhost', deproxy_port))
def setUp(self):
logger.debug('setting up')
repose_port = get_next_open_port()
stop_port = get_next_open_port()
identity_port = get_next_open_port()
atom_port = get_next_open_port()
deproxy_port = get_next_open_port()
logger.info('repose port: {0}'.format(repose_port))
logger.info('stop port: {0}'.format(stop_port))
logger.info('identity port: {0}'.format(identity_port))
logger.info('atom port: {0}'.format(atom_port))
logger.info('origin port: {0}'.format(deproxy_port))
self.deproxy = deproxy.Deproxy()
self.origin_endpoint = self.deproxy.add_endpoint(
deproxy_port, 'origin service')
self.identity_service = FakeIdentityService()
handler = self.identity_service.handler
endpoint = self.deproxy.add_endpoint(identity_port,
'identity service',
default_handler=handler)
self.identity_endpoint = endpoint
self.atom_service = FakeAtomService(atom_port)
handler = self.atom_service.handler
self.atom_endpoint = self.deproxy.add_endpoint(atom_port,
'atom service',
default_handler=handler)
params = {
'target_hostname': 'localhost',
'target_port': deproxy_port,
'port': repose_port,
'repose_port': repose_port,
'identity_port': identity_port,
'atom_port': atom_port
}
self.url = 'http://localhost:{0}/resource'.format(repose_port)
# configure Repose
conf.process_folder_contents(folder='configs',
dest_path='etc/repose',
params=params)
# start Valve
self.valve = valve.Valve(config_dir='etc/repose',
stop_port=stop_port,
wait_on_start=True,
port=repose_port,
insecure=True)
def test_deproxy_default_handler_method(self):
self.deproxy = deproxy.Deproxy(
default_handler=self.custom_handler_method)
self.deproxy.add_endpoint(port=self.port)
url = 'http://localhost:{0}/'.format(self.port)
mc = self.deproxy.make_request(url=url)
self.assertEqual(len(mc.handlings), 1)
self.assertEqual(mc.handlings[0].response.code, '604')
self.assertEqual(mc.received_response.code, '604')
def test_deproxy_default_handler_function(self):
def custom_handler(request):
return deproxy.Response(code='603', message='Custom', headers={},
body=None)
self.deproxy = deproxy.Deproxy(default_handler=custom_handler)
self.deproxy.add_endpoint(port=self.port)
url = 'http://localhost:{0}/'.format(self.port)
mc = self.deproxy.make_request(url=url)
self.assertEqual(len(mc.handlings), 1)
self.assertEqual(mc.handlings[0].response.code, '603')
self.assertEqual(mc.received_response.code, '603')
def setUpModule():
logger.debug('setting up')
# Set up folder hierarchy
pathutil.create_folder('etc/repose')
pathutil.create_folder('var/repose')
pathutil.create_folder('var/log/repose')
# start a single deproxy for all tests
global deproxy_port
global deproxy_object
deproxy_port = get_next_open_port()
if deproxy_object is None:
deproxy_object = deproxy.Deproxy()
deproxy_object.add_endpoint(('localhost', deproxy_port))
def setUpModule():
logger.debug('setUpModule')
create_folder(repose_config_folder)
clear_folder(repose_config_folder)
create_folder('var/log/repose')
create_folder('var/repose')
# the valve jar should be 'usr/share/repose/repose-valve.jar'
# the filter ears should be in 'usr/share/repose/filters/'
global mock_service
if mock_service is not None:
return
mock_service = deproxy.Deproxy()
mock_service.add_endpoint(mock_port)
logger.debug('setUpModule complete')
def setUp(self):
self.deproxy = deproxy.Deproxy()
self.endpoint1 = self.deproxy.add_endpoint(
name='test-endpoint-1',
port=get_next_deproxy_port())
self.endpoint2 = self.deproxy.add_endpoint(
name='test-endpoint-2',
port=get_next_deproxy_port())
def custom_handler1(request):
return deproxy.Response(code='605', message='Custom', headers={},
body=None)
def custom_handler2(request):
return deproxy.Response(code='606', message='Spoiler', headers={},
body=None)
self.custom_handler1 = custom_handler1
self.custom_handler2 = custom_handler2
self.url1 = 'http://localhost:{0}/'.format(self.endpoint1.port)
self.url2 = 'http://localhost:{0}/'.format(self.endpoint2.port)
def setUp(self):
logger.debug('setUp')
deproxy_port = deproxy_port_base - 0
self.deproxy = deproxy.Deproxy()
self.end_point = self.deproxy.add_endpoint(deproxy_port,'localhost')
pathutil.clear_folder(config_dir)
params = {
'port': repose_port,
'target_hostname': 'localhost',
'target_port': deproxy_port,
'deployment_dir': deployment_dir,
'artifact_dir': artifact_dir,
'log_file': log_file
}
apply_config_set('configs/.config-set.xml', params=params)
self.valve = valve.Valve(config_dir=config_dir,
stop_port=stop_port, port=repose_port,
wait_on_start=True,insecure=True)
time.sleep(startup_wait_time)
def setUp(self):
self.deproxy_port = get_next_deproxy_port()
self.deproxy = deproxy.Deproxy()
self.end_point = self.deproxy.add_endpoint(self.deproxy_port)
def setUp(self):
self.deproxy = deproxy.Deproxy()
self.port = get_next_deproxy_port()
self.deproxy.add_endpoint(self.port)
self.url = 'http://localhost:{0}/'.format(self.port)
def setUp(self):
self.deproxy_port1 = get_next_deproxy_port()
self.deproxy_port2 = get_next_deproxy_port()
self.deproxy = deproxy.Deproxy()
