コード例 #1
0
 def test_run(self):
     if os.environ.get('ON_TRAVIS', 'false') == 'false':
         event = {
             'campaign_uuid': 'dd7b3627dc6942dc9798ea094f8c680b',
             'type': 'Building'
         }
         lambda_handler(event, {})
コード例 #2
0
ファイル: test.py プロジェクト: pytorch/test-infra
 def test_logs(self, mock_urlopen):
     event = {'logs': 'logs'}
     lambda_function.lambda_handler(event, Mock())
     mock_urlopen.assert_called_once_with(
         ANY,
         data=b'{"access_token": "123", "logs": "logs"}',
     )
コード例 #3
0
def test_create():
    """ Create a server """
    lambda_handler({"action": "create", "app_name": "factorio"}, object())
    ip = controller.get_ip_address()
    status = check_output(["ping", ip]).decode()
    result_str = re.search(r"Received = (\d)+?,", status)
    if not result_str:
        raise Exception("Unexpected terminal response: " + status)
    received = int(result_str.groups()[0])
    assert received > 0
    # commands = [
    #     "sudo mkdir -p /opt/factorio",
    #     "sudo chown 845:845 /opt/factorio",
    #     " ".join(
    #         [
    #             "sudo docker run -d" "-p 34197:34197/udp",
    #             "-p 27015:27015/tcp",
    #             "-v /opt/factorio:/factorio",
    #             "--name factorio",
    #             "--restart=always",
    #             "factoriotools/factorio",
    #         ]
    #     ),
    # ]
    # for command in commands:
    #     controller.exec(command)
    pass
コード例 #4
0
def test_download_document_error(boto3_client_mock, pg_connect_mock, db_config,
                                 event, caplog):
    s3_mock = MagicMock()
    s3_mock.download_file.side_effect = Exception("Download document error")
    boto3_client_mock.return_value = s3_mock
    lambda_handler(event, None)
    assert all_in(["ERROR", "Download document"], caplog.text)
コード例 #5
0
 def test_backup_rds_verification(self):
     # Replace response of describe_db_snapshots api call
     lambda_function.rds_source.describe_db_snapshots = self.side_describe_db_snapshots
     # Replace response of describe_db_instances api call
     lambda_function.rds.describe_db_instances = self.side_describe_db_instances
     # Replace response of restore_db_instance_from_db_snapshot api call
     lambda_function.rds.restore_db_instance_from_db_snapshot = self.side_restore_db_instance_from_db_snapshot
     # Replace response of describe_events api call
     lambda_function.rds.describe_events = self.side_describe_events
     # Replace response of copy_db_snapshot api call
     lambda_function.rds.copy_db_snapshot = self.side_snapshot_copy
     # Replace response of modify_db_instance api call
     lambda_function.rds.modify_db_instance = self.side_modify_db_instance
     # Replace return value of get_account_id function
     lambda_function.get_account_id.return_value = "123456789012"
     # Replace return value of get_first_az function
     lambda_function.get_first_az.return_value = "us-west-2"
     # Replace response publish event data to Datadog and Jira
     lambda_function.requests.post.return_value.content = "==== Publish event ===="
     # Create sns topic
     sns = boto.sns.connect_to_region("us-west-2")
     sns.create_topic("hipchat-rds-mysql-db-check")
     # Replace return value of gatekeeper_allow_automation_instance_only function
     lambda_function.gatekeeper_allow_automation_instance_only.return_value = True
     print('==== Start testing with an event id {0} ====').format(self.EVENT_ID)
     lambda_function.lambda_handler(self.side_events(self.EVENT_ID), '')
コード例 #6
0
    def test_session_state(self):

        # create our launch request
        launch_event = {
            "request": {
                "type": "LaunchRequest"
            },
            "session": {
                "new": True
            }
        }
        response = lambda_function.lambda_handler(event=launch_event,
                                                  context=None)
        assert not response['response']['shouldEndSession']

        # Session is open, now ask for a list of breweries
        list_breweries_event = {
            "request": {
                "type": "IntentRequest",
                "intent": {
                    "name": "ListBreweries",
                    "mocked": True
                }
            },
            "session": {
                "new": False
            }
        }
        response = lambda_function.lambda_handler(event=list_breweries_event,
                                                  context=None)
        assert response['response']['shouldEndSession']
