def test_exchange_post(self, with_login):
exchange_api = ExchangeManagementApi()
user = self.data['user']
email, password = user['email'], user['password']
token = with_login('tenant', [exchange_api], email, password)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
exchange_api.exchange_post(exchange)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'pending'
# 初审
audit_api = AuditApi()
uid = self.data['account_id']
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
rv = audit_api.tenant_audits_get(uid=uid,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id, is_data_received=True,
status='approved',
failure_type='ENTERPRISE_LICENSE')
audit_api.tenant_audits_audit_post(res)
# 复审
res = PostTenantReAuditRequest(id=task_id,
status='disapproved',
failure_type=1)
audit_api.tenant_audits_re_audit_post(res)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'disapproved'
def test_exchange_post(self, with_login):
user = self.data['user']
exchange_api = ExchangeManagementApi()
email, password = user['email'], user['password']
token = with_login('tenant', [exchange_api], email, password)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
exchange_api.exchange_post(exchange)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'pending'
audit_api = AuditApi()
uid = self.data['account_id']
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
rv = audit_api.tenant_audits_get(uid=uid,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id, is_data_received=True,
status='approved',
failure_type='ENTERPRISE_LICENSE')
audit_api.tenant_audits_audit_post(res)
# 复审
res = PostTenantReAuditRequest(id=task_id,
status='approved',
failure_type='ENTERPRISE_LICENSE')
audit_api.tenant_audits_re_audit_post(res)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'approved'
rv = exchange_api.exchange_exchange_id_get()
exchange_id = rv.id
TestExchange10.data['exchange_id'] = exchange_id
TestExchange10.data['exchange'] = exchange
# 用另外一个账号再创建一个交易所
manager = PlatformManager('tenant')
account_api = AccountApi()
api = manager.account_api
verify_api = manager.verify_api
user = register_with_login('tenant', with_login,
[api, verify_api, account_api])
token1 = user['token']
id_number = get_random_id_number()
individual_verify('tenant', id_number, token1)
exchange1 = e.get_exchange()
exchange_api.exchange_get()
name_used = exchange1.name
# 用已有的交易所名称更新前一个交易所
r = GetExchangeRequest(name=name_used)
try:
exchange_api.exchange_put(r)
except ApiException as e:
assert e.status == 400
else:
assert False, '交易所名称已经注册'
def test_investors(self, with_login):
"""3.未开通交易所——获取投资人列表列表———投资人详情（exchange id is None）"""
manager = PlatformManager('tenant')
account_api = AccountApi()
api = manager.account_api
verify_api = manager.verify_api
user = register_with_login('tenant', with_login,
[api, verify_api, account_api])
# 绑定电话
email = user.get('email')
faker = Faker('zh_CN')
phone = faker.phone_number()
verify = verify_info(manager, email, "bind_phone")
manager.bind_phone(phone, DEFAULT_VERIFY_CODE,
area_code="+86", token=verify.token)
account_info = account_api.accounts_account_info_get()
account_id = account_info.account_info.account_id
exchange_api = ExchangeManagementApi()
email, password = user['email'], user['password']
token = with_login('tenant', [exchange_api], email, password)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
exchange_api.exchange_post(exchange)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'pending'
audit_api = AuditApi()
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
rv = audit_api.tenant_audits_get(uid=account_id,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id, is_data_received=True,
status='approved')
audit_api.tenant_audits_audit_post(res)
# 复审不通过
res = PostTenantReAuditRequest(id=task_id,
status='disapproved',
failure_type='ENTERPRISE_LICENSE')
audit_api.tenant_audits_re_audit_post(res)
api = AccountManagementApi()
admin_token = get_admin_token()
set_login_status(api, admin_token)
a_api = AccountApi()
token = with_login('tenant', [a_api], email, password)
account_info = a_api.accounts_account_info_get()
account_id = account_info.account_info.account_id
rv = api.accounts_investors_get(account_id=account_id)
investors = rv.items
assert len(investors) > 0
rv = api.accounts_accounts_id_get(id=account_id)
assert rv.basic_info.exchange_id is None
def test_coin_market(self, with_login):
manager = PlatformManager('tenant')
m_api = MarketManagementApi()
e_api = ExchangeManagementApi()
api = manager.account_api
verify_api = manager.verify_api
account_api = AccountApi()
user = register_with_login(
'tenant', with_login, [api, verify_api, m_api, e_api, account_api])
self.data['user'] = user
token = user['token']
email = user.get('email')
# 绑定电话
faker = Faker('zh_CN')
phone = faker.phone_number()
verify = verify_info(manager, email, "bind_phone")
manager.bind_phone(phone,
DEFAULT_VERIFY_CODE,
area_code="+86",
token=verify.token)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
exchange_api = ExchangeManagementApi()
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
e_api.exchange_post(exchange)
# 获取交易对市场列表
try:
m_api.markets_get()
except ApiException as e:
# 交易所不存在
assert e.status == 400
else:
assert False, '市场应当不存在'
# 初审复审
rv = account_api.accounts_account_info_get()
account_id = rv.account_info.account_id
self.data['account_id'] = account_id
audit_api = AuditApi()
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
rv = audit_api.tenant_audits_get(uid=account_id,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id,
is_data_received=True,
status='approved')
audit_api.tenant_audits_audit_post(res)
# 复审
res = PostTenantReAuditRequest(id=task_id, status='approved')
audit_api.tenant_audits_re_audit_post(res)
rv = e_api.exchange_exchange_id_get()
exchange_id = rv.id
self.data['exchange_id'] = exchange_id
def test_exchange_post(self, with_login):
exchange_api = ExchangeManagementApi()
user = self.data['user']
email, password = user['email'], user['password']
token = with_login('tenant', [exchange_api], email, password)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
exchange_api.exchange_post(exchange)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'pending'
# 初审
audit_api = AuditApi()
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
uid = self.data['account_id']
rv = audit_api.tenant_audits_get(uid=uid,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id, is_data_received=True,
status='approved',
failure_type='ENTERPRISE_LICENSE')
audit_api.tenant_audits_audit_post(res)
# 复审
res = PostTenantReAuditRequest(id=task_id,
status='approved',
failure_type='ENTERPRISE_LICENSE')
audit_api.tenant_audits_re_audit_post(res)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'approved'
rv = exchange_api.exchange_get()
assert rv.name == exchange.name
assert rv.logo_key == exchange.logo
assert rv.email == exchange.email
assert rv.nationality == exchange.nationality
exchange.logo = img1
exchange_api.exchange_put(exchange)
rv = exchange_api.exchange_get()
assert rv.name == exchange.name
assert rv.logo_key == exchange.logo
assert rv.email == exchange.email
assert rv.nationality == exchange.nationality
"""合并测试用例"""
"""12.交易所审核通过——获取交易所ID——获取交易所买卖方币种列表"""
coin = exchange_api.exchange_exchange_coin_get()
assert coin.seller_coin == []
def test_exchange_post(self, with_login):
audit_api = AuditApi()
user = self.data['user']
email = user['email']
password = user['password']
exchange_api = ExchangeManagementApi()
token = with_login('tenant', [exchange_api], email, password)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
exchange_api.exchange_post(exchange)
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
# 初审
uid = self.data['account_id']
rv = audit_api.tenant_audits_get(uid=uid,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id, is_data_received=True,
status='approved', failure_type=1)
audit_api.tenant_audits_audit_post(res)
# 复审
res = PostTenantReAuditRequest(id=task_id,
status='approved',
failure_type=None)
audit_api.tenant_audits_re_audit_post(res)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'approved'
try:
user1 = self.data['user1']
email1, password1 = user1['email'], user1['password']
exchange_api1 = ExchangeManagementApi()
token1 = with_login('tenant', [exchange_api1], email1, password1)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token1)
# print(token1)
exchange1 = e.get_exchange()
exchange1.name = exchange.name
# pprint(exchange1)
exchange_api1.exchange_post(exchange1)
except ApiException as e:
assert e.status == 400
else:
assert False, '交易所名称重复不应当创建'
assert exchange_name_verify(token, exchange.name), '交易所名称应当已经存在'
def test_exchange_post(self, with_login):
audit_api = AuditApi()
user = self.data['user']
email = user['email']
password = user['password']
exchange_api = ExchangeManagementApi()
e_api = ExchangeApi()
f_api = FavoriteManagementApi()
token = with_login('tenant',
[exchange_api, e_api, f_api],
email, password)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
exchange_api.exchange_post(exchange)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'pending'
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
# 初审
uid = self.data['account_id']
rv = audit_api.tenant_audits_get(uid=uid,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id, is_data_received=True,
status='approved')
audit_api.tenant_audits_audit_post(res)
# 初审详情
rv = audit_api.tenant_audits_results_id_company_audit_get(task_id)
assert rv.audit_status == 'approved'
assert rv.uid == uid
# 复审
res = PostTenantReAuditRequest(id=task_id,
status='disapproved')
audit_api.tenant_audits_re_audit_post(res)
# 复审详情
rv = audit_api.tenant_audits_results_id_company_re_audit_get(task_id)
assert rv.audit_status == 'approved'
assert rv.uid == uid
assert rv.re_status == 'disapproved'
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'disapproved'
def test_market_exchange(self, with_login):
"""添加测试用例，两个交易所对接同一个市场，手动在数据库中修改两者为深度共享"""
manager = PlatformManager('tenant')
m_api = MarketManagementApi()
e_api = ExchangeManagementApi()
api = manager.account_api
verify_api = manager.verify_api
account_api = AccountApi()
v_api = VerificationApi()
pm = ProjectManagementApi()
vc = VentureContactsApi()
user = register_with_login(
'tenant', with_login,
[vc, pm, api, v_api, verify_api, m_api, e_api, account_api])
self.data['user1'] = user
token0 = user['token']
email = user.get('email')
# 绑定电话
faker = Faker('zh_CN')
phone = faker.phone_number()
verify = verify_info(manager, email, "bind_phone")
manager.bind_phone(phone,
DEFAULT_VERIFY_CODE,
area_code="+86",
token=verify.token)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token0)
exchange_api = ExchangeManagementApi()
e = Exchange(exchange_api, token0)
exchange = e.get_exchange()
e_api.exchange_post(exchange)
rv = account_api.accounts_account_info_get()
account_id = rv.account_info.account_id
audit_api = AuditApi()
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
rv = audit_api.tenant_audits_get(uid=account_id,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id,
is_data_received=True,
status='approved',
failure_type=1)
audit_api.tenant_audits_audit_post(res)
# 复审
res = PostTenantReAuditRequest(id=task_id,
status='approved',
failure_type=None)
audit_api.tenant_audits_re_audit_post(res)
rv = e_api.exchange_exchange_id_get()
exchange_id = rv.id
# 对接币种
contacts_api = ContactsApi()
user = self.data['user']
email, password = user['email'], user['password']
token = with_login('tenant', [contacts_api], email, password)
project_id = self.data['project_id']
req = {
'exchangeId': exchange_id,
'projectId': project_id,
'sponsor': 'tenant'
}
rv = contacts_api.contacts_post(req)
# 处理对接邀请
rv = pm.projects_id_contacts_get(project_id, 'tenant')
# 处理对接邀请
contact_id = rv.items[0].contact_id
vc.contacts_put({'contactId': contact_id, 'status': 'accepted'})
#
# rv = contacts_api.contacts_projects_exchange_id_get(exchange_id,
# 'pending')
# contact_id = rv.items[0].id
# contacts_api.contacts_put({'contactId': contact_id,
# 'status': 'accepted'})
rv = contacts_api.contacts_check_get(project_id=project_id,
exchange_id=exchange_id)
assert rv.result
rv = e_api.exchange_exchange_coin_get()
res = PostOrderMarketRequest()
s_coin = self.data['s_coin']
b_coin = self.data['b_coin']
res.seller_coin_id = s_coin.id
res.buyer_coin_id = b_coin.id
res.allotted_time = AllottedTime._6month
res.fee_rate = TestMarket1.fee_rate
rv = e_api.exchange_exchange_coin_get()
# 配置交易对市场
rv = e_api.exchange_order_market_post(res)
order_id = rv.order_id
usdt_id = b_coin.id
# 充钱
free_charge(token0, usdt_id, account_id)
data = {
"challenge": "048ebbe51f829995db76ac4b81546403",
"seccode": "048ebbe51f829995db76ac4b81546403",
"validate": "true",
"account": "mailto:[email protected]",
"code": "666666",
"secondCode": "Ls1w1w",
"type": "pay"
}
rv = v_api.accounts_verify_post(data)
p = PutOrderMarketRequest(order_id=order_id, token=rv.token)
e_api.exchange_order_market_put(p)
# 获取交易对市场
rv = m_api.markets_get()
items = rv.items
assert len(items) == 1
def test_exchange_project(self):
"""2.新增项目——对接交易所——获取交易所卖买方币种列表
——单一币种在单一交易所币对的行情统计"""
exchange = new_exchange()
exchange_api = ExchangeManagementApi()
user_data = TestProject.data['user']
token = user_data['token']
exchange_api.api_client.set_default_header("Authentication-Token",
token)
account_api = AccountApi()
account_api.api_client.set_default_header("Authentication-Token",
token)
account_info = account_api.accounts_account_info_get()
account_id = account_info.accountInfo.accountId
TestProject.data['account_id'] = account_id
exchange_api.exchange_post(exchange)
manager = PlatformManager('tenant')
token = manager.login(sponsor_account, sponsor_pwd)
audit_api = AuditApi()
audit_api.api_client.set_default_header("Authentication-Token", token)
# 初审
rv = audit_api.tenant_audits_get()
audit_list = rv.items
_id = None
for each in audit_list:
if each.uid == account_id:
_id = each.id # 工单id
assert not _id
res = PostTenantAuditRequest(id=_id,
is_data_received=True,
status='approved',
failure_type=1)
audit_api.tenant_audits_audit_post(res)
# 复审
PostTenantReAuditRequest(id=_id, status='approved', failure_type=None)
exchange_id = exchange_api.exchange_exchange_id_get()
# 对接项目方
contacts_api = ContactsApi()
contacts_api.api_client.set_default_header("Authentication-Token",
token)
req = {
'exchangeId': exchange_id,
'projectId': TestProject.data['project_id'],
'sponsor': 'tenant'
}
contacts_api.contacts_post(req)
# 获取交易所买卖方币种
m_api = MarketManagementApi()
m_api.api_client.set_default_header("Authentication-Token", token)
trading_coins = m_api.markets_trading_coins_get()
seller_coin = trading_coins.seller_coin
s_coin = seller_coin[0]
buyer_coin = trading_coins.buyer_coin
b_coin = buyer_coin[0]
assert s_coin == TestProject.data['project']['short_name']
# 新建市场
res = PostOrderMarketRequest()
res.seller_coin_id = s_coin.id
res.buyer_coin_id = b_coin.id
TestProject.data['s_coin'] = s_coin
TestProject.data['b_coin'] = b_coin
res.allotted_time = AllottedTime._6month
res.fee_rate = TestProject.fee_rate
# 配置交易对市场
rv = exchange_api.exchange_order_market_post(res)
order_id = rv.order_id
token = get_verify_token()
p = PutOrderMarketRequest(order_id=order_id, token=token)
exchange_api.exchange_order_market_put(p)
# 单一币种在单一交易所币对的行情统计
dashboard_api = DashboardApi()
dashboard_api.api_client.set_default_header("Authentication-Token",
token)
dashboard_api.dashboard_quotation_historical_data_post()
dashboard_api.dashboard_quotations_summary_get(page_no=1,
page_size=10,
seller_coin=seller_coin)
# 3.新增项目——对接交易所——获取交易所卖买方币种列表——单一币种在各交易所的行情概要
dashboard_api.dashboard_daily_statistics_get()
def test_exchange_post(self, with_login):
audit_api = AuditApi()
user = self.data['user']
email = user['email']
password = user['password']
exchange_api = ExchangeManagementApi()
e_api = ExchangeApi()
ma_api = MainAccountApi()
f_api = FavoriteManagementApi()
token = with_login('tenant',
[exchange_api, e_api, f_api, ma_api],
email, password)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
exchange_api.exchange_post(exchange)
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'pending'
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
# 初审
uid = self.data['account_id']
rv = audit_api.tenant_audits_get(uid=uid,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id, is_data_received=True,
status='approved')
audit_api.tenant_audits_audit_post(res)
# 初审详情
rv = audit_api.tenant_audits_results_id_company_audit_get(task_id)
assert rv.audit_status == 'approved'
assert rv.uid == uid
# 复审
res = PostTenantReAuditRequest(id=task_id,
status='approved')
audit_api.tenant_audits_re_audit_post(res)
# 复审详情
rv = audit_api.tenant_audits_results_id_company_re_audit_get(task_id)
assert rv.audit_status == 'approved'
assert rv.uid == uid
assert rv.re_status == 'approved'
rv = exchange_api.exchange_exchange_status_get()
assert rv.status == 'approved'
# 合并测试用例
"""2.新增交易所——交易所列表模糊查询——收藏——收藏列表（交易所）"""
# res = PostPlatFormRegisterRequest()
# ma_api.create_platform(body=res)
rv = e_api.exchanges_suggestion_get(name=exchange.name)
assert len(rv) >= 1
exchange_id = rv[0]['id']
# 收藏
req = PostFavoriterRequest()
req.favorite_id = exchange_id
req.type = 'exchange'
f_api.favorites_post(req)
# 收藏列表
rv = f_api.favorites_get(type='exchange')
items = rv.items
assert len(items) == 1
item = items[0]
assert item.favorite_id == exchange_id
favorite_record_id = item.id
"""6.收藏交易所成功——收藏列表（交易所）——取消收藏"""
# 取消收藏
f_api.favorites_delete(favorite_record_id)
rv = f_api.favorites_is_favorite_get(favorite_id=exchange_id,
type='exchange')
assert not rv.status
def test_coin_market(self, with_login):
manager = PlatformManager('tenant')
m_api = MarketManagementApi()
e_api = ExchangeManagementApi()
api = manager.account_api
verify_api = manager.verify_api
account_api = AccountApi()
contacts_api = ContactsApi()
vc = VentureContactsApi()
venture_pm = ProjectManagementApi()
tenant_ca = TenantContactsApi()
user = register_with_login('tenant', with_login, [
api, verify_api, m_api, e_api, account_api, contacts_api, vc,
venture_pm, tenant_ca
])
self.data['user2'] = user
token = user['token']
email = user.get('email')
# 绑定电话
faker = Faker('zh_CN')
phone = faker.phone_number()
verify = verify_info(manager, email, "bind_phone")
manager.bind_phone(phone,
DEFAULT_VERIFY_CODE,
area_code="+86",
token=verify.token)
id_number = get_random_id_number()
individual_verify('tenant', id_number, token)
exchange_api = ExchangeManagementApi()
e = Exchange(exchange_api, token)
exchange = e.get_exchange()
e_api.exchange_post(exchange)
# 获取交易对市场列表
try:
m_api.markets_get()
except ApiException as e:
# 交易所不存在
assert e.status == 400
else:
assert False, '市场应当不存在'
# 初审复审
rv = account_api.accounts_account_info_get()
account_id = rv.account_info.account_id
self.data['account_id'] = account_id
audit_api = AuditApi()
admin_token = get_admin_token()
set_login_status(audit_api, admin_token)
rv = audit_api.tenant_audits_get(uid=account_id,
exchange_name=exchange.name,
type='audit')
task = rv.items[0]
task_id = task.id
res = PostTenantAuditRequest(id=task_id,
is_data_received=True,
status='approved')
audit_api.tenant_audits_audit_post(res)
# 复审
res = PostTenantReAuditRequest(id=task_id, status='approved')
audit_api.tenant_audits_re_audit_post(res)
rv = e_api.exchange_exchange_id_get()
exchange_id = rv.id
self.data['exchange_id'] = exchange_id
rv = e_api.exchange_exchange_coin_get()
seller_coin = rv.seller_coin
buyer_coin = rv.buyer_coin
b_coin = buyer_coin[0]
if seller_coin:
s_coin = seller_coin[0]
else:
# 对接币种
# 租户主动发起对接
project_id1 = self.data['project_id1']
project_id2 = self.data['project_id2']
req = {
'exchangeId': exchange_id,
'projectId': project_id1,
'sponsor': 'tenant'
}
contacts_api.contacts_post(req)
# 项目方主动发起对接
req = {
'exchangeId': exchange_id,
'projectId': project_id2,
'sponsor': 'venture'
}
vc.contacts_post(req)
rv1 = venture_pm.projects_id_contacts_get(project_id1, 'tenant')
rv2 = tenant_ca.contacts_projects_exchange_id_get(
exchange_id, 'pending')
# 处理对接邀请
contact_id1 = rv1.items[0].contact_id
contact_id2 = rv2.items[0].id
vc.contacts_put({'contactId': contact_id1, 'status': 'accepted'})
rv = contacts_api.contacts_check_get(project_id=project_id1,
exchange_id=exchange_id)
# pprint(rv)
contacts_api.contacts_put({
'contactId': contact_id2,
'status': 'accepted'
})
rv = vc.contacts_check_get(project_id2, exchange_id)
rv = contacts_api.contacts_check_get(project_id1, exchange_id)
assert rv.result
rv = contacts_api.contacts_project_id_status_get(project_id1)
assert rv.status == 'accepted'
rv = contacts_api.contacts_project_id_status_get(project_id2)
assert rv.status == 'accepted'