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', )