コード例 #7
0
    def test_get_home_brewery(self):
        """Test that we can set a home brewery and get it back"""
        set_home_event = {"request" : {"type": "IntentRequest",\
                                       "intent": {"name": "SetHomeBrewery",
                                                  "mocked": True,
                                                  "slots" : {"brewery":{"value":"Village Idiot"}}}},\
                          "session" : {"new": False, "user": {"userId": "valid_user_id"} } }

        response = lambda_function.lambda_handler(event=set_home_event,
                                                  context=None)
        assert response is not None
        assert response['response']['outputSpeech']['type'] == 'PlainText'
        assert response['response']['outputSpeech']['text'].startswith(
            'Your home brewery has been set to')
        assert response['response']['shouldEndSession']

        # now read it back
        get_home_event = {"request" : {"type": "IntentRequest",\
                                       "intent": {"name": "GetHomeBrewery", "mocked": True}},\
                          "session" : {"new": False, "user": {"userId": "valid_user_id"} } }
        response = lambda_function.lambda_handler(event=get_home_event,
                                                  context=None)
        assert response is not None
        assert response['response']['outputSpeech']['type'] == 'PlainText'
        assert 'Village Idiot' in response['response']['outputSpeech']['text']
        assert response['response']['shouldEndSession']
コード例 #8
0
def main():
    event = {}
    with open('events/s3.json', 'r', encoding='utf8') as f:
        json_str = f.read()
        event = json.loads(json_str)

    lambda_function.lambda_handler(event, None)
コード例 #9
0
def test_lambda():
    event = {
        "notification_type": "ui",
        "test_id": "d3caeeb7-32bd-4b4b-824d-702708a7116c",
        "report_id": 176,
    }
    lambda_handler(event, {})
コード例 #10
0
def test_create(create_event, context, monkeypatch):
    """Tests resource creation."""
    monkeypatch.setattr("urllib2.build_opener",
                        Mock(return_value=Mock()))
    # Don't sleep!
    monkeypatch.setattr("time.sleep", lambda t: None)
    lambda_function.lambda_handler(create_event, context)
コード例 #11
0
def test_non_existing_product_error(boto3_client_mock, os_remove_mock,
                                    put_partner_in_db_ids, success_event, rds,
                                    caplog):
    lambda_handler(success_event, None)
    assert all_in(["ERROR", "Put record in database", "IMPORT_FAILURE"],
                  caplog.text)
    infringement_count = get_dummy_infringement_count(rds)
    assert infringement_count == 0
コード例 #12
0
def test_import_document_success(boto3_client_mock, os_remove_mock,
                                 put_partner_in_db_ids, success_event, rds,
                                 caplog):
    lambda_handler(success_event, None)
    assert all_not_in(["CRITICAL", "ERROR", "WARNING"], caplog.text)
    assert all_in(["INFO", "SUCCESS", "IMPORT_SUCCESS"], caplog.text)
    product_count = get_dummy_product_count(rds)
    assert product_count == 2
コード例 #13
0
    def test_dispatch_wrong_appointment(self):
        # GIVEN
        evt = self.fetch_event()
        evt['currentIntent']['name'] = 'WrongName'

        # WHEN / THEN
        with self.assertRaises(Exception):
            lf.lambda_handler(evt, {})
コード例 #14
0
    def test_lambda_function_dummy(self):
        """
        Really run locally
        """
        with open('test_event.json', 'r') as test_event:
            event = json.load(test_event)

        lambda_handler(event, None)
コード例 #15
0
ファイル: test.py プロジェクト: mannbiher/iot-time-management
 def test_notification(self):
     event = [{
         'domain': 'fb',
         'size': 2000
     }, {
         'domain': '9gag',
         'size': 40000
     }]
     lambda_function.lambda_handler(event, {})
