def handle(self, *args: Any, **options: Any) -> None:
output_dir = options["output_dir"]
if output_dir is None:
print("You need to specify --output <output directory>")
exit(1)
if os.path.exists(output_dir) and not os.path.isdir(output_dir):
print(output_dir + " is not a directory")
exit(1)
os.makedirs(output_dir, exist_ok=True)
if os.listdir(output_dir):
print('Output directory should be empty!')
exit(1)
output_dir = os.path.realpath(output_dir)
data_dir = options['mattermost_data_dir']
if not os.path.exists(data_dir):
print("Directory not found: '%s'" % (data_dir, ))
exit(1)
data_dir = os.path.realpath(data_dir)
print("Converting Data ...")
do_convert_data(
mattermost_data_dir=data_dir,
output_dir=output_dir,
masking_content=options.get('masking_content', False),
)
def test_do_convert_data_with_masking(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch("builtins.print") as mock_print, self.assertLogs(
level="WARNING") as warn_log:
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=True,
)
self.assertEqual(
mock_print.mock_calls,
[
call("Generating data for", "gryffindor"),
call("Generating data for", "slytherin")
],
)
self.assertEqual(
warn_log.output,
[
"WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export",
"WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export",
],
)
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
messages = self.read_file(harry_team_output_dir,
"messages-000001.json")
self.assertIn(messages["zerver_message"][0]["content"],
"xxxxx xxxxxx xxx xxxxxxx.\n\n")
def test_import_data_to_existing_database(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch('builtins.print') as mock_print, self.assertLogs(level='WARNING') as warn_log:
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=True,
)
self.assertEqual(mock_print.mock_calls, [
call('Generating data for', 'gryffindor'),
call('Generating data for', 'slytherin')
])
self.assertEqual(warn_log.output, [
'WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export',
'WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export',
])
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
with self.assertLogs(level="INFO"):
do_import_realm(
import_dir=harry_team_output_dir,
subdomain='gryffindor',
)
realm = get_realm('gryffindor')
realm_users = UserProfile.objects.filter(realm=realm)
messages = Message.objects.filter(sender__in=realm_users)
for message in messages:
self.assertIsNotNone(message.rendered_content)
def test_do_convert_data_with_masking(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch('builtins.print') as mock_print, self.assertLogs(
level='WARNING') as warn_log:
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=True,
)
self.assertEqual(mock_print.mock_calls, [
call('Generating data for', 'gryffindor'),
call('Generating data for', 'slytherin')
])
self.assertEqual(warn_log.output, [
'WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export',
'WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export',
])
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
messages = self.read_file(harry_team_output_dir,
'messages-000001.json')
self.assertIn(messages['zerver_message'][0]['content'],
'xxxxx xxxxxx xxx xxxxxxx.\n\n')
def handle(self, *args: Any, **options: Any) -> None:
output_dir = options["output_dir"]
if output_dir is None:
raise CommandError(
"You need to specify --output <output directory>")
if os.path.exists(output_dir) and not os.path.isdir(output_dir):
raise CommandError(output_dir + " is not a directory")
os.makedirs(output_dir, exist_ok=True)
if os.listdir(output_dir):
raise CommandError("Output directory should be empty!")
output_dir = os.path.realpath(output_dir)
data_dir = options["mattermost_data_dir"]
if not os.path.exists(data_dir):
raise CommandError(f"Directory not found: '{data_dir}'")
data_dir = os.path.realpath(data_dir)
print("Converting data ...")
do_convert_data(
mattermost_data_dir=data_dir,
output_dir=output_dir,
masking_content=options.get("masking_content", False),
)
def test_import_data_to_existing_database(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch('builtins.print') as mock_print:
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=True,
)
self.assertEqual(mock_print.mock_calls, [
call('Generating data for', 'gryffindor'),
call('Generating data for', 'slytherin')
])
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
do_import_realm(
import_dir=harry_team_output_dir,
subdomain='gryffindor',
)
realm = get_realm('gryffindor')
realm_users = UserProfile.objects.filter(realm=realm)
messages = Message.objects.filter(sender__in=realm_users)
for message in messages:
self.assertIsNotNone(message.rendered_content)
def test_do_convert_data_with_masking(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
do_convert_data(mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=True)
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
messages = self.read_file(harry_team_output_dir,
'messages-000001.json')
self.assertIn(messages['zerver_message'][0]['content'],
'xxxxx xxxxxx xxx xxxxxxx.\n\n')
def test_import_data_to_existing_database(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
do_convert_data(mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=True)
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
do_import_realm(import_dir=harry_team_output_dir,
subdomain='gryffindor')
realm = get_realm('gryffindor')
realm_users = UserProfile.objects.filter(realm=realm)
messages = Message.objects.filter(sender__in=realm_users)
for message in messages:
self.assertIsNotNone(message.rendered_content)
def test_do_convert_data_with_masking(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch('builtins.print') as mock_print:
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=True,
)
self.assertEqual(mock_print.mock_calls, [
call('Generating data for', 'gryffindor'),
call('Generating data for', 'slytherin')
])
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
messages = self.read_file(harry_team_output_dir,
'messages-000001.json')
self.assertIn(messages['zerver_message'][0]['content'],
'xxxxx xxxxxx xxx xxxxxxx.\n\n')
def test_do_convert_data_with_direct_messages(self) -> None:
mattermost_data_dir = self.fixture_file_name("direct_channel", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch('builtins.print') as mock_print, self.assertLogs(level="INFO"):
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=False,
)
self.assertEqual(mock_print.mock_calls, [
call('Generating data for', 'gryffindor'),
])
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
self.assertEqual(os.path.exists(os.path.join(harry_team_output_dir, 'avatars')), True)
self.assertEqual(os.path.exists(os.path.join(harry_team_output_dir, 'emoji')), True)
self.assertEqual(os.path.exists(os.path.join(harry_team_output_dir, 'attachment.json')), True)
realm = self.read_file(harry_team_output_dir, 'realm.json')
self.assertEqual('Organization imported from Mattermost!',
realm['zerver_realm'][0]['description'])
exported_user_ids = self.get_set(realm['zerver_userprofile'], 'id')
exported_user_full_names = self.get_set(realm['zerver_userprofile'], 'full_name')
self.assertEqual({'Harry Potter', 'Ron Weasley', 'Ginny Weasley', 'Tom Riddle'}, exported_user_full_names)
exported_user_emails = self.get_set(realm['zerver_userprofile'], 'email')
self.assertEqual({'*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**'}, exported_user_emails)
self.assertEqual(len(realm['zerver_stream']), 3)
exported_stream_names = self.get_set(realm['zerver_stream'], 'name')
self.assertEqual(exported_stream_names, {'Gryffindor common room', 'Gryffindor quidditch team', 'Dumbledores army'})
self.assertEqual(self.get_set(realm['zerver_stream'], 'realm'), {realm['zerver_realm'][0]['id']})
self.assertEqual(self.get_set(realm['zerver_stream'], 'deactivated'), {False})
self.assertEqual(len(realm['zerver_defaultstream']), 0)
exported_recipient_ids = self.get_set(realm['zerver_recipient'], 'id')
self.assertEqual(len(exported_recipient_ids), 8)
exported_recipient_types = self.get_set(realm['zerver_recipient'], 'type')
self.assertEqual(exported_recipient_types, {1, 2, 3})
exported_recipient_type_ids = self.get_set(realm['zerver_recipient'], 'type_id')
self.assertEqual(len(exported_recipient_type_ids), 4)
exported_subscription_userprofile = self.get_set(realm['zerver_subscription'], 'user_profile')
self.assertEqual(len(exported_subscription_userprofile), 4)
exported_subscription_recipients = self.get_set(realm['zerver_subscription'], 'recipient')
self.assertEqual(len(exported_subscription_recipients), 8)
messages = self.read_file(harry_team_output_dir, 'messages-000001.json')
exported_messages_id = self.get_set(messages['zerver_message'], 'id')
self.assertIn(messages['zerver_message'][0]['sender'], exported_user_ids)
self.assertIn(messages['zerver_message'][0]['recipient'], exported_recipient_ids)
self.assertIn(messages['zerver_message'][0]['content'], 'ron joined the channel.\n\n')
exported_usermessage_userprofiles = self.get_set(messages['zerver_usermessage'], 'user_profile')
self.assertEqual(len(exported_usermessage_userprofiles), 3)
exported_usermessage_messages = self.get_set(messages['zerver_usermessage'], 'message')
self.assertEqual(exported_usermessage_messages, exported_messages_id)
with self.assertLogs(level="INFO"):
do_import_realm(
import_dir=harry_team_output_dir,
subdomain='gryffindor',
)
realm = get_realm('gryffindor')
messages = Message.objects.filter(sender__realm=realm)
for message in messages:
self.assertIsNotNone(message.rendered_content)
self.assertEqual(len(messages), 11)
stream_messages = messages.filter(recipient__type=Recipient.STREAM).order_by("date_sent")
stream_recipients = stream_messages.values_list("recipient", flat=True)
self.assertEqual(len(stream_messages), 4)
self.assertEqual(len(set(stream_recipients)), 2)
self.assertEqual(stream_messages[0].sender.email, "*****@*****.**")
self.assertEqual(stream_messages[0].content, "ron joined the channel.\n\n")
huddle_messages = messages.filter(recipient__type=Recipient.HUDDLE).order_by("date_sent")
huddle_recipients = huddle_messages.values_list("recipient", flat=True)
self.assertEqual(len(huddle_messages), 3)
self.assertEqual(len(set(huddle_recipients)), 1)
self.assertEqual(huddle_messages[0].sender.email, "*****@*****.**")
self.assertEqual(huddle_messages[0].content, "Who is going to Hogesmead this weekend?\n\n")
personal_messages = messages.filter(recipient__type=Recipient.PERSONAL).order_by("date_sent")
personal_recipients = personal_messages.values_list("recipient", flat=True)
self.assertEqual(len(personal_messages), 4)
self.assertEqual(len(set(personal_recipients)), 3)
self.assertEqual(personal_messages[0].sender.email, "*****@*****.**")
self.assertEqual(personal_messages[0].content, "hey harry\n\n")
def test_do_convert_data(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch('builtins.print') as mock_print, self.assertLogs(level='WARNING') as warn_log:
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=False,
)
self.assertEqual(mock_print.mock_calls, [
call('Generating data for', 'gryffindor'),
call('Generating data for', 'slytherin')
])
self.assertEqual(warn_log.output, [
'WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export',
'WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export',
])
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
self.assertEqual(os.path.exists(os.path.join(harry_team_output_dir, 'avatars')), True)
self.assertEqual(os.path.exists(os.path.join(harry_team_output_dir, 'emoji')), True)
self.assertEqual(os.path.exists(os.path.join(harry_team_output_dir, 'attachment.json')), True)
realm = self.read_file(harry_team_output_dir, 'realm.json')
self.assertEqual('Organization imported from Mattermost!',
realm['zerver_realm'][0]['description'])
exported_user_ids = self.get_set(realm['zerver_userprofile'], 'id')
exported_user_full_names = self.get_set(realm['zerver_userprofile'], 'full_name')
self.assertEqual({'Harry Potter', 'Ron Weasley', 'Severus Snape'}, exported_user_full_names)
exported_user_emails = self.get_set(realm['zerver_userprofile'], 'email')
self.assertEqual({'*****@*****.**', '*****@*****.**', '*****@*****.**'}, exported_user_emails)
self.assertEqual(len(realm['zerver_stream']), 3)
exported_stream_names = self.get_set(realm['zerver_stream'], 'name')
self.assertEqual(exported_stream_names, {'Gryffindor common room', 'Gryffindor quidditch team', 'Dumbledores army'})
self.assertEqual(self.get_set(realm['zerver_stream'], 'realm'), {realm['zerver_realm'][0]['id']})
self.assertEqual(self.get_set(realm['zerver_stream'], 'deactivated'), {False})
self.assertEqual(len(realm['zerver_defaultstream']), 0)
exported_recipient_ids = self.get_set(realm['zerver_recipient'], 'id')
self.assertEqual(len(exported_recipient_ids), 6)
exported_recipient_types = self.get_set(realm['zerver_recipient'], 'type')
self.assertEqual(exported_recipient_types, {1, 2})
exported_recipient_type_ids = self.get_set(realm['zerver_recipient'], 'type_id')
self.assertEqual(len(exported_recipient_type_ids), 3)
exported_subscription_userprofile = self.get_set(realm['zerver_subscription'], 'user_profile')
self.assertEqual(len(exported_subscription_userprofile), 3)
exported_subscription_recipients = self.get_set(realm['zerver_subscription'], 'recipient')
self.assertEqual(len(exported_subscription_recipients), 6)
messages = self.read_file(harry_team_output_dir, 'messages-000001.json')
exported_messages_id = self.get_set(messages['zerver_message'], 'id')
self.assertIn(messages['zerver_message'][0]['sender'], exported_user_ids)
self.assertIn(messages['zerver_message'][0]['recipient'], exported_recipient_ids)
self.assertIn(messages['zerver_message'][0]['content'], 'harry joined the channel.\n\n')
exported_usermessage_userprofiles = self.get_set(messages['zerver_usermessage'], 'user_profile')
self.assertEqual(len(exported_usermessage_userprofiles), 3)
exported_usermessage_messages = self.get_set(messages['zerver_usermessage'], 'message')
self.assertEqual(exported_usermessage_messages, exported_messages_id)
with self.assertLogs(level="INFO"):
do_import_realm(
import_dir=harry_team_output_dir,
subdomain='gryffindor',
)
realm = get_realm('gryffindor')
self.assertFalse(get_user("*****@*****.**", realm).is_mirror_dummy)
self.assertFalse(get_user("*****@*****.**", realm).is_mirror_dummy)
self.assertTrue(get_user("*****@*****.**", realm).is_mirror_dummy)
messages = Message.objects.filter(sender__realm=realm)
for message in messages:
self.assertIsNotNone(message.rendered_content)
def test_do_convert_data_with_direct_messages(self) -> None:
mattermost_data_dir = self.fixture_file_name("direct_channel",
"mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch("builtins.print") as mock_print, self.assertLogs(
level="INFO"):
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=False,
)
self.assertEqual(
mock_print.mock_calls,
[
call("Generating data for", "gryffindor"),
],
)
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
self.assertEqual(
os.path.exists(os.path.join(harry_team_output_dir, "avatars")),
True)
self.assertEqual(
os.path.exists(os.path.join(harry_team_output_dir, "emoji")), True)
self.assertEqual(
os.path.exists(os.path.join(harry_team_output_dir, "uploads")),
True)
self.assertEqual(
os.path.exists(
os.path.join(harry_team_output_dir, "attachment.json")), True)
realm = self.read_file(harry_team_output_dir, "realm.json")
self.assertEqual("Organization imported from Mattermost!",
realm["zerver_realm"][0]["description"])
exported_user_ids = self.get_set(realm["zerver_userprofile"], "id")
exported_user_full_names = self.get_set(realm["zerver_userprofile"],
"full_name")
self.assertEqual(
{"Harry Potter", "Ron Weasley", "Ginny Weasley", "Tom Riddle"},
exported_user_full_names)
exported_user_emails = self.get_set(realm["zerver_userprofile"],
"email")
self.assertEqual(
{
"*****@*****.**", "*****@*****.**", "*****@*****.**",
"*****@*****.**"
},
exported_user_emails,
)
self.assert_length(realm["zerver_stream"], 3)
exported_stream_names = self.get_set(realm["zerver_stream"], "name")
self.assertEqual(
exported_stream_names,
{
"Gryffindor common room", "Gryffindor quidditch team",
"Dumbledores army"
},
)
self.assertEqual(self.get_set(realm["zerver_stream"], "realm"),
{realm["zerver_realm"][0]["id"]})
self.assertEqual(self.get_set(realm["zerver_stream"], "deactivated"),
{False})
self.assert_length(realm["zerver_defaultstream"], 0)
exported_recipient_ids = self.get_set(realm["zerver_recipient"], "id")
self.assert_length(exported_recipient_ids, 8)
exported_recipient_types = self.get_set(realm["zerver_recipient"],
"type")
self.assertEqual(exported_recipient_types, {1, 2, 3})
exported_recipient_type_ids = self.get_set(realm["zerver_recipient"],
"type_id")
self.assert_length(exported_recipient_type_ids, 4)
exported_subscription_userprofile = self.get_set(
realm["zerver_subscription"], "user_profile")
self.assert_length(exported_subscription_userprofile, 4)
exported_subscription_recipients = self.get_set(
realm["zerver_subscription"], "recipient")
self.assert_length(exported_subscription_recipients, 8)
messages = self.read_file(harry_team_output_dir,
"messages-000001.json")
exported_messages_id = self.get_set(messages["zerver_message"], "id")
self.assertIn(messages["zerver_message"][0]["sender"],
exported_user_ids)
self.assertIn(messages["zerver_message"][0]["recipient"],
exported_recipient_ids)
self.assertIn(messages["zerver_message"][0]["content"],
"ron joined the channel.\n\n")
exported_usermessage_userprofiles = self.get_set(
messages["zerver_usermessage"], "user_profile")
self.assert_length(exported_usermessage_userprofiles, 3)
exported_usermessage_messages = self.get_set(
messages["zerver_usermessage"], "message")
self.assertEqual(exported_usermessage_messages, exported_messages_id)
with self.assertLogs(level="INFO"):
do_import_realm(
import_dir=harry_team_output_dir,
subdomain="gryffindor",
)
realm = get_realm("gryffindor")
messages = Message.objects.filter(sender__realm=realm)
for message in messages:
self.assertIsNotNone(message.rendered_content)
self.assert_length(messages, 11)
stream_messages = messages.filter(
recipient__type=Recipient.STREAM).order_by("date_sent")
stream_recipients = stream_messages.values_list("recipient", flat=True)
self.assert_length(stream_messages, 4)
self.assert_length(set(stream_recipients), 2)
self.assertEqual(stream_messages[0].sender.email, "*****@*****.**")
self.assertEqual(stream_messages[0].content,
"ron joined the channel.\n\n")
self.assertEqual(stream_messages[3].sender.email, "*****@*****.**")
self.assertRegex(
stream_messages[3].content,
"Looks like this channel is empty\n\n\\[this is a file\\]\\(.*\\)",
)
self.assertTrue(stream_messages[3].has_attachment)
self.assertFalse(stream_messages[3].has_image)
self.assertTrue(stream_messages[3].has_link)
huddle_messages = messages.filter(
recipient__type=Recipient.HUDDLE).order_by("date_sent")
huddle_recipients = huddle_messages.values_list("recipient", flat=True)
self.assert_length(huddle_messages, 3)
self.assert_length(set(huddle_recipients), 1)
self.assertEqual(huddle_messages[0].sender.email, "*****@*****.**")
self.assertEqual(huddle_messages[0].content,
"Who is going to Hogsmeade this weekend?\n\n")
personal_messages = messages.filter(
recipient__type=Recipient.PERSONAL).order_by("date_sent")
personal_recipients = personal_messages.values_list("recipient",
flat=True)
self.assert_length(personal_messages, 4)
self.assert_length(set(personal_recipients), 3)
self.assertEqual(personal_messages[0].sender.email, "*****@*****.**")
self.assertRegex(personal_messages[0].content,
"hey harry\n\n\\[harry-ron.jpg\\]\\(.*\\)")
self.assertTrue(personal_messages[0].has_attachment)
self.assertTrue(personal_messages[0].has_image)
self.assertTrue(personal_messages[0].has_link)
def test_do_convert_data(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
with patch("builtins.print") as mock_print, self.assertLogs(
level="WARNING") as warn_log:
do_convert_data(
mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=False,
)
self.assertEqual(
mock_print.mock_calls,
[
call("Generating data for", "gryffindor"),
call("Generating data for", "slytherin")
],
)
self.assertEqual(
warn_log.output,
[
"WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export",
"WARNING:root:Skipping importing huddles and PMs since there are multiple teams in the export",
],
)
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
self.assertEqual(
os.path.exists(os.path.join(harry_team_output_dir, "avatars")),
True)
self.assertEqual(
os.path.exists(os.path.join(harry_team_output_dir, "emoji")), True)
self.assertEqual(
os.path.exists(
os.path.join(harry_team_output_dir, "attachment.json")), True)
realm = self.read_file(harry_team_output_dir, "realm.json")
self.assertEqual("Organization imported from Mattermost!",
realm["zerver_realm"][0]["description"])
exported_user_ids = self.get_set(realm["zerver_userprofile"], "id")
exported_user_full_names = self.get_set(realm["zerver_userprofile"],
"full_name")
self.assertEqual({"Harry Potter", "Ron Weasley", "Severus Snape"},
exported_user_full_names)
exported_user_emails = self.get_set(realm["zerver_userprofile"],
"email")
self.assertEqual(
{"*****@*****.**", "*****@*****.**", "*****@*****.**"},
exported_user_emails)
self.assert_length(realm["zerver_stream"], 3)
exported_stream_names = self.get_set(realm["zerver_stream"], "name")
self.assertEqual(
exported_stream_names,
{
"Gryffindor common room", "Gryffindor quidditch team",
"Dumbledores army"
},
)
self.assertEqual(self.get_set(realm["zerver_stream"], "realm"),
{realm["zerver_realm"][0]["id"]})
self.assertEqual(self.get_set(realm["zerver_stream"], "deactivated"),
{False})
self.assert_length(realm["zerver_defaultstream"], 0)
exported_recipient_ids = self.get_set(realm["zerver_recipient"], "id")
self.assert_length(exported_recipient_ids, 6)
exported_recipient_types = self.get_set(realm["zerver_recipient"],
"type")
self.assertEqual(exported_recipient_types, {1, 2})
exported_recipient_type_ids = self.get_set(realm["zerver_recipient"],
"type_id")
self.assert_length(exported_recipient_type_ids, 3)
exported_subscription_userprofile = self.get_set(
realm["zerver_subscription"], "user_profile")
self.assert_length(exported_subscription_userprofile, 3)
exported_subscription_recipients = self.get_set(
realm["zerver_subscription"], "recipient")
self.assert_length(exported_subscription_recipients, 6)
messages = self.read_file(harry_team_output_dir,
"messages-000001.json")
exported_messages_id = self.get_set(messages["zerver_message"], "id")
self.assertIn(messages["zerver_message"][0]["sender"],
exported_user_ids)
self.assertIn(messages["zerver_message"][0]["recipient"],
exported_recipient_ids)
self.assertIn(messages["zerver_message"][0]["content"],
"harry joined the channel.\n\n")
exported_usermessage_userprofiles = self.get_set(
messages["zerver_usermessage"], "user_profile")
self.assert_length(exported_usermessage_userprofiles, 3)
exported_usermessage_messages = self.get_set(
messages["zerver_usermessage"], "message")
self.assertEqual(exported_usermessage_messages, exported_messages_id)
with self.assertLogs(level="INFO"):
do_import_realm(
import_dir=harry_team_output_dir,
subdomain="gryffindor",
)
realm = get_realm("gryffindor")
self.assertFalse(get_user("*****@*****.**", realm).is_mirror_dummy)
self.assertFalse(get_user("*****@*****.**", realm).is_mirror_dummy)
self.assertTrue(get_user("*****@*****.**", realm).is_mirror_dummy)
messages = Message.objects.filter(sender__realm=realm)
for message in messages:
self.assertIsNotNone(message.rendered_content)
self.verify_emoji_code_foreign_keys()
def test_do_convert_data(self) -> None:
mattermost_data_dir = self.fixture_file_name("", "mattermost_fixtures")
output_dir = self.make_import_output_dir("mattermost")
do_convert_data(mattermost_data_dir=mattermost_data_dir,
output_dir=output_dir,
masking_content=False)
harry_team_output_dir = self.team_output_dir(output_dir, "gryffindor")
self.assertEqual(
os.path.exists(os.path.join(harry_team_output_dir, 'avatars')),
True)
self.assertEqual(
os.path.exists(os.path.join(harry_team_output_dir, 'emoji')), True)
self.assertEqual(
os.path.exists(
os.path.join(harry_team_output_dir, 'attachment.json')), True)
realm = self.read_file(harry_team_output_dir, 'realm.json')
self.assertEqual('Organization imported from Mattermost!',
realm['zerver_realm'][0]['description'])
exported_user_ids = self.get_set(realm['zerver_userprofile'], 'id')
exported_user_full_names = self.get_set(realm['zerver_userprofile'],
'full_name')
self.assertEqual(set(['Harry Potter', 'Ron Weasley', 'Severus Snape']),
exported_user_full_names)
exported_user_emails = self.get_set(realm['zerver_userprofile'],
'email')
self.assertEqual(
set(['*****@*****.**', '*****@*****.**', '*****@*****.**']),
exported_user_emails)
self.assertEqual(len(realm['zerver_stream']), 3)
exported_stream_names = self.get_set(realm['zerver_stream'], 'name')
self.assertEqual(
exported_stream_names,
set([
'Gryffindor common room', 'Gryffindor quidditch team',
'Dumbledores army'
]))
self.assertEqual(self.get_set(realm['zerver_stream'], 'realm'),
set([realm['zerver_realm'][0]['id']]))
self.assertEqual(self.get_set(realm['zerver_stream'], 'deactivated'),
set([False]))
self.assertEqual(len(realm['zerver_defaultstream']), 0)
exported_recipient_ids = self.get_set(realm['zerver_recipient'], 'id')
self.assertEqual(len(exported_recipient_ids), 6)
exported_recipient_types = self.get_set(realm['zerver_recipient'],
'type')
self.assertEqual(exported_recipient_types, set([1, 2]))
exported_recipient_type_ids = self.get_set(realm['zerver_recipient'],
'type_id')
self.assertEqual(len(exported_recipient_type_ids), 3)
exported_subscription_userprofile = self.get_set(
realm['zerver_subscription'], 'user_profile')
self.assertEqual(len(exported_subscription_userprofile), 3)
exported_subscription_recipients = self.get_set(
realm['zerver_subscription'], 'recipient')
self.assertEqual(len(exported_subscription_recipients), 6)
messages = self.read_file(harry_team_output_dir,
'messages-000001.json')
exported_messages_id = self.get_set(messages['zerver_message'], 'id')
self.assertIn(messages['zerver_message'][0]['sender'],
exported_user_ids)
self.assertIn(messages['zerver_message'][0]['recipient'],
exported_recipient_ids)
self.assertIn(messages['zerver_message'][0]['content'],
'harry joined the channel.\n\n')
exported_usermessage_userprofiles = self.get_set(
messages['zerver_usermessage'], 'user_profile')
self.assertEqual(len(exported_usermessage_userprofiles), 2)
exported_usermessage_messages = self.get_set(
messages['zerver_usermessage'], 'message')
self.assertEqual(exported_usermessage_messages, exported_messages_id)
do_import_realm(import_dir=harry_team_output_dir,
subdomain='gryffindor')
realm = get_realm('gryffindor')
realm_users = UserProfile.objects.filter(realm=realm)
messages = Message.objects.filter(sender__in=realm_users)
for message in messages:
self.assertIsNotNone(message.rendered_content)
