def _do_generate_default_settings(self, path = None, jar = None):
if path is None:
expected_path = 'mymcadmin.settings'
else:
expected_path = os.path.join(path, 'mymcadmin.settings')
expected_settings = {
'java': 'java',
'jvm_args': [],
'args': ['nogui'],
'autostart': True,
}
if jar is not None:
expected_settings['jar'] = jar
with unittest.mock.patch('builtins.open') as mock_open, \
unittest.mock.patch('json.dump') as json_dump:
file_stream = unittest.mock.Mock(spec = io.IOBase)
mock_open.return_value = mock_open
mock_open.__enter__.return_value = file_stream
Server.generate_default_settings(
path = path,
jar = jar,
)
mock_open.assert_called_with(expected_path, 'w')
json_dump.assert_called_with(
expected_settings,
file_stream,
indent = '\t',
)
def test_download_server_bad_sha(self, get_version_info, requests_get, mock_open):
"""
Tests that we handle when the jar download has an incorrect SHA
"""
get_version_info.return_value = {
'id': 'test',
'downloads': {
'server': {
'url': 'http://example.com/mc/test/server',
'sha1': 'deadbeef',
},
},
}
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = True
mock_response.iter_content.return_value = io.BytesIO(
'Hello, world!'.encode(),
)
requests_get.return_value = mock_response
file_stream = io.BytesIO()
mock_open.return_value = mock_open
mock_open.__enter__.return_value = file_stream
Server.download_server_jar(
'test',
path = 'home',
)
def test_download_server_no_server(self, get_version_info):
"""
Tests that we handle then there's no server download for this version
"""
get_version_info.return_value = {
'id': 'test',
'downloads': {},
}
Server.download_server_jar('test')
def test_get_version_info_missing(self, list_versions):
"""
Tests that we handle when the version can't be found
"""
list_versions.return_value = {
'latest': {},
'versions': [],
}
Server.get_version_info('nope')
def test_list_versions_network(self, requests_get):
"""
Tests that we can handle networking errors
"""
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = False
requests_get.return_value = mock_response
Server.list_versions()
def test_download_server_response(self, get_version_info, requests_get):
"""
Tests that we handle bad responses while downloading
"""
get_version_info.return_value = SAMPLE_VERSION
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = False
requests_get.return_value = mock_response
Server.download_server_jar('my_release')
def test_get_version_info_network(self, list_versions, requests_get):
"""
Tests that we handle when there's a networking problem
"""
list_versions.return_value = copy.deepcopy(SAMPLE_VERSIONS)
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = False
requests_get.return_value = mock_response
Server.get_version_info('my_release')
def _do_agree_to_eula(self, path = None):
expected_path = 'eula.txt' if path is None else os.path.join(path, 'eula.txt')
# pylint: disable=line-too-long
stream = io.StringIO(
"""#By changing the setting below to TRUE you are indicating your agreement to our EULA (https://account.mojang.com/documents/minecraft_eula).
#Mon Jan 01 00:00:00 CST 2016
eula=FALSE""",
)
# pylint: enable=line-too-long
with unittest.mock.patch('fileinput.FileInput') as file_input, \
unittest.mock.patch('builtins.print') as mock_print:
file_input.return_value = file_input
file_input.__enter__.return_value = stream
Server.agree_to_eula(path = path)
file_input.assert_called_with(
expected_path,
inplace = True,
backup = '.bak',
)
# pylint: disable=line-too-long
mock_print.assert_has_calls(
[
unittest.mock.call(
'#By changing the setting below to TRUE you are indicating your agreement to our EULA (https://account.mojang.com/documents/minecraft_eula).\n',
end = '',
),
unittest.mock.call(
'#Mon Jan 01 00:00:00 CST 2016\n',
end = '',
),
unittest.mock.call(
'eula=TRUE',
end = '',
),
]
)
def _do_server_download_test(self, target, path):
root = path if path is not None else os.getcwd()
with unittest.mock.patch('mymcadmin.server.Server.get_version_info') as get_version_info, \
unittest.mock.patch('requests.get') as requests_get, \
unittest.mock.patch('builtins.open') as mock_open:
get_version_info.return_value = SAMPLE_VERSION
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = True
mock_response.iter_content.return_value = io.BytesIO(
'Hello, world!'.encode(),
)
requests_get.return_value = mock_response
file_stream = io.BytesIO()
mock_open.return_value = mock_open
mock_open.__enter__.return_value = file_stream
jar_path = Server.download_server_jar(
version_id = target,
path = path,
)
self.assertEqual(
os.path.join(root, 'minecraft_server_my_release.jar'),
jar_path,
'Jar file path did not match expected',
)
mock_open.assert_called_with(
jar_path,
'wb',
)
get_version_info.assert_called_with(target)
requests_get.assert_called_with(
'http://example.com/download/myrelease/server',
stream = True,
)
def test_list_versions_default(self, requests_get):
"""
Tests that the list_versions method returns correctly
"""
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = True
mock_response.json.return_value = copy.deepcopy(SAMPLE_VERSIONS)
requests_get.return_value = mock_response
versions = Server.list_versions()
requests_get.assert_called_with(
'https://launchermeta.mojang.com/mc/game/version_manifest.json',
)
self.assertDictEqual(
SAMPLE_VERSIONS,
versions,
'Version data did not match expected',
)
def test_get_version_info_latest(self, list_versions, requests_get):
"""
Tests that we can get the infor for the latest server version by default
"""
list_versions.return_value = SAMPLE_VERSIONS
version_info = SAMPLE_VERSION
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = True
mock_response.json.return_value = version_info
requests_get.return_value = mock_response
version = Server.get_version_info()
requests_get.assert_called_with('http://example.com/mc/my_release.json')
self.assertDictEqual(
version_info,
version,
'Version metadata did not match expected',
)
def test_get_version_info(self, list_versions, requests_get):
"""
Tests that we can get the information about a specific server version
"""
list_versions.return_value = copy.deepcopy(SAMPLE_VERSIONS)
version_info = SAMPLE_VERSION
mock_response = unittest.mock.Mock(spec = requests.Response)
mock_response.ok = True
mock_response.json.return_value = version_info
requests_get.return_value = mock_response
version = Server.get_version_info('my_release')
requests_get.assert_called_with('http://example.com/mc/my_release.json')
self.assertDictEqual(
version_info,
version,
'The version metadata did not match the expected',
)
def test_list_versions_filter(self, requests_get):
"""
Tests that we can filter out versions by release type
"""
mock_response = unittest.mock.Mock(spec = requests.Response)
requests_get.return_value = mock_response
for i in range(16):
requests_get.reset_mock()
mock_response.ok = True
mock_response.json.return_value = copy.deepcopy(SAMPLE_VERSIONS)
snapshots = i & 0b1000 > 0
releases = i & 0b0100 > 0
betas = i & 0b0010 > 0
alphas = i & 0b0001 > 0
versions = Server.list_versions(
snapshots = snapshots,
releases = releases,
betas = betas,
alphas = alphas,
)
remaining_types = set(
[
v['type']
for v in versions['versions']
]
)
if not snapshots:
self.assertNotIn(
'latest',
versions['latest'],
'Snapshots not filtered from latest',
)
self.assertNotIn(
'snapshot',
remaining_types,
'Snapshots were not filtered out',
)
if not releases:
self.assertNotIn(
'release',
versions['latest'],
'Release not filtered from latest',
)
self.assertNotIn(
'release',
remaining_types,
'Releases were not filtered out',
)
if not betas:
self.assertNotIn(
'old_beta',
remaining_types,
'Betas were not filtered out',
)
if not alphas:
self.assertNotIn(
'old_alpha',
remaining_types,
'Alphas were not filtered out',
)
def setUp(self):
self.server_id = 'test_server'
self.server_path = os.path.join('test', self.server_id)
self.server = Server(self.server_path)
class TestServerMethods(unittest.TestCase):
"""
Tests the methods of the Server class
"""
def setUp(self):
self.server_id = 'test_server'
self.server_path = os.path.join('test', self.server_id)
self.server = Server(self.server_path)
@asynctest.patch('asyncio.create_subprocess_exec')
def test_start(self, create_subprocess_exec):
"""
Tests the server start command works as expected
"""
create_subprocess_exec.return_value = create_subprocess_exec
with utils.mock_property(self.server, 'command_args') as command_args:
command_args.return_value = [
'java',
'-jar',
'minecraft_server.jar',
]
self.server.start()
create_subprocess_exec.assert_called_with(
'java',
'-jar',
'minecraft_server.jar',
cwd = self.server_path,
stdin = asyncio.subprocess.PIPE,
stdout = asyncio.subprocess.PIPE,
stderr = asyncio.subprocess.PIPE,
)
@unittest.mock.patch('os.replace')
@unittest.mock.patch('builtins.open')
def test_save_settings(self, mock_open, replace):
"""
Test that we can save settings changes
"""
settings_file = os.path.join(self.server_path, 'mymcadmin.settings')
tmp_file = settings_file + '.tmp'
file_stream = io.StringIO()
mock_open.return_value = mock_open
mock_open.__enter__.return_value = file_stream
with utils.mock_property(self.server, 'settings') as settings:
settings.return_value = {
'java': 'java',
}
self.server.save_settings()
mock_open.assert_called_with(
tmp_file,
'w',
)
replace.assert_called_with(
tmp_file,
settings_file,
)
self.assertEqual(
"""{
"java": "java"
}""",
file_stream.getvalue(),
'Settings file did not match expected',
)