コード例 #16
0
def test_process_request_success(boto3_client_mock, pg_connect_mock,
                                 os_remove_mock, db_config, success_event,
                                 caplog):
    rds_mock = MagicMock()
    pg_connect_mock.return_value = rds_mock
    lambda_handler(success_event, None)
    assert all_in(["INFO", "SUCCESS", "IMPORT_SUCCESS"], caplog.text)
    rds_mock.commit.assert_called()
    rds_mock.close.assert_called_once()
コード例 #17
0
def test_parse_empty_document_error(
    boto3_client_mock,
    pg_connect_mock,
    os_remove_mock,
    db_config,
    empty_document_event,
    caplog,
):
    lambda_handler(empty_document_event, None)
    assert all_in(["WARNING", "Empty document", "EMPTY_DOCUMENT"], caplog.text)
コード例 #18
0
ファイル: test.py プロジェクト: pytorch/test-infra
 def test_base64_bz2_logs(self, mock_urlopen):
     event = {
         'base64_bz2_logs':
         base64.b64encode(bz2.compress('logs'.encode())).decode()
     }
     lambda_function.lambda_handler(event, Mock())
     mock_urlopen.assert_called_once_with(
         ANY,
         data=b'{"access_token": "123", "logs": "logs"}',
     )
コード例 #19
0
def test_process_request_with_invalid_records_below_threshold_success(
    boto3_client_mock,
    pg_connect_mock,
    os_remove_mock,
    db_config,
    invalid_records_below_threshold_event,
    caplog,
):
    lambda_handler(invalid_records_below_threshold_event, None)
    assert all_in(["WARNING", "SUCCESS", "FAILED_RECORDS_BELOW_THRESHOLD"], caplog.text)
コード例 #20
0
def test_validate_record_error(
    boto3_client_mock,
    pg_connect_mock,
    os_remove_mock,
    db_config,
    invalid_records_above_threshold_event,
    caplog,
):
    lambda_handler(invalid_records_above_threshold_event, None)
    assert all_in(["ERROR", "Validate record"], caplog.text)
コード例 #21
0
def test_put_record_in_db_error(boto3_client_mock, pg_connect_mock,
                                os_remove_mock, db_config, success_event,
                                caplog):
    rds_mock = MagicMock()
    pg_connect_mock.return_value = rds_mock
    rds_mock.cursor.side_effect = Exception("Put record in database error")
    lambda_handler(success_event, None)
    assert all_in(["ERROR", "Put record in database"], caplog.text)
    rds_mock.rollback.assert_called()
    rds_mock.close.assert_called_once()
コード例 #22
0
def test_process_request_with_invalid_records_above_threshold_error(
    boto3_client_mock,
    pg_connect_mock,
    os_remove_mock,
    db_config,
    invalid_records_above_threshold_event,
    caplog,
):
    lambda_handler(invalid_records_above_threshold_event, None)
    assert all_in(["ERROR", "IMPORT_FAILURE"], caplog.text)
コード例 #23
0
def test_parse_non_existing_document_error(
    boto3_client_mock,
    pg_connect_mock,
    os_remove_mock,
    db_config,
    non_existing_document_event,
    caplog,
):
    lambda_handler(non_existing_document_event, None)
    assert all_in(["ERROR", "Parse document", "No such file or directory"],
                  caplog.text)
コード例 #24
0
 def test_run(self):
     if os.environ.get('ON_TRAVIS', 'false') == 'false':
         event = {
             'campaign_uuid': '76674eefa4524a6fbc20e147fe01f1fd',
             'feature': 'building=yes',
             'date': {
                 'from': '2018-01-01',
                 'to': '2019-12-31'
             }
         }
         lambda_handler(event, {})
コード例 #25
0
def test_move_document_to_processed_error(
    boto3_client_mock, pg_connect_mock, os_remove_mock, db_config, success_event, caplog
):
    s3_mock = MagicMock()
    boto3_client_mock.return_value = s3_mock
    s3_mock.copy_object.side_effect = Exception("Move document to processed error")
    lambda_handler(success_event, None)
    assert all_in(
        ["ERROR", "Move document to processed", "INFO", "SUCCESS", "IMPORT_SUCCESS"],
        caplog.text,
    )
