def test_route_through_edge(self): cluster_id = f"domain-{short_uid()}" cluster_url = f"http://localhost:{config.EDGE_PORT}/{cluster_id}" cluster = EdgeProxiedOpensearchCluster(cluster_url) try: cluster.start() assert cluster.wait_is_up(240), "gave up waiting for server" response = requests.get(cluster_url) assert response.ok, f"cluster endpoint returned an error: {response.text}" assert response.json()["version"]["number"] == "1.1.0" response = requests.get(f"{cluster_url}/_cluster/health") assert response.ok, f"cluster health endpoint returned an error: {response.text}" assert response.json()["status"] in [ "red", "orange", "yellow", "green", ], "expected cluster state to be in a valid state" finally: cluster.shutdown() assert poll_condition( lambda: not cluster.is_up(), timeout=240 ), "gave up waiting for cluster to shut down"
def try_cluster_health(cluster_url: str): response = requests.get(cluster_url) assert response.ok, f"cluster endpoint returned an error: {response.text}" response = requests.get(f"{cluster_url}/_cluster/health") assert response.ok, f"cluster health endpoint returned an error: {response.text}" assert response.json()["status"] in [ "orange", "yellow", "green", ], "expected cluster state to be in a valid state"
def test_set_external_hostname(self): bucket_name = 'test-bucket-%s' % short_uid() key = 'test.file' hostname_before = config.HOSTNAME_EXTERNAL config.HOSTNAME_EXTERNAL = 'foobar' try: content = 'test content 123' acl = 'public-read' self.s3_client.create_bucket(Bucket=bucket_name) # upload file response = self._perform_multipart_upload(bucket=bucket_name, key=key, data=content, acl=acl) expected_url = '%s://%s:%s/%s/%s' % (get_service_protocol(), config.HOSTNAME_EXTERNAL, config.PORT_S3, bucket_name, key) self.assertEqual(expected_url, response['Location']) # fix object ACL - currently not directly support for multipart uploads self.s3_client.put_object_acl(Bucket=bucket_name, Key=key, ACL=acl) # download object via API downloaded_object = self.s3_client.get_object(Bucket=bucket_name, Key=key) self.assertEqual(to_str(downloaded_object['Body'].read()), content) # download object directly from download link download_url = response['Location'].replace('%s:' % config.HOSTNAME_EXTERNAL, 'localhost:') response = safe_requests.get(download_url) self.assertEqual(response.status_code, 200) self.assertEqual(to_str(response.content), content) finally: config.HOSTNAME_EXTERNAL = hostname_before
def test_api_gateway_s3_get_integration(self): apigw_client = aws_stack.connect_to_service('apigateway') s3_client = aws_stack.connect_to_service('s3') bucket_name = 'test-bucket' object_name = 'test.json' object_content = '{ "success": "true" }' object_content_type = 'application/json' api = apigw_client.create_rest_api(name='test') api_id = api['id'] s3_client.create_bucket(Bucket=bucket_name) s3_client.put_object(Bucket=bucket_name, Key=object_name, Body=object_content, ContentType=object_content_type) self.connect_api_gateway_to_s3(bucket_name, object_name, api_id, 'GET') apigw_client.create_deployment(restApiId=api_id, stageName='test') url = gateway_request_url(api_id, 'test', '/') result = requests.get(url) self.assertEqual(result.status_code, 200) self.assertEqual(result.text, object_content) self.assertEqual(result.headers['content-type'], object_content_type) # clean up apigw_client.delete_rest_api(restApiId=api_id) s3_client.delete_object(Bucket=bucket_name, Key=object_name) s3_client.delete_bucket(Bucket=bucket_name)
def test_api_gateway_kinesis_integration(self): # create target Kinesis stream aws_stack.create_kinesis_stream(self.TEST_STREAM_KINESIS_API_GW) # create API Gateway and connect it to the target stream result = self.connect_api_gateway_to_kinesis('test_gateway1', self.TEST_STREAM_KINESIS_API_GW) # generate test data test_data = {'records': [ {'data': '{"foo": "bar1"}'}, {'data': '{"foo": "bar2"}'}, {'data': '{"foo": "bar3"}'} ]} url = self.gateway_request_url( api_id=result['id'], stage_name=self.TEST_STAGE_NAME, path=self.API_PATH_DATA_INBOUND ) # list Kinesis streams via API Gateway result = requests.get(url) result = json.loads(to_str(result.content)) self.assertIn('StreamNames', result) # post test data to Kinesis via API Gateway result = requests.post(url, data=json.dumps(test_data)) result = json.loads(to_str(result.content)) self.assertEqual(result['FailedRecordCount'], 0) self.assertEqual(len(result['Records']), len(test_data['records'])) # clean up kinesis = aws_stack.connect_to_service('kinesis') kinesis.delete_stream(StreamName=self.TEST_STREAM_KINESIS_API_GW)
def get_template_body(req_data): body = req_data.get("TemplateBody") if body: return body url = req_data.get("TemplateURL") if url: response = run_safe(lambda: safe_requests.get(url, verify=False)) # check error codes, and code 301 - fixes https://github.com/localstack/localstack/issues/1884 status_code = 0 if response is None else response.status_code if response is None or status_code == 301 or status_code >= 400: # check if this is an S3 URL, then get the file directly from there url = convert_s3_to_local_url(url) if is_local_service_url(url): parsed_path = urlparse.urlparse(url).path.lstrip("/") parts = parsed_path.partition("/") client = aws_stack.connect_to_service("s3") LOG.debug( "Download CloudFormation template content from local S3: %s - %s" % (parts[0], parts[2])) result = client.get_object(Bucket=parts[0], Key=parts[2]) body = to_str(result["Body"].read()) return body raise Exception( "Unable to fetch template body (code %s) from URL %s" % (status_code, url)) return response.content raise Exception("Unable to get template body from input: %s" % req_data)
def test_api_gateway_http_integration(): test_port = 12123 backend_url = 'http://localhost:%s%s' % (test_port, API_PATH_HTTP_BACKEND) # create target HTTP backend def listener(**kwargs): response = Response() response.status_code = 200 response._content = json.dumps( kwargs['data']) if kwargs['data'] else '{}' return response proxy = GenericProxy(test_port, update_listener=listener) proxy.start() # create API Gateway and connect it to the HTTP backend result = connect_api_gateway_to_http('test_gateway2', backend_url, path=API_PATH_HTTP_BACKEND) # make test request to gateway url = INBOUND_GATEWAY_URL_PATTERN.format(api_id=result['id'], stage_name=TEST_STAGE_NAME, path=API_PATH_HTTP_BACKEND) result = requests.get(url) assert result.status_code == 200 assert to_str(result.content) == '{}' data = {"data": 123} result = requests.post(url, data=json.dumps(data)) assert result.status_code == 200 assert json.loads(to_str(result.content)) == data # clean up proxy.stop()
def test_elasticsearch_get_document(self): article_path = '{}/{}/employee/{}?pretty'.format( self.es_url, TEST_INDEX, TEST_DOC_ID) resp = requests.get(article_path, headers=COMMON_HEADERS) self.assertIn('I like to collect rock albums', resp.text, msg='Document not found({}): {}'.format(resp.status_code, resp.text))
def test_create_indexes_and_domains(self): indexes = ["index1", "index2"] for index_name in indexes: index_path = "{}/{}".format(self.es_url, index_name) requests.put(index_path, headers=COMMON_HEADERS) endpoint = "{}/_cat/indices/{}?format=json&pretty".format( self.es_url, index_name) req = requests.get(endpoint) self.assertEqual(200, req.status_code) req_result = json.loads(req.text) self.assertIn(req_result[0]["health"], ["green", "yellow"]) self.assertIn(req_result[0]["index"], indexes) es_client = aws_stack.connect_to_service("es") test_domain_name_1 = "test1-%s" % short_uid() test_domain_name_2 = "test2-%s" % short_uid() self._create_domain(name=test_domain_name_1, version="6.8") self._create_domain(name=test_domain_name_2, version="6.8") status_test_domain_name_1 = es_client.describe_elasticsearch_domain( DomainName=test_domain_name_1) status_test_domain_name_2 = es_client.describe_elasticsearch_domain( DomainName=test_domain_name_2) self.assertFalse( status_test_domain_name_1["DomainStatus"]["Processing"]) self.assertFalse( status_test_domain_name_2["DomainStatus"]["Processing"])
def test_elasticsearch_get_document(): article_path = '{}/{}/employee/{}?pretty'.format( ES_URL, TEST_INDEX, TEST_DOC_ID) resp = requests.get(article_path, headers=COMMON_HEADERS) assert_true('I like to collect rock albums' in resp.text, msg='Document not found({}): {}'.format(resp.status_code, resp.text))
def test_elasticsearch_get_document(): article_path = '{}/{}/employee/{}?pretty'.format(es_url, test_index, test_doc_id) resp = requests.get(article_path, headers=common_headers) assert_true('I like to collect rock albums' in resp.text, msg='Document not found({}): {}'.format( resp.status_code, resp.text))
def run_api_gateway_http_integration(self, int_type): test_port = get_free_tcp_port() backend_url = 'http://localhost:%s%s' % (test_port, self.API_PATH_HTTP_BACKEND) # start test HTTP backend proxy = self.start_http_backend(test_port) # create API Gateway and connect it to the HTTP_PROXY/HTTP backend result = self.connect_api_gateway_to_http( int_type, 'test_gateway2', backend_url, path=self.API_PATH_HTTP_BACKEND) url = self.gateway_request_url(api_id=result['id'], stage_name=self.TEST_STAGE_NAME, path=self.API_PATH_HTTP_BACKEND) # make sure CORS headers are present origin = 'localhost' result = requests.options(url, headers={'origin': origin}) self.assertEqual(result.status_code, 200) self.assertTrue( re.match( result.headers['Access-Control-Allow-Origin'].replace( '*', '.*'), origin)) self.assertIn('POST', result.headers['Access-Control-Allow-Methods']) custom_result = json.dumps({'foo': 'bar'}) # make test GET request to gateway result = requests.get(url) self.assertEqual(result.status_code, 200) expected = custom_result if int_type == 'custom' else '{}' self.assertEqual(json.loads(to_str(result.content))['data'], expected) # make test POST request to gateway data = json.dumps({'data': 123}) result = requests.post(url, data=data) self.assertEqual(result.status_code, 200) expected = custom_result if int_type == 'custom' else data self.assertEqual(json.loads(to_str(result.content))['data'], expected) # make test POST request with non-JSON content type data = 'test=123' ctype = 'application/x-www-form-urlencoded' result = requests.post(url, data=data, headers={'content-type': ctype}) self.assertEqual(result.status_code, 200) content = json.loads(to_str(result.content)) headers = CaseInsensitiveDict(content['headers']) expected = custom_result if int_type == 'custom' else data self.assertEqual(content['data'], expected) self.assertEqual(headers['content-type'], ctype) # clean up proxy.stop()
def test_create_indices(self, opensearch_endpoint): indices = ["index1", "index2"] for index_name in indices: index_path = f"{opensearch_endpoint}/{index_name}" requests.put(index_path, headers=COMMON_HEADERS) endpoint = f"{opensearch_endpoint}/_cat/indices/{index_name}?format=json&pretty" req = requests.get(endpoint) assert req.status_code == 200 req_result = json.loads(req.text) assert req_result[0]["health"] in ["green", "yellow"] assert req_result[0]["index"] in indices
def test_search(self, opensearch_endpoint, opensearch_document_path): index = "/".join(opensearch_document_path.split("/")[:-2]) # force the refresh of the index after the document was added, so it can appear in search response = requests.post(f"{opensearch_endpoint}/_refresh", headers=COMMON_HEADERS) assert response.ok search = {"query": {"match": {"last_name": "Fett"}}} response = requests.get(f"{index}/_search", data=json.dumps(search), headers=COMMON_HEADERS) assert ( "I'm just a simple man" in response.text ), f"search unsuccessful({response.status_code}): {response.text}"
def test_elasticsearch_search(): search_path = '{}/{}/employee/_search?pretty'.format(es_url, test_index) search = {'query': {'match': {'last_name': 'Smith'}}} resp = requests.get(search_path, data=json.dumps(search), headers=common_headers) assert_true('I like to collect rock albums' in resp.text, msg='Search failed({}): {}'.format(resp.status_code, resp.text))
def test_elasticsearch_search(): search_path = '{}/{}/employee/_search?pretty'.format(ES_URL, TEST_INDEX) search = {'query': {'match': {'last_name': 'Smith'}}} resp = requests.get(search_path, data=json.dumps(search), headers=COMMON_HEADERS) assert_true('I like to collect rock albums' in resp.text, msg='Search failed({}): {}'.format(resp.status_code, resp.text))
def get_template_body(req_data): body = req_data.get('TemplateBody') if body: return body[0] url = req_data.get('TemplateURL') if url: response = safe_requests.get(url[0]) if response.status_code >= 400: raise Exception( 'Unable to fetch template body (code %s) from URL %s' % (response.status_code, url[0])) return response.content raise Exception('Unable to get template body from input: %s' % req_data)
def test_elasticsearch_search(self): search_path = "{}/{}/employee/_search?pretty".format( self.es_url, TEST_INDEX) search = {"query": {"match": {"last_name": "Smith"}}} resp = requests.get(search_path, data=json.dumps(search), headers=COMMON_HEADERS) self.assertIn( "I like to collect rock albums", resp.text, msg="Search failed({}): {}".format(resp.status_code, resp.text), )
def test_api_gateway_http_integration(self): test_port = 12123 backend_url = 'http://localhost:%s%s' % (test_port, self.API_PATH_HTTP_BACKEND) # create target HTTP backend class TestListener(ProxyListener): def forward_request(self, **kwargs): response = Response() response.status_code = 200 response._content = kwargs.get('data') or '{}' return response proxy = GenericProxy(test_port, update_listener=TestListener()) proxy.start() # create API Gateway and connect it to the HTTP backend result = self.connect_api_gateway_to_http( 'test_gateway2', backend_url, path=self.API_PATH_HTTP_BACKEND ) url = INBOUND_GATEWAY_URL_PATTERN.format( api_id=result['id'], stage_name=self.TEST_STAGE_NAME, path=self.API_PATH_HTTP_BACKEND ) # make sure CORS headers are present origin = 'localhost' result = requests.options(url, headers={'origin': origin}) self.assertEqual(result.status_code, 200) self.assertTrue(re.match(result.headers['Access-Control-Allow-Origin'].replace('*', '.*'), origin)) self.assertIn('POST', result.headers['Access-Control-Allow-Methods']) # make test request to gateway result = requests.get(url) self.assertEqual(result.status_code, 200) self.assertEqual(to_str(result.content), '{}') data = {'data': 123} result = requests.post(url, data=json.dumps(data)) self.assertEqual(result.status_code, 200) self.assertEqual(json.loads(to_str(result.content)), data) # clean up proxy.stop()
def test_elasticsearch_search(): search_path = '{}/{}/employee/_search?pretty'.format(ES_URL, TEST_INDEX) search = { 'query': { 'match': { 'last_name': 'Smith' } } } resp = requests.get( search_path, data=json.dumps(search), headers=COMMON_HEADERS) assert_true('I like to collect rock albums' in resp.text, msg='Search failed({}): {}'.format(resp.status_code, resp.text))
def get_template_body(req_data): body = req_data.get('TemplateBody') if body: return body url = req_data.get('TemplateURL') if url: response = safe_requests.get(url) if response.status_code >= 400: # check if this is an S3 URL, then get the file directly from there if '://localhost' in url or re.match(r'.*s3(\-website)?\.([^\.]+\.)?amazonaws.com.*', url): parsed_path = urlparse.urlparse(url).path.lstrip('/') parts = parsed_path.partition('/') client = aws_stack.connect_to_service('s3') result = client.get_object(Bucket=parts[0], Key=parts[2]) body = to_str(result['Body'].read()) return body raise Exception('Unable to fetch template body (code %s) from URL %s' % (response.status_code, url)) return response.content raise Exception('Unable to get template body from input: %s' % req_data)
def test_api_gateway_http_integration(): test_port = 12123 backend_url = 'http://localhost:%s%s' % (test_port, API_PATH_HTTP_BACKEND) # create target HTTP backend class TestListener(ProxyListener): def forward_request(self, **kwargs): response = Response() response.status_code = 200 response._content = kwargs.get('data') or '{}' return response proxy = GenericProxy(test_port, update_listener=TestListener()) proxy.start() # create API Gateway and connect it to the HTTP backend result = connect_api_gateway_to_http('test_gateway2', backend_url, path=API_PATH_HTTP_BACKEND) url = INBOUND_GATEWAY_URL_PATTERN.format(api_id=result['id'], stage_name=TEST_STAGE_NAME, path=API_PATH_HTTP_BACKEND) # make sure CORS headers are present origin = 'localhost' result = requests.options(url, headers={'origin': origin}) assert result.status_code == 200 assert re.match(result.headers['Access-Control-Allow-Origin'].replace('*', '.*'), origin) assert 'POST' in result.headers['Access-Control-Allow-Methods'] # make test request to gateway result = requests.get(url) assert result.status_code == 200 assert to_str(result.content) == '{}' data = {'data': 123} result = requests.post(url, data=json.dumps(data)) assert result.status_code == 200 assert json.loads(to_str(result.content)) == data # clean up proxy.stop()
def test_api_gateway_http_integration_with_path_request_parmeter(self): client = aws_stack.connect_to_service('apigateway') test_port = get_free_tcp_port() backend_url = 'http://localhost:%s/person/{id}' % (test_port) # start test HTTP backend proxy = self.start_http_backend(test_port) # create rest api api_rest = client.create_rest_api(name='test') api_id = api_rest['id'] parent_response = client.get_resources(restApiId=api_id) parent_id = parent_response['items'][0]['id'] resource_1 = client.create_resource(restApiId=api_id, parentId=parent_id, pathPart='person') resource_1_id = resource_1['id'] resource_2 = client.create_resource(restApiId=api_id, parentId=resource_1_id, pathPart='{id}') resource_2_id = resource_2['id'] client.put_method( restApiId=api_id, resourceId=resource_2_id, httpMethod='GET', authorizationType='NONE', apiKeyRequired=False, requestParameters={'method.request.path.id': True}) client.put_integration( restApiId=api_id, resourceId=resource_2_id, httpMethod='GET', integrationHttpMethod='GET', type='HTTP', uri=backend_url, timeoutInMillis=3000, contentHandling='CONVERT_TO_BINARY', requestParameters={'integration.request.path.id': 'method.request.path.id'}) client.create_deployment(restApiId=api_id, stageName='test') url = f'http://localhost:{config.EDGE_PORT}/restapis/{api_id}/test/_user_request_/person/123' result = requests.get(url) content = json.loads(result._content) self.assertEqual(result.status_code, 200) self.assertEqual(content['headers'].get(HEADER_LOCALSTACK_REQUEST_URL), f'http://localhost:{config.EDGE_PORT}/person/123') # clean up client.delete_rest_api(restApiId=api_id) proxy.stop()
def test_create_indexes_and_domains(self): indexes = ['index1', 'index2'] for index_name in indexes: index_path = '{}/{}'.format(self.es_url, index_name) requests.put(index_path, headers=COMMON_HEADERS) endpoint = 'http://localhost:{}/_cat/indices/{}?format=json&pretty'.format( config.PORT_ELASTICSEARCH, index_name) req = requests.get(endpoint) self.assertEqual(req.status_code, 200) req_result = json.loads(req.text) self.assertTrue(req_result[0]['health'] in ['green', 'yellow']) self.assertTrue(req_result[0]['index'] in indexes) es_client = aws_stack.connect_to_service('es') test_domain_name_1 = 'test1-%s' % short_uid() test_domain_name_2 = 'test2-%s' % short_uid() self._create_domain(name=test_domain_name_1, version='6.8') self._create_domain(name=test_domain_name_2, version='6.8') status_test_domain_name_1 = es_client.describe_elasticsearch_domain(DomainName=test_domain_name_1) status_test_domain_name_2 = es_client.describe_elasticsearch_domain(DomainName=test_domain_name_2) self.assertTrue(status_test_domain_name_1['DomainStatus']['Created']) self.assertTrue(status_test_domain_name_2['DomainStatus']['Created'])
def get_template_body(req_data): body = req_data.get('TemplateBody') if body: return body url = req_data.get('TemplateURL') if url: response = run_safe(lambda: safe_requests.get(url, verify=False)) # check error codes, and code 301 - fixes https://github.com/localstack/localstack/issues/1884 status_code = 0 if response is None else response.status_code if not response or status_code == 301 or status_code >= 400: # check if this is an S3 URL, then get the file directly from there if '://localhost' in url or re.match( r'.*s3(\-website)?\.([^\.]+\.)?amazonaws.com.*', url): parsed_path = urlparse.urlparse(url).path.lstrip('/') parts = parsed_path.partition('/') client = aws_stack.connect_to_service('s3') result = client.get_object(Bucket=parts[0], Key=parts[2]) body = to_str(result['Body'].read()) return body raise Exception( 'Unable to fetch template body (code %s) from URL %s' % (status_code, url)) return response.content raise Exception('Unable to get template body from input: %s' % req_data)
def test_api_gateway_http_integration(self): test_port = 12123 backend_url = 'http://localhost:%s%s' % (test_port, self.API_PATH_HTTP_BACKEND) # create target HTTP backend class TestListener(ProxyListener): def forward_request(self, **kwargs): response = Response() response.status_code = 200 result = { 'data': kwargs.get('data') or '{}', 'headers': dict(kwargs.get('headers')) } response._content = json.dumps(json_safe(result)) return response proxy = GenericProxy(test_port, update_listener=TestListener()) proxy.start() # create API Gateway and connect it to the HTTP backend result = self.connect_api_gateway_to_http( 'test_gateway2', backend_url, path=self.API_PATH_HTTP_BACKEND) url = self.gateway_request_url(api_id=result['id'], stage_name=self.TEST_STAGE_NAME, path=self.API_PATH_HTTP_BACKEND) # make sure CORS headers are present origin = 'localhost' result = requests.options(url, headers={'origin': origin}) self.assertEqual(result.status_code, 200) self.assertTrue( re.match( result.headers['Access-Control-Allow-Origin'].replace( '*', '.*'), origin)) self.assertIn('POST', result.headers['Access-Control-Allow-Methods']) # make test GET request to gateway result = requests.get(url) self.assertEqual(result.status_code, 200) self.assertEqual(json.loads(to_str(result.content))['data'], '{}') # make test POST request to gateway data = json.dumps({'data': 123}) result = requests.post(url, data=data) self.assertEqual(result.status_code, 200) self.assertEqual(json.loads(to_str(result.content))['data'], data) # make test POST request with non-JSON content type data = 'test=123' ctype = 'application/x-www-form-urlencoded' result = requests.post(url, data=data, headers={'content-type': ctype}) self.assertEqual(result.status_code, 200) content = json.loads(to_str(result.content)) headers = CaseInsensitiveDict(content['headers']) self.assertEqual(content['data'], data) self.assertEqual(headers['content-type'], ctype) # clean up proxy.stop()
def test_apigateway_with_lambda_integration(self): apigw_client = aws_stack.connect_to_service('apigateway') # create Lambda function lambda_name = 'apigw-lambda-%s' % short_uid() self.create_lambda_function(lambda_name) lambda_uri = aws_stack.lambda_function_arn(lambda_name) target_uri = aws_stack.apigateway_invocations_arn(lambda_uri) # create REST API api = apigw_client.create_rest_api(name='test-api', description='') api_id = api['id'] root_res_id = apigw_client.get_resources( restApiId=api_id)['items'][0]['id'] api_resource = apigw_client.create_resource(restApiId=api_id, parentId=root_res_id, pathPart='test') apigw_client.put_method(restApiId=api_id, resourceId=api_resource['id'], httpMethod='GET', authorizationType='NONE') rs = apigw_client.put_integration( restApiId=api_id, resourceId=api_resource['id'], httpMethod='GET', integrationHttpMethod='POST', type='AWS', uri=target_uri, requestTemplates={ 'application/json': '{"param1": "$input.params(\'param1\')"}' }) self.assertEqual(rs['ResponseMetadata']['HTTPStatusCode'], 200) for key in [ 'httpMethod', 'type', 'passthroughBehavior', 'cacheKeyParameters', 'uri', 'cacheNamespace' ]: self.assertIn(key, rs) self.assertNotIn('responseTemplates', rs) apigw_client.create_deployment(restApiId=api_id, stageName=self.TEST_STAGE_NAME) rs = apigw_client.get_integration(restApiId=api_id, resourceId=api_resource['id'], httpMethod='GET') self.assertEqual(rs['ResponseMetadata']['HTTPStatusCode'], 200) self.assertEqual(rs['type'], 'AWS') self.assertEqual(rs['httpMethod'], 'POST') self.assertEqual(rs['uri'], target_uri) # invoke the gateway endpoint url = self.gateway_request_url(api_id=api_id, stage_name=self.TEST_STAGE_NAME, path='/test') response = requests.get('%s?param1=foobar' % url) self.assertLess(response.status_code, 400) content = json.loads(to_str(response.content)) self.assertEqual(content.get('httpMethod'), 'POST') self.assertEqual( content.get('requestContext', {}).get('resourceId'), api_resource['id']) self.assertEqual( content.get('requestContext', {}).get('stage'), self.TEST_STAGE_NAME) self.assertEqual(content.get('body'), '{"param1": "foobar"}') # delete integration rs = apigw_client.delete_integration( restApiId=api_id, resourceId=api_resource['id'], httpMethod='GET', ) self.assertEqual(rs['ResponseMetadata']['HTTPStatusCode'], 200) with self.assertRaises(ClientError) as ctx: # This call should not be successful as the integration is deleted apigw_client.get_integration(restApiId=api_id, resourceId=api_resource['id'], httpMethod='GET') self.assertEqual(ctx.exception.response['Error']['Code'], 'BadRequestException') # clean up lambda_client = aws_stack.connect_to_service('lambda') lambda_client.delete_function(FunctionName=lambda_name) apigw_client.delete_rest_api(restApiId=api_id)
def test_get_document(self, opensearch_document_path): response = requests.get(opensearch_document_path) assert ( "I'm just a simple man" in response.text ), f"document not found({response.status_code}): {response.text}"