def test_addowner_slackr():
"""
Tests if channel_addowner works if Slackr owner who is not a channel owner tries to use it
"""
user1 = auth.auth_register("*****@*****.**", "password", "Severus",
"Snape")
user2 = auth.auth_register("*****@*****.**", "password", "Albus",
"Dumbledore")
user3 = auth.auth_register("*****@*****.**", "Potions", "Harry",
"Potter")
c_id_dict = channels.channels_create(user2["token"], "test_channel", True)
channel.channel_join(user1["token"], c_id_dict["channel_id"])
channel.channel_join(user3["token"], c_id_dict["channel_id"])
details_before = channel.channel_details(user2["token"],
c_id_dict["channel_id"])
assert details_before["owner_members"][0]["u_id"] == user2["u_id"]
assert details_before["owner_members"][1]["u_id"] == user1["u_id"]
assert len(details_before["owner_members"]) == 2
assert len(details_before["all_members"]) == 3
assert details_before["all_members"][2]["u_id"] == user3["u_id"]
channel.channel_addowner(user1["token"], c_id_dict["channel_id"],
user3["u_id"])
details_after = channel.channel_details(user2["token"],
c_id_dict["channel_id"])
assert len(details_after["owner_members"]) == 3
assert details_after["owner_members"][0]["u_id"] == user2["u_id"]
assert details_after["owner_members"][1]["u_id"] == user1["u_id"]
assert details_after["owner_members"][2]["u_id"] == user3["u_id"]
def test_join_admin():
"""
Tests if channel_join allows an admin to join a private channel
"""
# establish a test register
# since test_dict is first member he is owner of slackr/admin (per assumptions)
test_dict = auth.auth_register("*****@*****.**", "password", "Bob", "Ross")
# create a second user
test_dict_2 = auth.auth_register("*****@*****.**", "password2", "James",
"May")
# second user creates a private channel (which bob ross is not a part of)
c_id_dict = channels.channels_create(test_dict_2["token"], "test admin",
False)
# store details before using channel_join
details_before = channel.channel_details(test_dict_2["token"],
c_id_dict["channel_id"])
# check that only test_dict_2 is owner in channel
assert len(details_before["owner_members"]) == 1
assert details_before["owner_members"][0]["u_id"] == test_dict_2["u_id"]
# we then test that test_dict(admin) can join the private channel
channel.channel_join(test_dict["token"], c_id_dict["channel_id"])
details_after = channel.channel_details(test_dict_2["token"],
c_id_dict["channel_id"])
# we check that there are now two owners in the channel
assert len(details_after["owner_members"]) == 2
assert details_after["owner_members"][0]["u_id"] == test_dict_2["u_id"]
assert details_after["owner_members"][1]["u_id"] == test_dict["u_id"]
def test_addowner_channel():
"""
Tests if channel_addowner works if user is a channel owner but not a Slackr owner
"""
user1 = auth.auth_register("*****@*****.**", "password", "Earthworm",
"Jim")
user2 = auth.auth_register("*****@*****.**", "password", "Gabe",
"Newell")
user3 = auth.auth_register("*****@*****.**", "Potions", "Harry",
"Potter")
# user2 creates a channel, they should be the only owner
c_id_dict = channels.channels_create(user2["token"], "test_channel", True)
channel.channel_join(user3["token"], c_id_dict["channel_id"])
details_before = channel.channel_details(user2["token"],
c_id_dict["channel_id"])
assert details_before["owner_members"][0]["u_id"] == user2["u_id"]
assert len(details_before["owner_members"]) == 1
# user2 makes user3 an owner, channel_details should now show two owners
channel.channel_addowner(user2["token"], c_id_dict["channel_id"],
user3["u_id"])
details_after = channel.channel_details(user2["token"],
c_id_dict["channel_id"])
assert len(details_after["owner_members"]) == 2
assert details_after["owner_members"][0]["u_id"] == user2["u_id"]
assert details_after["owner_members"][1]["u_id"] == user3["u_id"]
# user1 (admin) joins the channel, he should be owner
channel.channel_join(user1["token"], c_id_dict["channel_id"])
details_admin = channel.channel_details(user1["token"],
c_id_dict["channel_id"])
assert len(details_admin["owner_members"]) == 3
assert details_admin["owner_members"][2]["u_id"] == user1["u_id"]
def test_leave_valid():
"""
Tests if channel_leave works with a valid token and channel ID
"""
# establish a test register
test_dict = auth.auth_register("*****@*****.**", "password", "Bob", "Ross")
# valid channel ID (assigned by channels_create)
c_id_dict = channels.channels_create(test_dict["token"], "test rum ham",
True)
# create a second user and add them to the channel
test_dict_2 = auth.auth_register("*****@*****.**", "password2", "James",
"May")
channel.channel_join(test_dict_2["token"], c_id_dict["channel_id"])
# store our details before the leave
details_before = channel.channel_details(test_dict["token"],
c_id_dict["channel_id"])
# ensure there are two members: test_dict & test_dict_2
assert len(details_before["all_members"]) == 2
assert details_before["all_members"][0]["u_id"] == test_dict["u_id"]
assert details_before["all_members"][1]["u_id"] == test_dict_2["u_id"]
# test channel_leave to have James May(test_dict_2) leave
channel.channel_leave(test_dict_2["token"], c_id_dict["channel_id"])
# check that "test rum ham" only has 1 user in it: Bob Ross
details_after = channel.channel_details(test_dict["token"],
c_id_dict["channel_id"])
assert len(details_after["all_members"]) == 1
assert details_after["all_members"][0]["u_id"] == test_dict["u_id"]
def test_channel_add_owner():
results = auth_register("*****@*****.**", '123!Asdf', 'John', 'Smith')
results = auth_login('*****@*****.**', '123!Asdf')
token1 = results['token']
results2 = auth_register('*****@*****.**', 'zxc123asd', 'Bob',
'Builder')
results2 = auth_login('*****@*****.**', 'zxc123asd')
u_id2 = results2['u_id']
token2 = results2['token']
channel_info3 = channels_create(token1, 'Slakrs', True)
channel_addowner(token1, channel_info3, u_id2)
owners = channel_details(token2, channel_info3)['owner_members']
print(channel_details(token2, channel_info3))
print(owners[0]['u_id'])
is_owner = 0
j = 0
for i in owners:
if u_id2 == owners[j]['u_id']:
is_owner = 1
j = +1
assert is_owner == 1
def test_channel_addowner_user_slackr_owner(auth_fixture):
'''
Test case when authorised user is an owner of the slackr
'''
(server_data, auth_fixture) = auth_fixture
# get user details
tokenslackr = auth_fixture[0]['token']
token1 = auth_fixture[1]['token']
token2 = auth_fixture[2]['token']
u_id2 = auth_fixture[2]['u_id']
# create channels with 1 user (user 1 is owner)
channel_id1 = channels_create(server_data, token1, 'New_Channel',
True)['channel_id']
channel_id2 = channels_create(server_data, token1, 'Another_Channel',
True)['channel_id']
# add user2 as member to channel1
channel_invite(server_data, token1, channel_id1, u_id2)
# slackrowner adds user2 as owner for channel1 (which user2 is a member of) and channel2 (which user2 is not a member of)
channel_addowner(server_data, tokenslackr, channel_id1, u_id2)
channel_addowner(server_data, tokenslackr, channel_id2, u_id2)
# get details of channels
user2_channel_det1 = channel_details(server_data, token2,
channel_id1)['owner_members']
user2_channel_det2 = channel_details(server_data, token2,
channel_id2)['owner_members']
# check that user2 is an owner for both channels
assert any(True for i in user2_channel_det1 if i['u_id'] == u_id2)
assert any(True for i in user2_channel_det2 if i['u_id'] == u_id2)
def test_clear_users():
'''
Test that clear() removes the users[]
'''
# Test basic functionality initially
clear()
f_owner = auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
f_channel = channels_create(f_owner['token'], 'Channel 1', True)
details = channel_details(f_owner['token'], f_channel['channel_id'])
assert len(details['all_members']) == 1
assert len(details['owner_members']) == 1
random_user = auth_register('*****@*****.**', 'password', 'Random',
'User')
channel_invite(f_owner['token'], f_channel['channel_id'],
random_user['u_id'])
details = channel_details(f_owner['token'], f_channel['channel_id'])
assert len(details['all_members']) == 2
assert len(details['owner_members']) == 1
# Cannot register someone who's already a Flockr member
clear()
with pytest.raises(AccessError):
details = channel_details(f_owner['token'], f_channel['channel_id'])
auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
with pytest.raises(InputError):
auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
clear()
auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
def test_channel_details_unauthorised_user(channel_init):
'''
test_channel_details_unauthorised_user
'''
with pytest.raises(AccessError):
#Test with valid channel_id
channel_details(channel_init[3]['token'], channel_init[2])
def test_channel_invite_simple():
clear()
usera, userb = register_n_users(2)
channel_id = channels_create(userb["token"], "userb_channel",
False)["channel_id"]
usera_info = {
"u_id":
usera["u_id"],
"name_first":
auth_get_user_data_from_id(usera["u_id"])["first_name"],
"name_last":
auth_get_user_data_from_id(usera["u_id"])["last_name"],
"profile_img_url":
auth_get_user_data_from_id(usera["u_id"])["profile_img_url"],
}
channel_members_info = channel_details(userb["token"],
channel_id)["all_members"]
assert usera_info not in channel_members_info
channel_invite(userb["token"], channel_id, usera["u_id"])
updated_channel_members_info = channel_details(userb["token"],
channel_id)["all_members"]
assert usera_info in updated_channel_members_info
def test_join_standard():
info = starter()
u1, u2, u3, c1 = info[1], info[2], info[3], info[4]
# store user information
u3_info = {
'u_id': u3['u_id'],
'name_first': 'Charlie',
'name_last': 'Barry'
}
u1_info = {
'u_id': u1['u_id'],
'name_first': 'Elizabeth',
'name_last': 'Alexander'
}
u2_info = {'u_id': u2['u_id'], 'name_first': 'Jane', 'name_last': 'Anton'}
# user 1 joins public channel
channel.channel_join(u1['token'], c1['channel_id'])
details = channel.channel_details(u1['token'], c1['channel_id'])
# user 1 should appear in channel members list
assert details['all_members'] == [u3_info, u1_info]
# user 1 should NOT be in channel owners list
assert details['owner_members'] == [u3_info]
# user 2 joins public channel
channel.channel_join(u2['token'], c1['channel_id'])
details = channel.channel_details(u2['token'], c1['channel_id'])
# both users 1 and 2 should appear in list of channel members
assert details['all_members'] == [u3_info, u1_info, u2_info]
# users 1 and 2 should NOT appear in channel owners list
assert details['owner_members'] == [u3_info]
def test_channel_join_multiple_channels():
clear()
usera, userb, userc = register_n_users(3)
channel_id_a = channels_create(usera["token"], "channela",
is_public=True)["channel_id"]
channel_id_b = channels_create(userb["token"], "channelb",
is_public=True)["channel_id"]
channel_id_c = channels_create(userc["token"], "channelc",
is_public=True)["channel_id"]
channel_join(usera["token"], channel_id_b)
channel_join(usera["token"], channel_id_c)
channel_join(userb["token"], channel_id_c)
# usera should be able to get all the details since the channels are public
detailsa = channel_details(usera["token"], channel_id_a)
detailsb = channel_details(usera["token"], channel_id_b)
detailsc = channel_details(usera["token"], channel_id_c)
# there should still be only one owner
assert_contains_users_id(detailsa["owner_members"], [usera["u_id"]])
assert_contains_users_id(detailsb["owner_members"], [userb["u_id"]])
assert_contains_users_id(detailsc["owner_members"], [userc["u_id"]])
assert_contains_users_id(detailsa["all_members"], [usera["u_id"]])
assert_contains_users_id(detailsb["all_members"],
[usera["u_id"], userb["u_id"]])
assert_contains_users_id(detailsc["all_members"],
[usera["u_id"], userb["u_id"], userc["u_id"]])
def test_admin_valid_permission_change(auth_fixture):
"""
Pytest: testing valid requests
"""
(server_data, auth_fixture) = auth_fixture
token = auth_fixture[0]["token"]
token1 = auth_fixture[1]["token"]
token2 = auth_fixture[2]["token"]
token3 = auth_fixture[3]["token"]
token4 = auth_fixture[4]["token"]
u_id1 = auth_fixture[1]["u_id"]
u_id2 = auth_fixture[2]["u_id"]
u_id3 = auth_fixture[3]["u_id"]
u_id4 = auth_fixture[4]["u_id"]
# Change all of them to owner
admin_userpermission_change(server_data, token, u_id1,
const.PERMISSION_GLOBAL_OWNER)
admin_userpermission_change(server_data, token, u_id2,
const.PERMISSION_GLOBAL_OWNER)
admin_userpermission_change(server_data, token, u_id3,
const.PERMISSION_GLOBAL_OWNER)
admin_userpermission_change(server_data, token, u_id4,
const.PERMISSION_GLOBAL_OWNER)
# user 0 now create a channel
channel_info = channels_create(server_data, token, "TEST1", True)
# All other users join the channel, they should automatically become owners
channel_join(server_data, token1, channel_info["channel_id"])
channel_join(server_data, token2, channel_info["channel_id"])
channel_join(server_data, token3, channel_info["channel_id"])
channel_join(server_data, token4, channel_info["channel_id"])
# Get channel details and check
rt_info = channel_details(server_data, token, channel_info["channel_id"])
assert len(rt_info["owner_members"]) == 5
assert len(rt_info["all_members"]) == 5
# Test other users to change permission, it should not fail
admin_userpermission_change(server_data, token2, u_id1,
const.PERMISSION_GLOBAL_MEMBER)
admin_userpermission_change(server_data, token2, u_id3,
const.PERMISSION_GLOBAL_MEMBER)
admin_userpermission_change(server_data, token2, u_id4,
const.PERMISSION_GLOBAL_MEMBER)
# Create a second channel to test
channel_info = channels_create(server_data, token, "TEST1", True)
channel_join(server_data, token1, channel_info["channel_id"])
channel_join(server_data, token2, channel_info["channel_id"])
channel_join(server_data, token3, channel_info["channel_id"])
channel_join(server_data, token4, channel_info["channel_id"])
# Get channel details and check
rt_info = channel_details(server_data, token, channel_info["channel_id"])
assert len(rt_info["owner_members"]) == 2
assert len(rt_info["all_members"]) == 5
def test_removeowner_standard():
info = starter()
u1, u2, u3, c1 = info[1], info[2], info[3], info[4]
# get user information
u2_info = {'u_id': u2['u_id'], 'name_first': 'Jane', 'name_last': 'Anton'}
u3_info = {
'u_id': u3['u_id'],
'name_first': 'Charlie',
'name_last': 'Barry'
}
# user 3 adds user 1 as an owner
channel.channel_addowner(u3['token'], c1['channel_id'], u1['u_id'])
# user 3 adds user 2 as an owner
channel.channel_addowner(u3['token'], c1['channel_id'], u2['u_id'])
# user 2 removes user 1 as owner
channel.channel_removeowner(u2['token'], c1['channel_id'], u1['u_id'])
# user 1 should not be in owners list
details = channel.channel_details(u2['token'], c1['channel_id'])
assert details['owner_members'] == [u3_info, u2_info]
# user 2 removes herself as channel owner
channel.channel_removeowner(u2['token'], c1['channel_id'], u2['u_id'])
# channel should have one owner now
details = channel.channel_details(u2['token'], c1['channel_id'])
assert details['owner_members'] == [u3_info]
def test_channel_leave_correct_details(reset, create_private_channel,
create_user1):
'''
Testing channel is actually updated if user leaves by using channel_details
'''
# creating user and channel
new_ch, owner_info = create_private_channel
user_info = create_user1
# inviting user
channel_invite(owner_info["token"], new_ch["channel_id"],
user_info["u_id"])
# getting details
all_membs = channel_details(owner_info['token'],
new_ch['channel_id'])['all_members']
u_ids = [member['u_id'] for member in all_membs]
# asserting user is in the channel
assert user_info['u_id'] in u_ids
assert len(all_membs) == 3
channel_leave(user_info["token"], new_ch["channel_id"])
# getting details
all_membs = channel_details(owner_info['token'],
new_ch['channel_id'])['all_members']
u_ids = [member['u_id'] for member in all_membs]
assert user_info['u_id'] not in u_ids
assert len(all_membs) == 2
def test_database_clear():
# use some test helpers to populate with some more realistic data
usera = auth_register("*****@*****.**", "veryverysafe", "safety", "first")
userb = auth_register("*****@*****.**", "nostress", "safety", "second")
channels_create(usera["token"], "first_channel", is_public=True)
channels_create(userb["token"], "second_channel", is_public=True)
channels_create(userb["token"], "p_channel", is_public=False)
clear()
# the spec doesn't specifiy which of the InputError and AccessError should
# be raised first. This is an implementation detail, and since we are doing
# black box testing, we shouldn't rely on that.
with pytest.raises(Exception):
channel_details(usera["token"], "first_channel")
with pytest.raises(Exception):
channels_listall(usera["token"])
# assert len(channels_listall(usera['token'])) == 0
with pytest.raises(InputError):
auth_login("*****@*****.**", "veryverysafe")
with pytest.raises(InputError):
auth_login("*****@*****.**", "nostress")
def test_channel_details_invalid_channel(channel_init):
'''
test_channel_details_invalid_channel
'''
with pytest.raises(InputError):
#Test with valid user
channel_details(channel_init[0]['token'], "")
def test_channel_removeowner(auth_fixture):
'''
Test case for a simple channel removeowner
- owner removing another owner in the same channel
'''
(server_data, auth_fixture) = auth_fixture
# get user details
token1 = auth_fixture[1]['token']
token2 = auth_fixture[2]['token']
uid2 = auth_fixture[2]['u_id']
# create channels with user1 then add user2 as owner
pub_channel_id = channels_create(server_data, token1, 'New_Channel', True)['channel_id']
priv_channel_id = channels_create(server_data, token1, 'Priv_Channel', False)['channel_id']
channel_addowner(server_data, token1, pub_channel_id, uid2)
channel_addowner(server_data, token1, priv_channel_id, uid2)
# user1 removes user2 from owner permissions
channel_removeowner(server_data, token1, pub_channel_id, uid2)
channel_removeowner(server_data, token1, priv_channel_id, uid2)
# check channel details to make sure user 2 is a non owner member
user2_channel_det1 = channel_details(server_data, token2, pub_channel_id)['owner_members']
user2_channel_det2 = channel_details(server_data, token2, priv_channel_id)['owner_members']
# owner member list should not have any ids equal to the id of user2
assert not any(True for i in user2_channel_det1 if i['u_id'] == uid2)
assert not any(True for i in user2_channel_det2 if i['u_id'] == uid2)
def test_user_profile_setname_updated_on_channel():
'''
Test that user's details get updated on the channel
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "testpass", "First", "User")
test_user = auth.auth_register("*****@*****.**", "password", "Notedited",
"Alsonotedited")
channel_1 = channels.channels_create(owner['token'], "Test Channel", True)
channels.channels_create(owner['token'], "Test Channel 2", True)
channel_3 = channels.channels_create(test_user['token'], "Test Channel 2",
True)
channel.channel_join(test_user['token'], channel_1['channel_id'])
channel.channel_join(owner['token'], channel_3['channel_id'])
details = channel.channel_details(test_user['token'],
channel_1['channel_id'])
owner_dict = {
'u_id': owner['u_id'],
'name_first': "First",
'name_last': "User",
'profile_img_url': ""
}
test_user_dict = {
'u_id': test_user['u_id'],
'name_first': "Notedited",
'name_last': "Alsonotedited",
'profile_img_url': ""
}
assert details == {
'name': 'Test Channel',
'owner_members': [owner_dict],
'all_members': [owner_dict, test_user_dict]
}
user.user_profile_setname(test_user['token'], "Newname", "Nowedited")
user.user_profile_setname(owner['token'], "Firstedited", "Nowedited")
details = channel.channel_details(test_user['token'],
channel_1['channel_id'])
owner_dict = {
'u_id': owner['u_id'],
'name_first': "Firstedited",
'name_last': "Nowedited",
'profile_img_url': ""
}
test_user_dict = {
'u_id': test_user['u_id'],
'name_first': "Newname",
'name_last': "Nowedited",
'profile_img_url': ""
}
assert details == {
'name': 'Test Channel',
'owner_members': [owner_dict],
'all_members': [owner_dict, test_user_dict]
}
def test_channel_details_invalid_token(reset, create_public_channel,
create_user1):
'''
Access Error occurs when an unauthorized user invokes the function
'''
channel_id = create_public_channel[0]
with pytest.raises(AccessError):
channel_details("I am an invalid token", channel_id['channel_id'])
def test_not_member_of_channel():
'''test for access error'''
reset_data()
owner = auth_register("*****@*****.**", "hellocse", "jiaqi", "zhu")
user = auth_register("*****@*****.**", "iamrobert", "Robert", "Cad")
test_channel = channels.channels_create(owner['token'], "New Channel",
True)
with pytest.raises(AccessError):
channel.channel_details(user['token'], test_channel['channel_id'])
def test_channel_details_wrong_channel_id():
user_1 = auth_register("*****@*****.**", "12345678", "Devansh",
"Kala")
user_1_user_id = user_1["u_id"]
user_1_token = user_1["token"]
new_channel = channels_create(user_1_token, "NEWCHANNEL", True)
new_channel_channel_id = new_channel["channel_id"]
with pytest.raises(InputError) as e:
channel_details(user_1_token, new_channel_channel_id * 6789)
def test_channel_details_no_id(reset, create_private_channel):
'''
Input error when channel_id does not exist
'''
channel_id, owner_info = create_private_channel
non_channel_id = channel_id['channel_id'] + 1
with pytest.raises(InputError):
channel_details(owner_info['token'], non_channel_id)
def test_create_private():
clear()
usera, userb = register_n_users(2)
channel = channels_create(usera["token"], "channel", is_public=False)
details = channel_details(usera["token"], channel["channel_id"])
assert details["name"] == "channel"
with pytest.raises(AccessError):
channel_details(userb["token"], channel["channel_id"])
def test_channel_details_invalid_channel():
'''
Testing for when a Channel ID is not a valid channel
'''
clear()
token = auth_register('*****@*****.**', '123abc!@#', 'Hayden',
'Everest', None)['token']
channel_id = channels_create(token, 'TestChannel', True)['channel_id']
with pytest.raises(InputError):
channel_details(token, channel_id + 100)
def test_details_invalid_channel():
'''
Testing when channel is invalid.
'''
clear()
user = auth_register("*****@*****.**", 'erenyaegar', 'ando', 'pech')
user_token = user.get("token")
channels_create(user_token, "a", True)
with pytest.raises(InputError):
channel_details(user_token, "invalid channel")
def test_channel_details_not_member():
"""Testing an invalid member passed into channel_details"""
clear()
valid_user = auth_register("*****@*****.**", "validPassword",
"Validate", "Me")
invalid_user = auth_register("*****@*****.**", "invalidPassword",
"Invalidate", "Mee")
channels_create(valid_user["token"], "testing_invalid_user", False)
with pytest.raises(AccessError):
channel_details(invalid_user["token"], 1)
def test_channel_details_wrong_id():
other.clear()
user_1 = auth.auth_register("*****@*****.**", "abcd1234", "John",
"Smith")
channels.channels_create(user_1['token'], "Test Channel", True)
with pytest.raises(InputError):
channel.channel_details(user_1['token'], 2)
other.clear()
def test_channel_details_non_member(reset, create_user1,
create_public_channel):
'''
Access Error occurs when a user that does not
belong to a channel attempts to retrieve its details
'''
channel_id = create_public_channel[0]
user_info = create_user1
with pytest.raises(AccessError):
channel_details(user_info['token'], channel_id['channel_id'])
def test_remove_owner_with_the_only_member():
clear()
# register a owner and remove its owner
user_A = register_n_users(1)
public_channel = channels_create(user_A["token"], "public_channel", True)
channel_removeowner(user_A["token"], public_channel["channel_id"], user_A["u_id"])
# if a owner is the only member of a channel, we expect him leaving the channel after
# remove owner, so he won't have authority to access the channel
with pytest.raises(AccessError):
channel_details(user_A["token"], public_channel["channel_id"])
def test_channel_details_no_permission(channels_fixture):
"""
Function to test channel_details with no permissions
"""
(server_data, channels_fixture) = channels_fixture
token = channels_fixture[1]["token"]
channel_id = channels_fixture[3]["channels"][0]["channel_id"]
with pytest.raises(AccessError):
channel_details(server_data, token, channel_id)