コード例 #26
0
 def test_terraform_upgrade_by_hashicorp_release(self):
     self.setup_dockerfile_test_repo(self.clone_dir, "test-terraform-upgrade")
     initial_values = { "TF_VERSION": "v0.11.8", "DOCKERFILE_VERSION": "1", "PK_VERSION": "v1.3.2" }
     self.mngr.write_object(self.internal_store_path, JSON_CONTENT_WITHOUT_FORCE_TEMPLATE.format(**initial_values))
     try:
         with mock.patch.dict("os.environ", self.environ):
             expected_new_tfpk_ver = "vXX.YY.ZZ"
             expected_dockerfile_ver = "2"
             dockerfile_repo_name = os.environ.get("dockerfile_github_repository")
             github_access_token = os.environ.get("github_access_token")
             dockerfile_repo = GitHubRepository(dockerfile_repo_name, github_access_token)
             with mock.patch("lambda_function.get_latest_hashicorp_terraform_version", return_value=expected_new_tfpk_ver) :
                 with mock.patch("lambda_function.get_latest_hashicorp_packer_version", return_value=expected_new_tfpk_ver):
                     retcode = lambda_function.lambda_handler(None, None)
                     self.assertEqual(retcode, 0)
                     expected_values = {"TF_VERSION": expected_new_tfpk_ver, "DOCKERFILE_VERSION": expected_dockerfile_ver, "PK_VERSION": expected_new_tfpk_ver}
                     expected_store_content = JSON_CONTENT_WITHOUT_FORCE_TEMPLATE.format(**expected_values)
                     store_s3 = Store(self.mngr.read_object(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     store_github = Store(dockerfile_repo.get_file_content(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     store_expected = Store(expected_store_content, dockerfile_repo_name=dockerfile_repo_name)
                     self.assertTrue(store_github.equals(store_s3))
                     self.assertTrue(store_github.equals(store_expected))
                     self.assertTrue(store_github.version(os.path.basename(dockerfile_repo_name)), expected_dockerfile_ver)
                     # run the lambda function again with the same version of tf
                     retcode = lambda_function.lambda_handler(None, None)
                     store_s3 = Store(self.mngr.read_object(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     store_github = Store(dockerfile_repo.get_file_content(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     # version and Dockerfile has not been changed ...
                     self.assertTrue(store_github.version(os.path.basename(dockerfile_repo_name)), expected_dockerfile_ver)
                     self.assertTrue(store_github.equals(store_expected))
             expected_new_tfpk_ver = "vAA.BB.CC"
             expected_dockerfile_ver = "3"
             with mock.patch("lambda_function.get_latest_hashicorp_terraform_version", return_value=expected_new_tfpk_ver) :
                 with mock.patch("lambda_function.get_latest_hashicorp_packer_version", return_value=expected_new_tfpk_ver):
                     retcode = lambda_function.lambda_handler(None, None)
                     self.assertEqual(retcode, 0)
                     expected_values = {"TF_VERSION": expected_new_tfpk_ver, "DOCKERFILE_VERSION": expected_dockerfile_ver, "PK_VERSION": expected_new_tfpk_ver}
                     expected_store_content = JSON_CONTENT_WITHOUT_FORCE_TEMPLATE.format(**expected_values)
                     store_s3 = Store(self.mngr.read_object(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     store_github = Store(dockerfile_repo.get_file_content(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     store_expected = Store(expected_store_content, dockerfile_repo_name=dockerfile_repo_name)
                     self.assertTrue(store_github.equals(store_s3))
                     self.assertTrue(store_github.equals(store_expected))
                     self.assertTrue(store_github.version(os.path.basename(dockerfile_repo_name)), expected_dockerfile_ver)
                     # run the lambda function again with the same version of tf
                     retcode = lambda_function.lambda_handler(None, None)
                     store_s3 = Store(self.mngr.read_object(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     store_github = Store(dockerfile_repo.get_file_content(self.internal_store_path), dockerfile_repo_name=dockerfile_repo_name)
                     # version and Dockerfile has not been changed ...
                     self.assertTrue(store_github.version(os.path.basename(dockerfile_repo_name)), expected_dockerfile_ver)
                     self.assertTrue(store_github.equals(store_expected))
                     self.assertTrue(store_github.version(os.path.basename(dockerfile_repo_name)), expected_dockerfile_ver)
     except lambda_function.LambdaException as e:
         self.fail(str(e))
コード例 #27
0
def test_import_document_error(
    boto3_client_mock,
    os_remove_mock,
    put_partner_in_db_ids,
    invalid_records_above_threshold_event,
    rds,
    caplog,
):
    lambda_handler(invalid_records_above_threshold_event, None)
    assert all_in(["ERROR", "IMPORT_FAILURE"], caplog.text)
    product_count = get_dummy_product_count(rds)
    assert product_count == 2
コード例 #28
0
def test_parse_invalid_document_error(
    boto3_client_mock,
    pg_connect_mock,
    os_remove_mock,
    db_config,
    invalid_document_event,
    caplog,
):
    lambda_handler(invalid_document_event, None)
    assert all_in(
        ["ERROR", "Parse record", "Expecting value", "IMPORT_FAILURE"],
        caplog.text)
コード例 #29
0
def test_intent():
    test_event = {
        "session": {
            "new": True,
            "sessionId": "SessionId.323e732c-a975-49b3-b796-82a5709b0c31",
            "application": {
                "applicationId":
                "amzn1.ask.skill.78652fba-466f-4a54-b5c0-ea7930de5788"
            },
            "attributes": {},
            "user": {
                "userId":
                "amzn1.ask.account.AESP3HPYTOIQHOFKO4XBHIIC74XJTON52GCQNBQR2ARB6XFIX5MKFNQ2QKBOLQTUYGXTM476RL4F7WKPYCMIJGGFT2QD6PNDSEHVIZN4KRLB5U2X7AEZM66CWD7YN2YJEMQBU6IJDFHMF6RQ44V5EGIWI62Y2N3IVFI3O7QNMEKAMGTBV5XJLKDKBYMN2XZF6UHHGKHQL45M2IY"
            }
        },
        "request": {
            "type": "IntentRequest",
            "requestId": "EdwRequestId.41fae6de-d61f-488c-936e-18f5abad6a0e",
            "intent": {
                "name": "IntentActivity",
                "slots": {
                    "activityname": {
                        "name": "activityname",
                        "value": "raid"
                    }
                }
            },
            "locale": "en-US",
            "timestamp": "2017-09-15T06:05:20Z"
        },
        "context": {
            "AudioPlayer": {
                "playerActivity": "IDLE"
            },
            "System": {
                "application": {
                    "applicationId":
                    "amzn1.ask.skill.78652fba-466f-4a54-b5c0-ea7930de5788"
                },
                "user": {
                    "userId":
                    "amzn1.ask.account.AESP3HPYTOIQHOFKO4XBHIIC74XJTON52GCQNBQR2ARB6XFIX5MKFNQ2QKBOLQTUYGXTM476RL4F7WKPYCMIJGGFT2QD6PNDSEHVIZN4KRLB5U2X7AEZM66CWD7YN2YJEMQBU6IJDFHMF6RQ44V5EGIWI62Y2N3IVFI3O7QNMEKAMGTBV5XJLKDKBYMN2XZF6UHHGKHQL45M2IY"
                },
                "device": {
                    "supportedInterfaces": {}
                }
            }
        },
        "version": "1.0"
    }
    lambda_handler(test_event, None)
コード例 #30
0
 def test_lambda_handler(self):
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='gzip, deflate, br',
                                   uri="/packs/application.0332f160.js"),
             None)['uri'], '/packs/application.0332f160.js.br')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='gzip',
                                   uri="/packs/application.0332f160.js"),
             None)['uri'], '/packs/application.0332f160.js.gz')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='deflate',
                                   uri="/packs/application.0332f160.js"),
             None)['uri'], '/packs/application.0332f160.js')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='gzip, br',
                                   uri='/packs/css/foobar.css'),
             None)['uri'], '/packs/css/foobar.css.br')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='gzip',
                                   uri='/packs/css/foobar.css'),
             None)['uri'], '/packs/css/foobar.css.gz')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='br',
                                   uri='/packs/css/foobar.css'),
             None)['uri'], '/packs/css/foobar.css.br')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='deflate',
                                   uri='/packs/css/foobar.css'),
             None)['uri'], '/packs/css/foobar.css')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='gzip',
                                   uri='/packs/media/foobar.svg'),
             None)['uri'], '/packs/media/foobar.svg')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='br',
                                   uri='/packs/media/foobar.svg'),
             None)['uri'], '/packs/media/foobar.svg')
     self.assertEqual(
         lambda_handler(
             self.cloudfront_event(accept_encoding='deflate',
                                   uri='/packs/media/foobar.svg'),
             None)['uri'], '/packs/media/foobar.svg')
