def test_get_phases_checks_status_on_first_call_and_returns_correct_value(self):
        self.conn.send_get_request.return_value = self.status_with({
            'phases': [
                {
                    'name': 'name1',
                    'part': 'part1',
                    'description': 'description1',
                    'completion': 1
                },
                {
                    'name': 'name2',
                    'part': 'part2',
                    'description': 'description2',
                    'completion': 2
                }
            ]
        })
        d = Decompilation('ID', self.conn)

        phases = d.get_phases()

        self.assertEqual(len(phases), 2)
        self.assertEqual(phases[0].name, 'name1')
        self.assertEqual(phases[1].name, 'name2')
        self.assert_get_request_was_sent_with('/ID/status')

    def test_waits_until_cfg_is_generated(self):
        self.conn.send_get_request.side_effect = [
            self.status_with({
                'cfgs': {
                    'my_func': {
                        'generated': False,
                        'failed': False,
                        'error': None
                    }
                }
            }), self.status_with({
                'cfgs': {
                    'my_func': {
                        'generated': True,
                        'failed': False,
                        'error': None
                    }
                }
            })
        ]
        d = Decompilation('ID', self.conn)

        d.wait_until_cfg_is_generated('my_func')

        self.assertEqual(len(self.conn.send_get_request.mock_calls), 2)

    def test_does_not_raise_exception_when_on_failure_is_none(self):
        self.conn.send_get_request.return_value = self.status_with({
            'finished': True,
            'failed': True,
            'error': 'error message'
        })
        d = Decompilation('ID', self.conn)

        d.wait_until_finished(on_failure=None)

    def test_get_completion_checks_status_on_first_call_and_returns_correct_value(self):
        self.conn.send_get_request.return_value = self.status_with({
            'completion': 20
        })
        d = Decompilation('ID', self.conn)

        completion = d.get_completion()

        self.assertEqual(completion, 20)
        self.assert_get_request_was_sent_with('/ID/status')

    def test_returns_when_resource_is_finished(self):
        self.conn.send_get_request.return_value = self.status_with({
            'completion': 100,
            'finished': True,
            'succeeded': True
        })
        d = Decompilation('ID', self.conn)

        d.wait_until_finished()

        self.assert_get_request_was_sent_with('/ID/status')

    def test_get_archive_generation_error_returns_correct_error_when_failed(self):
        self.conn.send_get_request.return_value = self.status_with({
            'archive': {
                'generated': False,
                'failed': True,
                'error': 'error message'
            }
        })
        d = Decompilation('ID', self.conn)

        self.assertEqual(d.get_archive_generation_error(), 'error message')

    def test_get_archive_generation_error_returns_none_when_succeeded(self):
        self.conn.send_get_request.return_value = self.status_with({
            'archive': {
                'generated': True,
                'failed': False,
                'error': None
            }
        })
        d = Decompilation('ID', self.conn)

        self.assertIsNone(d.get_archive_generation_error())

    def test_archive_generation_has_failed_returns_false_when_not_finished(self):
        self.conn.send_get_request.return_value = self.status_with({
            'archive': {
                'generated': False,
                'failed': False,
                'error': None
            }
        })
        d = Decompilation('ID', self.conn)

        self.assertFalse(d.archive_generation_has_failed())

    def test_archive_generation_has_failed_returns_true_when_failed(self):
        self.conn.send_get_request.return_value = self.status_with({
            'archive': {
                'generated': False,
                'failed': True,
                'error': 'error message'
            }
        })
        d = Decompilation('ID', self.conn)

        self.assertTrue(d.archive_generation_has_failed())

    def test_cg_generation_has_failed_returns_false_when_succeeded(self):
        self.conn.send_get_request.return_value = self.status_with({
            'cg': {
                'generated': True,
                'failed': False,
                'error': None
            }
        })
        d = Decompilation('ID', self.conn)

        self.assertFalse(d.cg_generation_has_failed())

    def test_raises_exception_by_default_when_resource_failed(self):
        self.conn.send_get_request.return_value = self.status_with({
            'finished': True,
            'failed': True,
            'error': 'error message'
        })
        d = Decompilation('ID', self.conn)

        with self.assertRaises(DecompilationFailedError) as cm:
            d.wait_until_finished()
        self.assertRegex(str(cm.exception), r'.*error message.*')

    def test_calls_callback_when_resource_finishes(self):
        self.conn.send_get_request.return_value = self.status_with({
            'completion': 100,
            'finished': True,
            'succeeded': True
        })
        d = Decompilation('ID', self.conn)
        callback = mock.Mock()

        d.wait_until_finished(callback)

        callback.assert_called_once_with(d)

    def test_calls_on_failure_when_it_is_callable(self):
        self.conn.send_get_request.return_value = self.status_with({
            'finished': True,
            'failed': True,
            'error': 'error message'
        })
        d = Decompilation('ID', self.conn)
        on_failure = mock.Mock()

        d.wait_until_finished(on_failure=on_failure)

        on_failure.assert_called_once_with('error message')

    def test_archive_generation_has_finished_checks_status_on_first_call(self):
        self.conn.send_get_request.return_value = self.status_with({
            'archive': {
                'generated': True,
                'failed': False,
                'error': None
            }
        })
        d = Decompilation('ID', self.conn)

        d.archive_generation_has_finished()

        self.assert_get_request_was_sent_with('/ID/status')

    def test_get_cg_error_checks_status_on_first_call(self):
        self.conn.send_get_request.return_value = self.status_with({
            'cg': {
                'generated': False,
                'failed': True,
                'error': 'error message'
            }
        })
        d = Decompilation('ID', self.conn)

        d.get_cg_generation_error()

        self.assert_get_request_was_sent_with('/ID/status')

    def test_cfg_generation_has_finished_returns_true_when_generated(self):
        self.conn.send_get_request.return_value = self.status_with({
            'cfgs': {
                'my_func': {
                    'generated': True,
                    'failed': False,
                    'error': None
                }
            }
        })
        d = Decompilation('ID', self.conn)

        self.assertTrue(d.cfg_generation_has_finished('my_func'))

    def test_raises_exception_by_default_when_generation_failed(self):
        self.conn.send_get_request.return_value = self.status_with({
            'archive': {
                'generated': False,
                'failed': True,
                'error': 'error message'
            }
        })
        d = Decompilation('ID', self.conn)

        with self.assertRaises(ArchiveGenerationFailedError) as cm:
            d.wait_until_archive_is_generated()
        self.assertRegex(str(cm.exception), r'.*error message.*')

    def test_returns_when_archive_is_generated(self):
        self.conn.send_get_request.return_value = self.status_with({
            'archive': {
                'generated': True,
                'failed': False,
                'error': None
            }
        })
        d = Decompilation('ID', self.conn)

        d.wait_until_archive_is_generated()

        self.assert_get_request_was_sent_with('/ID/status')

    def test_cfg_generation_has_succeeded_returns_false_when_failed(self):
        self.conn.send_get_request.return_value = self.status_with({
            'cfgs': {
                'my_func': {
                    'generated': False,
                    'failed': True,
                    'error': 'error message'
                }
            }
        })
        d = Decompilation('ID', self.conn)

        self.assertFalse(d.cfg_generation_has_succeeded('my_func'))

    def test_cfg_generation_has_succeeded_checks_status_on_first_call(self):
        self.conn.send_get_request.return_value = self.status_with({
            'cfgs': {
                'my_func': {
                    'generated': True,
                    'failed': False,
                    'error': None
                }
            }
        })
        d = Decompilation('ID', self.conn)

        d.cfg_generation_has_succeeded('my_func')

        self.assert_get_request_was_sent_with('/ID/status')