class TestUserService(TestCase): def setUp(self): self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) @patch("common.boto_utils.BotoUtils.invoke_lambda") def test_delete_user(self, mock_invoke_lambda): user_service = UserService() username = "******" account_id = "123" name = "dummy_135" status = 1 request_id = "id_123" current_time = datetime.utcnow() epoch_time = current_time.timestamp() self.repo.execute( "INSERT INTO user (username, account_id, name, email, email_verified, status, request_id, " "request_time_epoch, row_created, row_updated) VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", [ username, account_id, name, username, 1, status, request_id, epoch_time, current_time, current_time ]) mock_invoke_lambda.return_value = {"statusCode": 201, "body": ""} user_service.delete_user(username) user_data = self.repo.execute( "SELECT username FROM user WHERE username = %s", [username]) if len(user_data) == 0: assert True else: assert True def tearDown(self): self.repo.execute("DELETE FROM user")
class DappUserService(TestCase): def setUp(self): self._repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) @patch("common.utils.Utils.report_slack") def test_register_user_on_post_cognito_signup(self, report_slack): report_slack.return_value = None event = { 'version': '1', 'region': 'us-east-2', 'userPoolId': 'us-east-2 tyuiop', 'userName': '******', 'callerContext': { 'awsSdkVersion': 'aws-sdk-unknown-unknown', 'clientId': 'dummy_client_id_1' }, 'triggerSource': 'PostConfirmation_ConfirmSignUp', 'request': { 'userAttributes': { 'sub': '23456789-d2cb-4388-9915-3456789', 'cognito:email_alias': '*****@*****.**', 'cognito:user_status': 'CONFIRMED', 'email_verified': 'true', 'nickname': 'Piyush', 'email': '*****@*****.**' } }, 'response': {} } event_response = register_user_post_aws_cognito_signup(event, None) assert (event_response == event) def tearDown(self): self._repo.execute("DELETE FROM user")
class TestWalletAPI(unittest.TestCase): def setUp(self): self.NETWORKS_NAME = dict((NETWORKS[netId]["name"], netId) for netId in NETWORKS.keys()) self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) @patch("common.utils.Utils.report_slack") @patch("common.blockchain_util.BlockChainUtil.create_account") def test_create_wallet(self, mock_create_account, mock_report_slack): create_wallet_event = { "path": "/wallet", "httpMethod": "POST", "body": '{"username": "******"}', } mock_create_account.return_value = ( "323449587122651441342932061624154600879572532581", "26561428888193216265620544717131876925191237116680314981303971688115990928499", ) response = lambda_handler.request_handler(create_wallet_event, context=None) assert response["statusCode"] == 200 response_body = json.loads(response["body"]) assert response_body["status"] == "success" assert (response_body["data"]["address"] == "323449587122651441342932061624154600879572532581") assert ( response_body["data"]["private_key"] == "26561428888193216265620544717131876925191237116680314981303971688115990928499" ) assert response_body["data"]["status"] == 0 assert response_body["data"]["type"] == "GENERAL" @patch("common.utils.Utils.report_slack") def test_create_wallet_and_channel(self, mock_report_slack): pass @patch("common.utils.Utils.report_slack") def test_create_channel(self, mock_report_slack): pass @patch("common.utils.Utils.report_slack") def test_top_up_channel(self, mock_report_slack): pass @patch("common.utils.Utils.report_slack") def test_get_wallet_details(self, mock_report_slack): pass @patch("common.utils.Utils.report_slack") def test_register_wallets(self, mock_report_slack): pass @patch("common.utils.Utils.report_slack") def test_set_default_wallet(self, mock_report_slack): pass def tearDown(self): self.repo.execute("DELETE FROM wallet") self.repo.execute("DELETE FROM user_wallet")
class TestMPE(TestCase): def setUp(self): self.NETWORKS_NAME = dict( (NETWORKS[netId]["name"], netId) for netId in NETWORKS.keys()) self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) self.mpe = MPE(self.repo) def test_update_consumed_balance(self): mpe_repo = MPERepository(self.repo) mpe_repo.create_channel({ "channelId": 1, "sender": '0x123', "recipient": "0x345", "groupId": b"\xbc\xb0\xa1\x93Z\xa1\xab\x11\xfd\xbcX\x1c\x1cxZ\xdc.\xb6\xba\x8e\xc6\xc8C*\xd7\xa9\xea\x91\xe6'\xae\xfc", "amount": 100, "pending": 0, "nonce": 0, "expiration": 8396357, "signer": '0x987', "consumed_balance": 12 }) mpe_repo.create_channel({ "channelId": 2, "sender": '0x3432', "recipient": "0x5453", "groupId": b"\xbc\xb0\xa1\x93Z\xa1\xab\x11\xfd\xbcX\x1c\x1cxZ\xdc.\xb6\xba\x8e\xc6\xc8C*\xd7\xa9\xea\x91\xe6'\xae\xfc", "amount": 100, "pending": 0, "nonce": 1, "expiration": 8396357, "signer": '0x987', "consumed_balance": 3 }) self.assertDictEqual({}, self.mpe.update_consumed_balance(1, 13, 100, 0)) try: self.mpe.update_consumed_balance(2, 2, 100, 1) except: assert True try: self.mpe.update_consumed_balance(2, 4, 100, 0) except: assert True try: self.mpe.update_consumed_balance(2, 4, 80, 1) except: assert True def tearDown(self): self.repo.execute("DELETE FROM `mpe_channel`")
def test_update_transaction_status(self, mock_report_slack): response = request_handler(event={}, context=None) assert (response == "success") repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) query_response = repo.execute( "SELECT * FROM transaction_history WHERE status = %s", "ORDER_CANCELED") assert (len(query_response) > 1)
class TestCreateChannelConsumer(TestCase): def setUp(self): self.connection = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) @patch( "wallets.service.wallet_service.WalletService.open_channel_by_third_party" ) def test_create_channel_event_consumer_success(self, create_channel_mock): create_channel_mock.return_value = {} channel_dao = ChannelDAO(self.connection) channel_dao.persist_create_channel_event( { "r": "0x7be1502b09f5997339571f4885194417d6ca84ca65f98a9a2883d981d071ba62", "s": "0x55bcc83399b93bc60d70d4b10e33db626eac0dafd863b91e00a6b4b2c3586eb6", "v": 27, "amount": 2, "org_id": "snet", "sender": "0x4A3Beb90be90a28fd6a54B6AE449dd93A3E26dd0", "currency": "USD", "group_id": "m5FKWq4hW0foGW5qSbzGSjgZRuKs7A1ZwbIrJ9e96rc=", "order_id": "b7d9ffa0-07a3-11ea-b3cf-9e57fd86be16", "recipient": "0xfA8a01E837c30a3DA3Ea862e6dB5C6232C9b800A", "signature": "0x7be1502b09f5997339571f4885194417d6ca84ca65f98a9a2883d981d071ba6255bcc83399b93bc60d70d4b10e33db626eac0dafd863b91e00a6b4b2c3586eb61b", "amount_in_cogs": 4000, "current_block_no": 6780504 }, datetime.now().strftime("%Y-%m-%d %H:%M:%S")) ManageCreateChannelEvent().manage_create_channel_event() channel_create_events = channel_dao.get_one_create_channel_event( TransactionStatus.PENDING) if channel_create_events is None: assert True def test_create_channel_even_consumer_no_data(self): ManageCreateChannelEvent().manage_create_channel_event() def tearDown(self): self.connection.execute("DELETE FROM create_channel_event")
def test_cancel_given_order(self, mock_report_slack): event = { "path": "/orchestrator/order/Fb736cfa-dae4-11e9-9769-26327914c219/cancel", "pathParameters": { "order_id": "Fb736cfa-dae4-11e9-9769-26327914c219" }, "httpMethod": "GET" } response = cancel_given_order(event=event, context=None) assert (response["statusCode"] == 200) response_body = json.loads(response["body"]) assert (response_body["status"] == "success") repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) query_response = repo.execute( "SELECT * FROM transaction_history WHERE order_id = %s AND status = %s", ["Fb736cfa-dae4-11e9-9769-26327914c219", "ORDER_CANCELED"]) assert (len(query_response) == 1)
class HandleContractsDB: def __init__(self, err_obj, net_id): self.err_obj = err_obj self.repo = Repository(net_id) self.util_obj = Utils() # read operations def read_registry_events(self): query = 'select * from registry_events_raw where processed = 0 order by block_no asc limit ' + EVNTS_LIMIT evts_dta = self.repo.execute(query) print('read_registry_events::read_count: ', len(evts_dta)) return evts_dta def read_mpe_events(self): query = 'select * from mpe_events_raw where processed = 0 order by block_no asc limit ' + EVNTS_LIMIT evts_dta = self.repo.execute(query) print('read_mpe_events::read_count: ', len(evts_dta)) return evts_dta def _get_srvc_row_id(self, org_id, service_id): print('get_srvc_row_id::service_id: ', service_id) query = 'SELECT row_id FROM service WHERE service_id = %s AND org_id = %s ' srvc_data = self.repo.execute(query, [service_id, org_id]) print('get_srvc_row_id::srvc_data: ', srvc_data) return srvc_data def _get_srvcs(self, org_id): query = 'SELECT * FROM service WHERE org_id = %s ' srvc_data = self.repo.execute(query, (org_id)) print('_get_srvcs::srvc_data: ', srvc_data) return srvc_data # write operations def _create_or_updt_org(self, org_id, org_data, conn): upsert_qry = "Insert into organization (org_id, organization_name, owner_address, row_updated, row_created) " \ "VALUES ( %s, %s, %s, %s, %s ) " \ "ON DUPLICATE KEY UPDATE organization_name = %s, owner_address = %s, row_updated = %s " upsert_params = [org_id, org_data[2], org_data[3], dt.utcnow(), dt.utcnow(), org_data[2], org_data[3], dt.utcnow()] print('upsert_qry: ', upsert_qry) qry_resp = conn.execute(upsert_qry, upsert_params) print('_create_or_updt_org::row upserted: ', qry_resp) def _create_or_updt_members(self, org_id, members, conn): upsrt_members = "INSERT INTO members (org_id, member, row_created, row_updated)" \ "VALUES ( %s, %s, %s, %s )" \ "ON DUPLICATE KEY UPDATE row_updated = %s " cnt = 0 for member in members: upsrt_members_params = [org_id, member, dt.utcnow(), dt.utcnow(), dt.utcnow()] qry_res = conn.execute(upsrt_members, upsrt_members_params) cnt = cnt + qry_res[0] print('create_or_updt_members::row upserted', cnt) def _create_channel(self, q_dta, conn): upsrt_mpe_chnl = "INSERT INTO mpe_channel (channel_id, sender, recipient, groupId, balance_in_cogs, pending, nonce, " \ "expiration, signer, row_created, row_updated) " \ "VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE balance_in_cogs = %s, pending = %s, nonce = %s, " \ "expiration = %s, row_updated = %s" upsrt_mpe_chnl_params = [q_dta['channelId'], q_dta['sender'], q_dta['recipient'], q_dta['groupId'], q_dta['amount'], 0.0, q_dta['nonce'], q_dta['expiration'], q_dta['signer'], dt.utcnow(), dt.utcnow(), q_dta['amount'], 0.0, q_dta['nonce'], q_dta['expiration'], dt.utcnow()] qry_res = conn.execute(upsrt_mpe_chnl, upsrt_mpe_chnl_params) print('_create_channel::row upserted', qry_res) def _del_srvc(self, org_id, service_id, conn): del_srvc = 'DELETE FROM service WHERE service_id = %s AND org_id = %s ' qry_res = conn.execute(del_srvc, [service_id, org_id]) print('_del_srvc::rows deleted: ', qry_res) def _del_org(self, org_id, conn): del_org = 'DELETE FROM organization WHERE org_id = %s ' qry_res = conn.execute(del_org, org_id) print('_del_org::rows deleted: ', qry_res) def _del_members(self, org_id, conn): del_org = 'DELETE FROM members WHERE org_id = %s ' qry_res = conn.execute(del_org, org_id) print('_del_members::rows deleted: ', qry_res) def _del_tags(self, org_id, service_id, conn): del_srvc_tags = 'DELETE FROM service_tags WHERE service_id = %s AND org_id = %s ' del_srvc_tags_count = conn.execute(del_srvc_tags, [service_id, org_id]) print('_del_tags::del_srvc_tags: ', del_srvc_tags_count) def _del_srvc_dpndts(self, org_id, service_id, conn): print("_del_srvc_dpndts::service_id: ", service_id, '|org_id: ', org_id) del_srvc_grps = 'DELETE FROM service_group WHERE service_id = %s AND org_id = %s ' del_srvc_grps_count = conn.execute(del_srvc_grps, [service_id, org_id]) del_srvc_endpts = 'DELETE FROM service_endpoint WHERE service_id = %s AND org_id = %s ' del_srvc_endpts_count = conn.execute(del_srvc_endpts, [service_id, org_id]) del_srvc_st = 'DELETE FROM service_status WHERE service_id = %s AND org_id = %s ' del_srvc_st_count = conn.execute(del_srvc_st, [service_id, org_id]) self._del_tags(org_id=org_id, service_id=service_id, conn=conn) print('_del_srvc_dpndts::del_srvc_grps: ', del_srvc_grps_count, '|del_srvc_endpts: ', del_srvc_endpts_count, '|del_srvc_st_count: ', del_srvc_st_count) def _create_or_updt_srvc(self, org_id, service_id, ipfs_hash, conn): upsrt_srvc = "INSERT INTO service (org_id, service_id, is_curated, ipfs_hash, row_created, row_updated) " \ "VALUES (%s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE ipfs_hash = %s, row_updated = %s " upsrt_srvc_params = [org_id, service_id, 0, ipfs_hash, dt.utcnow(), dt.utcnow(), ipfs_hash, dt.utcnow()] qry_res = conn.execute(upsrt_srvc, upsrt_srvc_params) print('_create_or_updt_srvc::row upserted', qry_res) return qry_res[len(qry_res) - 1] def _create_or_updt_srvc_mdata(self, srvc_rw_id, org_id, service_id, ipfs_data, conn): upsrt_srvc_mdata = "INSERT INTO service_metadata (service_row_id, org_id, service_id, price_model, " \ "price_in_cogs, display_name, model_ipfs_hash, description, url, json, encoding, type, " \ "mpe_address, payment_expiration_threshold, row_updated, row_created) " \ "VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE service_row_id = %s, price_model = %s, price_in_cogs = %s, " \ "display_name = %s, model_ipfs_hash = %s, description = %s, url = %s, json = %s, " \ "encoding = %s, type = %s, mpe_address = %s, payment_expiration_threshold = %s, row_updated = %s " price = ipfs_data['pricing'] price_model = price.get('price_model', '') price_in_cogs = price.get('price_in_cogs', '') pm_exp_th = ipfs_data.get('payment_expiration_threshold') srvc_desc = ipfs_data.get('service_description', {}) desc = srvc_desc.get('description', '') url = srvc_desc.get('url', '') json_str = ipfs_data.get('json', '') upsrt_srvc_mdata_params = [srvc_rw_id, org_id, service_id, price_model, price_in_cogs, ipfs_data['display_name'], ipfs_data['model_ipfs_hash'], desc, url, json_str, ipfs_data['encoding'], ipfs_data['service_type'], ipfs_data['mpe_address'], pm_exp_th, dt.utcnow(), dt.utcnow(), srvc_rw_id, price_model, price_in_cogs, ipfs_data['display_name'], ipfs_data['model_ipfs_hash'],desc, url, json_str, ipfs_data['encoding'], ipfs_data['service_type'], ipfs_data['mpe_address'], pm_exp_th, dt.utcnow()] qry_res = conn.execute(upsrt_srvc_mdata, upsrt_srvc_mdata_params) print('_create_or_updt_srvc_mdata::row upserted', qry_res) def _create_grp(self, srvc_rw_id, org_id, service_id, grp_data, conn): insrt_grp = "INSERT INTO service_group (service_row_id, org_id, service_id, group_id, group_name, " \ "payment_address, row_updated, row_created)" \ "VALUES(%s, %s, %s, %s, %s, %s, %s, %s)" insrt_grp_params = [srvc_rw_id, org_id, service_id, grp_data['group_id'], grp_data['group_name'], grp_data['payment_address'], dt.utcnow(), dt.utcnow()] return conn.execute(insrt_grp, insrt_grp_params) def _create_edpts(self, srvc_rw_id, org_id, service_id, endpt_data, conn): insrt_endpt = "INSERT INTO service_endpoint (service_row_id, org_id, service_id, group_id, endpoint, " \ "row_created, row_updated) " \ "VALUES(%s, %s, %s, %s, %s, %s, %s)" insrt_endpt_params = [srvc_rw_id, org_id, service_id, endpt_data['group_id'], endpt_data['endpoint'], dt.utcnow(), dt.utcnow()] return conn.execute(insrt_endpt, insrt_endpt_params) def _create_tags(self, srvc_rw_id, org_id, service_id, tag_name, conn): insrt_tag = "INSERT INTO service_tags (service_row_id, org_id, service_id, tag_name, row_created, row_updated) " \ "VALUES(%s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE tag_name = %s, row_updated = %s " insrt_tag_params = [srvc_rw_id, org_id, service_id, tag_name, dt.utcnow(), dt.utcnow(), tag_name, dt.utcnow()] qry_res = conn.execute(insrt_tag, insrt_tag_params) print('_create_tags::qry_res: ', qry_res) def _updt_raw_evts(self, row_id, type, err_cd, err_msg, conn): try: if type == 'REG': updt_evts = 'UPDATE registry_events_raw SET processed = 1, error_code = %s, error_msg = %s WHERE row_id = %s ' elif type == 'MPE': updt_evts = 'UPDATE mpe_events_raw SET processed = 1, error_code = %s, error_msg = %s WHERE row_id = %s ' updt_evts_resp = self.repo.execute(updt_evts, [err_cd, err_msg, row_id]) print('updt_raw_evts::row updated: ', updt_evts_resp, '|', type) except Exception as e: self.util_obj.report_slack(type=1, slack_msg=repr(e)) print('Error in updt_reg_evts_raw::error: ', e) def updt_raw_evts(self, row_id, type, err_cd, err_msg): conn = self.repo self._updt_raw_evts(row_id, type, err_cd, err_msg, conn) def del_org(self, org_id): self.repo.auto_commit = False conn = self.repo try: self._del_org(org_id=org_id, conn=conn) srvcs = self._get_srvcs(org_id=org_id) for rec in srvcs: self._del_srvc(org_id=org_id, service_id=rec['service_id'], conn=conn) self._commit(conn=conn) except Exception as e: self.util_obj.report_slack(type=1, slack_msg=repr(e)) self._rollback(conn=conn, err=repr(e)) def del_srvc(self, org_id, service_id): self._del_srvc(org_id=org_id, service_id=service_id, conn=self.repo) def create_channel(self, q_dta): if q_dta['groupId'][0:2] == '0x': q_dta['groupId'] = q_dta['groupId'][2:] q_dta['groupId'] = base64.b64encode(bytes.fromhex(q_dta['groupId'])).decode('utf8') self._create_channel(q_dta, self.repo) def update_channel(self, channel_id, group_id, channel_data): print('update_channel::channel_id: ', channel_id) self._create_channel(q_dta={ 'sender': channel_data[1], 'recipient': channel_data[3], 'nonce': int(channel_data[0]), 'expiration': channel_data[6], 'signer': channel_data[2], 'groupId': group_id, 'channelId': channel_id, 'amount': channel_data[5] }, conn=self.repo) def process_srvc_data(self, org_id, service_id, ipfs_hash, ipfs_data, tags_data): self.repo.auto_commit = False conn = self.repo try: self._del_srvc_dpndts(org_id=org_id, service_id=service_id, conn=conn) qry_data = self._create_or_updt_srvc(org_id=org_id, service_id=service_id, ipfs_hash=ipfs_hash, conn=conn) service_row_id = qry_data['last_row_id'] print('service_row_id == ', service_row_id) self._create_or_updt_srvc_mdata(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, ipfs_data=ipfs_data, conn=conn) grps = ipfs_data.get('groups', []) cnt = 0 grp_name_id_dict = {} for grp in grps: grp_name_id_dict[grp['group_name']] = grp['group_id'] qry_data = self._create_grp(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, conn=conn, grp_data={ 'group_id': grp['group_id'], 'group_name': grp['group_name'], 'payment_address': grp['payment_address'] }) cnt = cnt + qry_data[0] print('rows insert in grp: ', cnt) endpts = ipfs_data.get('endpoints', []) cnt = 0 for endpt in endpts: qry_data = self._create_edpts(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, conn=conn, endpt_data={ 'endpoint': endpt['endpoint'], 'group_id': grp_name_id_dict[endpt['group_name']] }) cnt = cnt + qry_data[0] print('rows insert in endpt: ', cnt) if (tags_data is not None and tags_data[0]): tags = tags_data[3] for tag in tags: tag = tag.decode('utf-8') tag = tag.rstrip("\u0000") self._create_tags(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, tag_name=tag, conn=conn) self._commit(conn=conn) except Exception as e: self.util_obj.report_slack(type=1, slack_msg=repr(e)) self._rollback(conn=conn, err=repr(e)) def process_org_data(self, org_id, org_data): self.repo.auto_commit = False conn = self.repo try: if (org_data is not None and org_data[0]): self._create_or_updt_org(org_id, org_data, conn) self._del_members(org_id=org_id, conn=conn) self._create_or_updt_members(org_id, org_data[4], conn) self._commit(conn) except Exception as e: self.util_obj.report_slack(type=1, slack_msg=repr(e)) self._rollback(conn=conn, err=repr(e)) def update_tags(self, org_id, service_id, tags_data): self.repo.auto_commit = False conn = self.repo try: self._del_tags(org_id=org_id, service_id=service_id, conn=conn) if (tags_data is not None and tags_data[0]): tags = tags_data[3] srvc_data = self._get_srvc_row_id(service_id=service_id, org_id=org_id) srvc_rw_id = srvc_data[0]['row_id'] for tag in tags: tag = tag.decode('utf-8') tag = tag.rstrip("\u0000") self._create_tags(srvc_rw_id=srvc_rw_id, org_id=org_id, service_id=service_id, tag_name=tag, conn=conn) self._commit(conn) except Exception as e: self.util_obj.report_slack(type=1, slack_msg=repr(e)) self._rollback(conn=conn, err=repr(e)) # def _commit(self, conn): conn.auto_commit = True conn.connection.commit() print('_commit') print(conn.connection) def _rollback(self, conn, err): print('_rollback ::error: ', err) conn.auto_commit = True conn.connection.rollback()
class UserRepository: def __init__(self): self._repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) def enable_preference(self, user_preference, user_row_id): enable_preference_query = \ "INSERT INTO user_preference (user_row_id, preference_type, communication_type, source, status, " \ "created_on, updated_on) " \ "VALUES(%s, %s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE status = %s, updated_on = %s" query_response = self._repo.execute(enable_preference_query, [ user_row_id, user_preference.preference_type, user_preference.communication_type, user_preference.source, user_preference.status, dt.utcnow(), dt.utcnow(), user_preference.status, dt.utcnow() ]) return query_response def get_user_data_for_given_username(self, username): get_user_data_query = \ "SELECT row_id, username, account_id, name, email, email_verified, email_alerts, status, request_id, " \ "request_time_epoch, is_terms_accepted FROM user WHERE username = %s LIMIT 1" user_data = self._repo.execute(get_user_data_query, username) return user_data def disable_preference(self, user_preference, user_row_id): disable_preference_query = \ "UPDATE user_preference SET status = %s, opt_out_reason = %s WHERE user_row_id = %s " \ "AND preference_type = %s AND communication_type = %s AND source = %s" query_response = self._repo.execute(disable_preference_query, [ user_preference.status, user_preference.opt_out_reason, user_row_id, user_preference.preference_type, user_preference.communication_type, user_preference.source ]) return query_response def get_user_preferences(self, user_row_id): get_user_preference = \ "SELECT status, preference_type, communication_type, source, opt_out_reason FROM user_preference WHERE user_row_id = %s " query_response = self._repo.execute(get_user_preference, [user_row_id]) return query_response def delete_user(self, username): query = "DELETE FROM user WHERE username = %s " self._repo.execute(query, [username]) def register_user_data(self, user): """ register user data """ user_data = self.get_user_data_for_given_username( username=user.username) if bool(user_data): raise UserAlreadyExistException() query_parameters = [ user.email, "", user.origin, user.name, user.email, user.email_verified, user.email_verified, "", "", dt.utcnow(), dt.utcnow() ] query_response = self._repo.execute( "INSERT INTO user (username, account_id, origin, name, email, email_verified, status, request_id, " "request_time_epoch, row_created, row_updated) " "VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", query_parameters) return "SUCCESS"
class TestMonitorService(TestCase): def setUp(self): self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) # @patch("service_status.monitor_service.MonitorServiceCertificate._get_service_endpoint_data") # @patch( # "service_status.monitor_service.MonitorServiceCertificate._get_certification_expiration_date_for_given_service") # @patch("service_status.monitor_service.MonitorServiceCertificate._get_service_provider_email") # @patch("common.utils.Utils.report_slack") # @patch("service_status.monitor_service.MonitorServiceCertificate._send_email_notification") # def test_monitor_service_certificate_expiry_handler( # self, _send_email_notification, report_slack, _get_service_provider_email, # _get_certification_expiration_date_for_given_service, # _get_service_endpoint_data): # _get_service_endpoint_data.return_value = [ # {"endpoint": "https://dummy.com:9999", "org_id": "test_org_id", "service_id": "test_service"}] # _get_certification_expiration_date_for_given_service.return_value = dt.utcnow() + timedelta(days=25) # _get_service_provider_email.return_value = ["*****@*****.**"] # report_slack.return_value = None # _send_email_notification.return_value = None # response = monitor_service_certificates_expiry_handler(event={}, context=None) # assert (response == "success") # def test_reset_service_health_failed_status_count(self): # self.tearDown() # created_at = dt.utcnow() - timedelta(days=25) # updated_at = dt.utcnow() - timedelta(hours=6) # last_check_timestamp = dt.utcnow() - timedelta(hours=6) # next_check_timestamp = dt.utcnow() + timedelta(hours=6) # current_timestamp = dt.utcnow() # org_id = "test_org_id" # service_id = "test_service_id" # self.repo.execute( # "INSERT INTO service (row_id, org_id, service_id, service_path, ipfs_hash, is_curated, row_created, row_updated)" # "VALUES(1, %s, %s, '', '', 0, %s, %s)", # [org_id, service_id, created_at, updated_at] # ) # self.repo.execute( # "INSERT INTO service_endpoint (service_row_id, org_id, service_id, group_id, endpoint, is_available, " # "last_check_timestamp, next_check_timestamp, failed_status_count, row_created, row_updated)" # "VALUES(1, %s, %s, 'test_group_id', 'https://dummy.io', 0, %s, %s, 10, %s, %s)", # [org_id, service_id, last_check_timestamp, next_check_timestamp, created_at, updated_at] # ) # event = { # "httpMethod": "GET", # "pathParameters": { # "org_id": org_id, # "service_id": service_id} # } # response = reset_service_health_next_check_time(event=event, context=None) # db_response = self.repo.execute( # "SELECT next_check_timestamp FROM service_endpoint WHERE org_id = %s AND service_id = %s", # [org_id, service_id]) # date_diff = (db_response[0]["next_check_timestamp"] - current_timestamp) # assert ((date_diff.microseconds / 1000000) <= 2) # assert (response["statusCode"] == 200) # response_body = json.loads(response["body"]) # assert (response_body["data"] == "We will trigger a health check immediately.") def test_get_service_status(self, secure=True): url = "https://bh.singularitynet.io:7252" url = "138.197.215.173:5001" try: if secure: channel = grpc.secure_channel( url, grpc.ssl_channel_credentials( root_certificates=certificate)) else: channel = grpc.insecure_channel(url) stub = heartb_pb2_grpc.HealthStub(channel) response = stub.Check(heartb_pb2.HealthCheckRequest(service=""), timeout=10) if response is not None and response.status == 1: # logger.info(response.status) return 1 return 0 except Exception as e: # logger.info(f"error in making grpc call::url: {url}, |error: {e}") return 0 def tearDown(self): self.repo.execute("DELETE FROM service") self.repo.execute("DELETE FROM service_endpoint")
class TestWalletService(unittest.TestCase): def setUp(self): self.NETWORKS_NAME = dict( (NETWORKS[netId]["name"], netId) for netId in NETWORKS.keys()) self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) self.wallet_service = WalletService(repo=self.repo) @patch("common.utils.Utils.report_slack") @patch("common.blockchain_util.BlockChainUtil.create_account") def test_create_wallet(self, mock_create_account, mock_report_slack): mock_create_account.return_value = ( "323449587122651441342932061624154600879572532581", "26561428888193216265620544717131876925191237116680314981303971688115990928499", ) response = self.wallet_service.create_and_register_wallet( username="******") self.assertDictEqual( response, { "address": "323449587122651441342932061624154600879572532581", "private_key": "26561428888193216265620544717131876925191237116680314981303971688115990928499", "status": 0, "type": "GENERAL" }) @patch("common.utils.Utils.report_slack") @patch("wallets.dao.wallet_data_access_object.WalletDAO.get_wallet_details" ) @patch("wallets.dao.wallet_data_access_object.WalletDAO.insert_wallet") @patch( "wallets.dao.wallet_data_access_object.WalletDAO.add_user_for_wallet") def test_register_wallet(self, mock_add_user_for_wallet, mock_insert_wallet, mock_get_wallet_details, mock_report_slack): """ insert new wallet for user """ mock_get_wallet_details.return_value = [] address = "323449587122651441342932061624154600879572532581" type = "GENERAL" status = 0 username = "******" response = self.wallet_service.register_wallet(username, address, type, status) assert response self.assertRaises( Exception, self.wallet_service.register_wallet(username, address, type, status)) def test_remove_user_wallet(self): wallet_dao = WalletDAO(self.repo) username = "******" wallet = Wallet(address="32344958712265144", type="GENERAL", status=0) wallet_dao.insert_wallet(wallet) wallet_dao.add_user_for_wallet(wallet, username) self.wallet_service.remove_user_wallet(username) wallet_details = wallet_dao.get_wallet_data_by_username(username) if len(wallet_details) == 0: assert True else: assert False def tearDown(self): self.repo.execute("DELETE FROM wallet") self.repo.execute("DELETE FROM user_wallet")
class TestUserSignUp(TestCase): def setUp(self): self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) def test_user_signup(self): self.tearDown() event = { "resource": "/signup", "path": "/dapp-user/signup", "httpMethod": "GET", "headers": { "Authorization": "", "Host": "ropsten-marketplace.singularitynet.io", "origin": "https://beta.singularitynet.io", "referer": "https://beta.singularitynet.io/aimarketplace", "sec-fetch-mode": "cors", "sec-fetch-site": "same-site" }, "multiValueHeaders": {}, "queryStringParameters": { "origin": "PUBLISHER_DAPP" }, "multiValueQueryStringParameters": None, "pathParameters": None, "stageVariables": None, "requestContext": { "resourceId": "kduff6", "authorizer": { "claims": { "sub": "00af3833-47ce-4b3c-b2f9-af09440dac30", "aud": "2ddk0m23u0ovju2fst34q0t96j", "email_verified": "true", "event_id": "7bb22434-626d-483d-8519-7275d61fdbae", "token_use": "id", "auth_time": "1583996248", "iss": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_fVrm4ARvK", "nickname": "Ankit", "cognito:username": "******", "exp": "Thu Mar 12 07:57:31 UTC 2020", "iat": "Thu Mar 12 06:57:31 UTC 2020", "email": "*****@*****.**" } }, "resourcePath": "/signup", "httpMethod": "GET", "extendedRequestId": "JQ-GlEIfIAMF9xw=", "requestTime": "12/Mar/2020:06:57:33 +0000", "path": "/dapp-user/signup", "accountId": "533793137436", "protocol": "HTTP/1.1", "stage": "mainnet", "domainPrefix": "mainnet-marketplace", "requestTimeEpoch": 1583996253283, "requestId": "0c543e73-343a-4d6f-9cbf-5ad1d5de6ec7", "identity": { "cognitoIdentityPoolId": None, "accountId": None, "cognitoIdentityId": None, "caller": None, "sourceIp": "111.93.235.50", "principalOrgId": None, "accessKey": None, "cognitoAuthenticationType": None, "cognitoAuthenticationProvider": None, "userArn": None, "userAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36", "user": None }, "domainName": "ropsten-marketplace.singularitynet.io", "apiId": "6nfct1u0yf" }, "isBase64Encoded": False } response = request_handler(event=event, context=None) assert (response["statusCode"] == 200) response_body = json.loads(response["body"]) assert (response_body["status"] == "success") record_count = self.repo.execute("SELECT * FROM user") assert (len(record_count) == 1) def tearDown(self): self.repo.execute("DELETE FROM user")
class TestMonitorService(TestCase): def setUp(self): self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) @patch( "service_status.monitor_service.MonitorServiceCertificate._get_service_endpoint_data" ) @patch( "service_status.monitor_service.MonitorServiceCertificate._get_certification_expiration_date_for_given_service" ) @patch( "service_status.monitor_service.MonitorServiceCertificate._get_service_provider_email" ) @patch("common.utils.Utils.report_slack") @patch( "service_status.monitor_service.MonitorServiceCertificate._send_email_notification" ) def test_monitor_service_certificate_expiry_handler( self, _send_email_notification, report_slack, _get_service_provider_email, _get_certification_expiration_date_for_given_service, _get_service_endpoint_data): _get_service_endpoint_data.return_value = [{ "endpoint": "https://dummy.com:9999", "org_id": "test_org_id", "service_id": "test_service" }] _get_certification_expiration_date_for_given_service.return_value = dt.utcnow( ) + timedelta(days=25) _get_service_provider_email.return_value = [ "*****@*****.**" ] report_slack.return_value = None _send_email_notification.return_value = None response = monitor_service_certificates_expiry_handler(event={}, context=None) assert (response == "success") def test_reset_service_health_failed_status_count(self): self.tearDown() created_at = dt.utcnow() - timedelta(days=25) updated_at = dt.utcnow() - timedelta(hours=6) last_check_timestamp = dt.utcnow() - timedelta(hours=6) next_check_timestamp = dt.utcnow() + timedelta(hours=6) current_timestamp = dt.utcnow() org_id = "test_org_id" service_id = "test_service_id" self.repo.execute( "INSERT INTO service (row_id, org_id, service_id, service_path, ipfs_hash, is_curated, row_created, row_updated)" "VALUES(1, %s, %s, '', '', 0, %s, %s)", [org_id, service_id, created_at, updated_at]) self.repo.execute( "INSERT INTO service_endpoint (service_row_id, org_id, service_id, group_id, endpoint, is_available, " "last_check_timestamp, next_check_timestamp, failed_status_count, row_created, row_updated)" "VALUES(1, %s, %s, 'test_group_id', 'https://dummy.io', 0, %s, %s, 10, %s, %s)", [ org_id, service_id, last_check_timestamp, next_check_timestamp, created_at, updated_at ]) event = { "httpMethod": "GET", "pathParameters": { "org_id": org_id, "service_id": service_id } } response = reset_service_health_next_check_time(event=event, context=None) db_response = self.repo.execute( "SELECT next_check_timestamp FROM service_endpoint WHERE org_id = %s AND service_id = %s", [org_id, service_id]) date_diff = (db_response[0]["next_check_timestamp"] - current_timestamp) assert ((date_diff.microseconds / 1000000) <= 2) assert (response["statusCode"] == 200) response_body = json.loads(response["body"]) assert (response_body["data"] == "We will trigger a health check immediately.") def tearDown(self): self.repo.execute("DELETE FROM service") self.repo.execute("DELETE FROM service_endpoint")
class HandleContractsDB: def __init__(self, err_obj, net_id): self.err_obj = err_obj self.repo = Repository(net_id, NETWORKS) self.util_obj = Utils() self.ipfs_utll = IPFSUtil(IPFS_URL['url'], IPFS_URL['port']) self.s3_util = S3Util(S3_BUCKET_ACCESS_KEY, S3_BUCKET_SECRET_KEY) # read operations def read_registry_events(self): query = 'select * from registry_events_raw where processed = 0 order by block_no asc limit ' + EVNTS_LIMIT evts_dta = self.repo.execute(query) print('read_registry_events::read_count: ', len(evts_dta)) return evts_dta def read_mpe_events(self): query = 'select * from mpe_events_raw where processed = 0 order by block_no asc limit ' + EVNTS_LIMIT evts_dta = self.repo.execute(query) print('read_mpe_events::read_count: ', len(evts_dta)) return evts_dta def _get_srvc_row_id(self, org_id, service_id): print('get_srvc_row_id::service_id: ', service_id) query = 'SELECT row_id FROM service WHERE service_id = %s AND org_id = %s ' srvc_data = self.repo.execute(query, [service_id, org_id]) print('get_srvc_row_id::srvc_data: ', srvc_data) return srvc_data def _get_srvcs(self, org_id): query = 'SELECT * FROM service WHERE org_id = %s ' srvc_data = self.repo.execute(query, (org_id)) print('_get_srvcs::srvc_data: ', srvc_data) return srvc_data # write operations def _create_or_updt_org(self, org_id, org_name, owner_address, org_metadata_uri, conn): upsert_qry = "Insert into organization (org_id, organization_name, owner_address, org_metadata_uri, row_updated, row_created) " \ "VALUES ( %s, %s, %s, %s, %s , %s) " \ "ON DUPLICATE KEY UPDATE organization_name = %s, owner_address = %s, org_metadata_uri = %s, row_updated = %s " upsert_params = [org_id, org_name, owner_address, org_metadata_uri, dt.utcnow(), dt.utcnow(), org_name, owner_address, org_metadata_uri, dt.utcnow()] print('upsert_qry: ', upsert_qry) qry_resp = conn.execute(upsert_qry, upsert_params) print('_create_or_updt_org::row upserted: ', qry_resp) def _del_org_groups(self, org_id, conn): delete_query = conn.execute( "DELETE FROM org_group WHERE org_id = %s ", [org_id]) def _create_org_groups(self, org_id, groups, conn): insert_qry = "Insert into org_group (org_id, group_id, group_name, payment, row_updated, row_created) " \ "VALUES ( %s, %s, %s, %s, %s, %s ) " cnt = 0 for group in groups: insert_params = [org_id, group['group_id'], group['group_name'], json.dumps( group['payment']), dt.utcnow(), dt.utcnow()] qry_res = conn.execute(insert_qry, insert_params) cnt = cnt + qry_res[0] print('_create_org_groups::row inserted', cnt) def _create_or_updt_members(self, org_id, members, conn): upsrt_members = "INSERT INTO members (org_id, member, row_created, row_updated)" \ "VALUES ( %s, %s, %s, %s )" \ "ON DUPLICATE KEY UPDATE row_updated = %s " cnt = 0 for member in members: upsrt_members_params = [org_id, member, dt.utcnow(), dt.utcnow(), dt.utcnow()] qry_res = conn.execute(upsrt_members, upsrt_members_params) cnt = cnt + qry_res[0] print('create_or_updt_members::row upserted', cnt) def _create_channel(self, q_dta, conn): upsrt_mpe_chnl = "INSERT INTO mpe_channel (channel_id, sender, recipient, groupId, balance_in_cogs, pending, nonce, " \ "expiration, signer, row_created, row_updated) " \ "VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE balance_in_cogs = %s, pending = %s, nonce = %s, " \ "expiration = %s, row_updated = %s" upsrt_mpe_chnl_params = [q_dta['channelId'], q_dta['sender'], q_dta['recipient'], q_dta['groupId'], q_dta['amount'], 0.0, q_dta['nonce'], q_dta['expiration'], q_dta['signer'], dt.utcnow( ), dt.utcnow(), q_dta['amount'], 0.0, q_dta['nonce'], q_dta['expiration'], dt.utcnow()] qry_res = conn.execute(upsrt_mpe_chnl, upsrt_mpe_chnl_params) print('_create_channel::row upserted', qry_res) def _del_srvc(self, org_id, service_id, conn): del_srvc = 'DELETE FROM service WHERE service_id = %s AND org_id = %s ' qry_res = conn.execute(del_srvc, [service_id, org_id]) print('_del_srvc::rows deleted: ', qry_res) def _del_org(self, org_id, conn): del_org = 'DELETE FROM organization WHERE org_id = %s ' qry_res = conn.execute(del_org, org_id) print('_del_org::rows deleted: ', qry_res) def _del_members(self, org_id, conn): del_org = 'DELETE FROM members WHERE org_id = %s ' qry_res = conn.execute(del_org, org_id) print('_del_members::rows deleted: ', qry_res) def _del_tags(self, org_id, service_id, conn): del_srvc_tags = 'DELETE FROM service_tags WHERE service_id = %s AND org_id = %s ' del_srvc_tags_count = conn.execute(del_srvc_tags, [service_id, org_id]) print('_del_tags::del_srvc_tags: ', del_srvc_tags_count) def _del_srvc_dpndts(self, org_id, service_id, conn): print("_del_srvc_dpndts::service_id: ", service_id, '|org_id: ', org_id) del_srvc_grps = 'DELETE FROM service_group WHERE service_id = %s AND org_id = %s ' del_srvc_grps_count = conn.execute(del_srvc_grps, [service_id, org_id]) del_srvc_endpts = 'DELETE FROM service_endpoint WHERE service_id = %s AND org_id = %s ' del_srvc_endpts_count = conn.execute( del_srvc_endpts, [service_id, org_id]) self._del_tags(org_id=org_id, service_id=service_id, conn=conn) print('_del_srvc_dpndts::del_srvc_grps: ', del_srvc_grps_count, '|del_srvc_endpts: ', del_srvc_endpts_count) def _create_or_updt_srvc(self, org_id, service_id, ipfs_hash, conn): upsrt_srvc = "INSERT INTO service (org_id, service_id, is_curated, ipfs_hash, row_created, row_updated) " \ "VALUES (%s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE ipfs_hash = %s, row_updated = %s " upsrt_srvc_params = [org_id, service_id, 0, ipfs_hash, dt.utcnow(), dt.utcnow(), ipfs_hash, dt.utcnow()] qry_res = conn.execute(upsrt_srvc, upsrt_srvc_params) print('_create_or_updt_srvc::row upserted', qry_res) return qry_res[len(qry_res) - 1] def _create_or_updt_srvc_mdata(self, srvc_rw_id, org_id, service_id, ipfs_data, assets_url, conn): upsrt_srvc_mdata = "INSERT INTO service_metadata (service_row_id, org_id, service_id, " \ "display_name, model_ipfs_hash, description, url, json, encoding, type, " \ "mpe_address, assets_hash , assets_url, service_rating, row_updated, row_created) " \ "VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s ) " \ "ON DUPLICATE KEY UPDATE service_row_id = %s, " \ "display_name = %s, model_ipfs_hash = %s, description = %s, url = %s, json = %s, " \ "encoding = %s, type = %s, mpe_address = %s, row_updated = %s ,assets_hash = %s ,assets_url = %s" srvc_desc = ipfs_data.get('service_description', {}) desc = srvc_desc.get('description', '') url = srvc_desc.get('url', '') json_str = ipfs_data.get('json', '') assets_hash = json.dumps(ipfs_data.get('assets', {})) assets_url_str = json.dumps(assets_url) upsrt_srvc_mdata_params = [srvc_rw_id, org_id, service_id, ipfs_data['display_name'], ipfs_data['model_ipfs_hash'], desc, url, json_str, ipfs_data['encoding'], ipfs_data['service_type'], ipfs_data['mpe_address'], assets_hash, assets_url_str, '{"rating": 0.0 , "total_users_rated": 0 }', dt.utcnow( ), dt.utcnow(), srvc_rw_id, ipfs_data['display_name'], ipfs_data['model_ipfs_hash'], desc, url, json_str, ipfs_data['encoding'], ipfs_data['service_type'], ipfs_data['mpe_address'], dt.utcnow(), assets_hash, assets_url_str] qry_res = conn.execute(upsrt_srvc_mdata, upsrt_srvc_mdata_params) print('_create_or_updt_srvc_mdata::row upserted', qry_res) def _create_grp(self, srvc_rw_id, org_id, service_id, grp_data, conn): insrt_grp = "INSERT INTO service_group (service_row_id, org_id, service_id, group_id, group_name," \ "pricing, row_updated, row_created)" \ "VALUES(%s, %s, %s, %s, %s, %s, %s, %s)" insrt_grp_params = [srvc_rw_id, org_id, service_id, grp_data['group_id'], grp_data['group_name'], grp_data['pricing'], dt.utcnow(), dt.utcnow()] return conn.execute(insrt_grp, insrt_grp_params) def _create_edpts(self, srvc_rw_id, org_id, service_id, endpt_data, conn): insrt_endpt = "INSERT INTO service_endpoint (service_row_id, org_id, service_id, group_id, endpoint, " \ "row_created, row_updated) " \ "VALUES(%s, %s, %s, %s, %s, %s, %s)" insrt_endpt_params = [srvc_rw_id, org_id, service_id, endpt_data['group_id'], endpt_data['endpoint'], dt.utcnow(), dt.utcnow()] return conn.execute(insrt_endpt, insrt_endpt_params) def _create_tags(self, srvc_rw_id, org_id, service_id, tag_name, conn): insrt_tag = "INSERT INTO service_tags (service_row_id, org_id, service_id, tag_name, row_created, row_updated) " \ "VALUES(%s, %s, %s, %s, %s, %s) " \ "ON DUPLICATE KEY UPDATE tag_name = %s, row_updated = %s " insrt_tag_params = [srvc_rw_id, org_id, service_id, tag_name, dt.utcnow(), dt.utcnow(), tag_name, dt.utcnow()] qry_res = conn.execute(insrt_tag, insrt_tag_params) print('_create_tags::qry_res: ', qry_res) def _updt_raw_evts(self, row_id, type, err_cd, err_msg, conn): try: if type == 'REG': updt_evts = 'UPDATE registry_events_raw SET processed = 1, error_code = %s, error_msg = %s WHERE row_id = %s ' elif type == 'MPE': updt_evts = 'UPDATE mpe_events_raw SET processed = 1, error_code = %s, error_msg = %s WHERE row_id = %s ' updt_evts_resp = self.repo.execute( updt_evts, [err_cd, err_msg, row_id]) print('updt_raw_evts::row updated: ', updt_evts_resp, '|', type) except Exception as e: self.util_obj.report_slack( type=1, slack_msg=repr(e), SLACK_HOOK=SLACK_HOOK) print('Error in updt_reg_evts_raw::error: ', e) def updt_raw_evts(self, row_id, type, err_cd, err_msg): conn = self.repo self._updt_raw_evts(row_id, type, err_cd, err_msg, conn) def del_org(self, org_id): self.repo.auto_commit = False conn = self.repo try: self._del_org(org_id=org_id, conn=conn) self._del_org_groups(org_id=org_id, conn=conn) srvcs = self._get_srvcs(org_id=org_id) for rec in srvcs: self._del_srvc( org_id=org_id, service_id=rec['service_id'], conn=conn) self._commit(conn=conn) except Exception as e: self.util_obj.report_slack( type=1, slack_msg=repr(e), SLACK_HOOK=SLACK_HOOK) self._rollback(conn=conn, err=repr(e)) def del_srvc(self, org_id, service_id): self._del_srvc(org_id=org_id, service_id=service_id, conn=self.repo) def create_channel(self, q_dta): if q_dta['groupId'][0:2] == '0x': q_dta['groupId'] = q_dta['groupId'][2:] q_dta['groupId'] = base64.b64encode( bytes.fromhex(q_dta['groupId'])).decode('utf8') self._create_channel(q_dta, self.repo) def update_channel(self, channel_id, group_id, channel_data): print('update_channel::channel_id: ', channel_id) self._create_channel(q_dta={ 'sender': channel_data[1], 'recipient': channel_data[3], 'nonce': int(channel_data[0]), 'expiration': channel_data[6], 'signer': channel_data[2], 'groupId': group_id, 'channelId': channel_id, 'amount': channel_data[5] }, conn=self.repo) def _push_asset_to_s3_using_hash(self, hash, org_id, service_id): io_bytes = self.ipfs_utll.read_bytesio_from_ipfs(hash) filename = hash.split("/")[1] new_url = self.s3_util.push_io_bytes_to_s3(ASSETS_PREFIX + "/" + org_id + "/" + service_id + "/" + filename, ASSETS_BUCKET_NAME, io_bytes) return new_url def _comapre_assets_and_push_to_s3(self, existing_assets_hash, new_assets_hash, existing_assets_url, org_id, service_id): """ :param existing_assets_hash: contains asset_type and its has value stored in ipfs :param new_assets_hash: contains asset type and its updated hash value in ipfs :param existing_assets_url: contains asset type and s3_url value for given asset_type :param org_id: :param service_id: :return: dict of asset_type and new_s3_url """ # this function compare assets and deletes and update the new assets assets_url_mapping = {} if not existing_assets_hash: existing_assets_hash = {} if not existing_assets_url: existing_assets_url = {} if not new_assets_hash: new_assets_hash = {} for new_asset_type, new_asset_hash in new_assets_hash.items(): if isinstance(new_asset_hash, list): # if this asset_type contains list of assets than remove all existing assetes from s3 and add all new assets to s3 # new_urls_list = [] # remove all existing assets if exits if new_asset_type in existing_assets_url: for url in existing_assets_url[new_asset_type]: self.s3_util.delete_file_from_s3(url) # add new files to s3 and update the url for hash in new_assets_hash[new_asset_type]: new_urls_list.append( self._push_asset_to_s3_using_hash(hash, org_id, service_id)) assets_url_mapping[new_asset_type] = new_urls_list elif isinstance(new_asset_hash, str): # if this asset_type has single value if new_asset_type in existing_assets_hash and existing_assets_hash[new_asset_type] == new_asset_hash: # file is not updated , add existing url assets_url_mapping[new_asset_type] = existing_assets_url[new_asset_type] else: if new_asset_type in existing_assets_url: url_of_file_to_be_removed = existing_assets_url[new_asset_type] self.s3_util.delete_file_from_s3( url_of_file_to_be_removed) hash_of_file_to_be_pushed_to_s3 = new_assets_hash[new_asset_type] assets_url_mapping[new_asset_type] = self._push_asset_to_s3_using_hash( hash_of_file_to_be_pushed_to_s3, org_id, service_id) else: logger.info( "unknown type assets for org_id %s service_id %s", org_id, service_id) return assets_url_mapping def _get_new_assets_url(self, org_id, service_id, new_ipfs_data): new_assets_hash = new_ipfs_data.get('assets', {}) existing_assets_hash = {} existing_assets_url = {} service_metadata_repo = ServiceMetadataRepository() existing_service_metadata = service_metadata_repo.get_service_metatdata_by_servcie_id_and_org_id( service_id, org_id) if existing_service_metadata: existing_assets_hash = existing_service_metadata.assets_hash existing_assets_url = existing_service_metadata.assets_url assets_url_mapping = self._comapre_assets_and_push_to_s3(existing_assets_hash, new_assets_hash, existing_assets_url, org_id, service_id) return assets_url_mapping def process_srvc_data(self, org_id, service_id, ipfs_hash, ipfs_data, tags_data): self.repo.auto_commit = False conn = self.repo try: assets_url = self._get_new_assets_url( org_id, service_id, ipfs_data) self._del_srvc_dpndts( org_id=org_id, service_id=service_id, conn=conn) qry_data = self._create_or_updt_srvc( org_id=org_id, service_id=service_id, ipfs_hash=ipfs_hash, conn=conn) service_row_id = qry_data['last_row_id'] print('service_row_id == ', service_row_id) self._create_or_updt_srvc_mdata(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, ipfs_data=ipfs_data, assets_url=assets_url, conn=conn) grps = ipfs_data.get('groups', []) group_insert_count = 0 for grp in grps: qry_data = self._create_grp(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, conn=conn, grp_data={ 'group_id': grp['group_id'], 'group_name': grp['group_name'], 'pricing': json.dumps(grp['pricing']) }) group_insert_count = group_insert_count + qry_data[0] endpts = grp.get('endpoints', []) endpt_insert_count = 0 for endpt in endpts: qry_data = self._create_edpts(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, conn=conn, endpt_data={ 'endpoint': endpt, 'group_id': grp['group_id'], }) endpt_insert_count = endpt_insert_count + qry_data[0] print('rows insert in endpt: ', endpt_insert_count) print('rows insert in grp: ', group_insert_count) if (tags_data is not None and tags_data[0]): tags = tags_data[3] for tag in tags: tag = tag.decode('utf-8') tag = tag.rstrip("\u0000") self._create_tags(srvc_rw_id=service_row_id, org_id=org_id, service_id=service_id, tag_name=tag, conn=conn) self._commit(conn=conn) except Exception as e: self.util_obj.report_slack( type=1, slack_msg=repr(e), SLACK_HOOK=SLACK_HOOK) self._rollback(conn=conn, err=repr(e)) def process_org_data(self, org_id, org_data, ipfs_data, org_metadata_uri): self.repo.auto_commit = False conn = self.repo try: if (org_data is not None and org_data[0]): self._create_or_updt_org( org_id=org_id, org_name=ipfs_data["org_name"], owner_address=org_data[3], org_metadata_uri=org_metadata_uri, conn=conn) self._del_org_groups(org_id=org_id, conn=conn) self._create_org_groups( org_id=org_id, groups=ipfs_data["groups"], conn=conn) self._del_members(org_id=org_id, conn=conn) self._create_or_updt_members(org_id, org_data[4], conn) self._commit(conn) except Exception as e: self.util_obj.report_slack( type=1, slack_msg=repr(e), SLACK_HOOK=SLACK_HOOK) self._rollback(conn=conn, err=repr(e)) def update_tags(self, org_id, service_id, tags_data): self.repo.auto_commit = False conn = self.repo try: self._del_tags(org_id=org_id, service_id=service_id, conn=conn) if (tags_data is not None and tags_data[0]): tags = tags_data[3] srvc_data = self._get_srvc_row_id( service_id=service_id, org_id=org_id) srvc_rw_id = srvc_data[0]['row_id'] for tag in tags: tag = tag.decode('utf-8') tag = tag.rstrip("\u0000") self._create_tags(srvc_rw_id=srvc_rw_id, org_id=org_id, service_id=service_id, tag_name=tag, conn=conn) self._commit(conn) except Exception as e: self.util_obj.report_slack( type=1, slack_msg=repr(e), SLACK_HOOK=SLACK_HOOK) self._rollback(conn=conn, err=repr(e)) # def _commit(self, conn): conn.auto_commit = True conn.connection.commit() print('_commit') print(conn.connection) def _rollback(self, conn, err): print('_rollback ::error: ', err) conn.auto_commit = True conn.connection.rollback()
class TestUserPreference(TestCase): def setUp(self): self.repo = Repository(net_id=NETWORK_ID, NETWORKS=NETWORKS) username = "******" account_id = "123" name = "dummy_user_2" status = 1 request_id = "id_123" user_one_row_id = 101 current_time = datetime.utcnow() epoch_time = current_time.timestamp() self.repo.execute( "INSERT INTO user (row_id, username, account_id, name, email, email_verified, status, request_id, " "request_time_epoch, row_created, row_updated) VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", [ user_one_row_id, username, account_id, name, username, 1, status, request_id, epoch_time, current_time, current_time ]) username = "******" account_id = "123" name = "dummy_user_2" status = 1 user_two_row_id = 202 request_id = "id_123" self.repo.execute( "INSERT INTO user (row_id, username, account_id, name, email, email_verified, status, request_id, " "request_time_epoch, row_created, row_updated) VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", [ user_two_row_id, username, account_id, name, username, 1, status, request_id, epoch_time, current_time, current_time ]) row_id = 1111 user_row_id = user_two_row_id preference_type = "FEATURE_RELEASE" communication_type = "SMS" source = "PUBLISHER_DAPP" opt_out_reason = None status = 0 self.repo.execute( "INSERT INTO user_preference(row_id, user_row_id, preference_type, communication_type, source, " "opt_out_reason, status, created_on, updated_on) VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s)", [ row_id, user_row_id, preference_type, communication_type, source, opt_out_reason, status, current_time, current_time ]) def test_add_or_update_user_preference(self): event = { "requestContext": { "authorizer": { "claims": { "email": "*****@*****.**" } } }, "body": json.dumps([{ "preference_type": "FEATURE_RELEASE", "communication_type": "EMAIL", "source": "PUBLISHER_DAPP", "status": True }, { "preference_type": "WEEKLY_SUMMARY", "communication_type": "EMAIL", "source": "PUBLISHER_DAPP", "status": True }]) } response = add_or_update_user_preference(event=event, context=None) assert (response["statusCode"] == 200) response_body = json.loads(response["body"]) assert (response_body["status"] == "success") assert (response_body["data"] == [ Status.ENABLED.value, Status.ENABLED.value ]) event = { "requestContext": { "authorizer": { "claims": { "email": "*****@*****.**" } } }, "body": json.dumps([{ "preference_type": "FEATURE_RELEASE", "communication_type": "EMAIL", "source": "PUBLISHER_DAPP", "status": False, "opt_out_reason": "Mail too frequent!" }]) } response = add_or_update_user_preference(event=event, context=None) assert (response["statusCode"] == 200) response_body = json.loads(response["body"]) assert (response_body["status"] == "success") assert (response_body["data"] == [Status.DISABLED.value]) event = { "requestContext": { "authorizer": { "claims": { "email": "*****@*****.**" } } }, "body": json.dumps([{ "preference_type": "FEATURE_RELEASE", "communication_type": "EMAIL", "source": "PUBLISHER_DAPP", "status": True }, { "preference_type": "WEEKLY_SUMMARY", "communication_type": "EMAIL", "source": "PUBLISHER_DAPP", "status": False, "opt_out_reason": "Mail too frequent!" }]) } response = add_or_update_user_preference(event=event, context=None) assert (response["statusCode"] == 200) response_body = json.loads(response["body"]) assert (response_body["status"] == "success") assert (response_body["data"] == [ Status.ENABLED.value, Status.DISABLED.value ]) def test_get_user_preference(self): event = { "requestContext": { "authorizer": { "claims": { "email": "*****@*****.**" } } } } response = get_user_preference(event=event, context=None) print(response) assert (response["statusCode"] == 200) response_body = json.loads(response["body"]) assert (response_body["status"] == "success") assert ( response_body["data"][0]["preference_type"] == "FEATURE_RELEASE") assert (response_body["data"][0]["communication_type"] == "SMS") assert (response_body["data"][0]["source"] == "PUBLISHER_DAPP") assert (response_body["data"][0]["status"] == 0) def tearDown(self): self.repo.execute("DELETE FROM user_preference") self.repo.execute("DELETE FROM user")