コード例 #31
0
 def test_response(self):
     print("testing response.")
     event = {'Country': 'USA'}
     result = lambda_function.lambda_handler(event, None)
     print(result)
     self.assertEqual(result['statusCode'], 200)
     self.assertEqual(result['headers']['Content-Type'], 'application/json')
     self.assertIn('Hello from ' + event['Country'], result['body'])
     event = {'Country': 'INDIA'}
     result = lambda_function.lambda_handler(event, None)
     print(result)
     self.assertEqual(result['statusCode'], 200)
     self.assertEqual(result['headers']['Content-Type'], 'application/json')
     self.assertIn('Hello from ' + event['Country'], result['body'])
コード例 #32
0
ファイル: test_lambda.py プロジェクト: ncvc/chat-wheel
MSG = {
	u'timestamp': 1460870880139,
	u'postback': {
		u'payload': u'NEXT_USER'
	},
	u'recipient': {
		u'id': 12345
	},
	u'sender': {
		u'id': 12345
	}
}


EVENT = {
	'body': {
		"object":"page",
		"entry":[
			{
				"id": "page_id",
				"time":1457764198246,
				"messaging":[ MSG ],
			}
		]
	}
}
CONTEXT = None

if __name__ == '__main__':
	print('Response:', lambda_function.lambda_handler(EVENT, CONTEXT))
コード例 #33
0
ファイル: test_lambda.py プロジェクト: appfolio/landa
    "site_admin": false
  }
}
"""

for search, replace in {
  'pr_id': str(pr_id),
  'pr_author': pr_author,
  'repo_owner': repo_owner,
  'repo': repo,
  'base_branch': base_branch,
  'head_branch': head_branch,
  'head_sha': head_sha,
}.items():
    github_event = github_event.replace('{' + search + '}', replace)

sns_wrapper = {
    'Records': [{
        'Sns': {
            'Message': github_event,
            'MessageAttributes': {
                'X-Github-Event': {
                    'Value': 'pull_request'
                }
            }
        }
    }]
}

lambda_function.lambda_handler(sns_wrapper, None, debug=True)
コード例 #34
0
def alexa_skills_kit_requests():
    request_obj = request.get_json()
    return lambda_handler(request_obj)
コード例 #35
0
ファイル: test.py プロジェクト: hx-markterry/webhook-test
#!/usr/bin/env python
from __future__ import print_function
import lambda_function

if __name__ == '__main__':
    event = {
      'A': 1
    }
    context = 1
    lambda_function.lambda_handler(event, context)
コード例 #36
0
ファイル: test.py プロジェクト: WisdomWolf/ask-alexa-pykit
'''
Script for testing out the response for any given request
'''
from __future__ import print_function
from lambda_function import lambda_handler
import json
import sys
from argparse import ArgumentParser

if __name__ == '__main__':
    parser = ArgumentParser()
    parser.add_argument('-i', '--input_json', required=True)
    args = parser.parse_args()
    request_obj = json.load(open(args.input_json))
    print ('Request JSON')
    print (json.dumps(request_obj, indent=2))
    response = lambda_handler(request_obj)
    print ('Response JSON')
    print (json.dumps(response, indent=2))