Exemplo n.º 1
0
 def test_mesos_timeout(self, mock_get_cached_list_of_running_tasks_from_frameworks):
     mock_get_cached_list_of_running_tasks_from_frameworks.side_effect = ReadTimeout
     mesos_status = instance.marathon_mesos_status(
         "fake_service", "fake_instance", verbose=0
     )
     assert mesos_status == {
         "error_message": "Talking to Mesos timed out. It may be overloaded."
     }
    def test_not_verbose(
            self, mock_get_cached_list_of_running_tasks_from_frameworks):
        mock_task1 = Task(master=mock.Mock(),
                          items={"id": "fake--service.fake--instance.1"})
        mock_task2 = Task(master=mock.Mock(),
                          items={"id": "fake--service.fake--instance.2"})
        mock_get_cached_list_of_running_tasks_from_frameworks.return_value = [
            mock_task1,
            mock_task2,
        ]
        mesos_status = instance.marathon_mesos_status("fake_service",
                                                      "fake_instance",
                                                      verbose=0)

        assert mesos_status == {"running_task_count": 2}
    def test_verbose(self,
                     mock_get_cached_list_of_running_tasks_from_frameworks):
        with asynctest.patch(
                "paasta_tools.api.views.instance.get_cached_list_of_not_running_tasks_from_frameworks",
                autospec=True,
        ) as mock_get_cached_list_of_not_running_tasks_from_frameworks, asynctest.patch(
                "paasta_tools.api.views.instance.get_mesos_running_task_dict",
                autospec=True
        ) as mock_get_mesos_running_task_dict, asynctest.patch(
                "paasta_tools.api.views.instance.get_mesos_non_running_task_dict",
                autospec=True,
        ) as mock_get_mesos_non_running_task_dict:
            running_task_1 = Task(
                master=mock.Mock(),
                items={"id": "fake--service.fake--instance.1"})
            running_task_2 = Task(
                master=mock.Mock(),
                items={"id": "fake--service.fake--instance.2"})
            non_running_task = Task(
                master=mock.Mock(),
                items={
                    "id": "fake--service.fake--instance.3",
                    "statuses": [{
                        "timestamp": 1560888500
                    }],
                },
            )

            mock_get_cached_list_of_running_tasks_from_frameworks.return_value = [
                running_task_1,
                running_task_2,
            ]
            mock_get_cached_list_of_not_running_tasks_from_frameworks.return_value = [
                non_running_task
            ]
            mock_get_mesos_running_task_dict.side_effect = lambda task, nlines: {
                "id": task["id"]
            }
            mock_get_mesos_non_running_task_dict.side_effect = lambda task, nlines: {
                "id": task["id"],
                "state": "TASK_LOST",
            }

            mesos_status = instance.marathon_mesos_status("fake_service",
                                                          "fake_instance",
                                                          verbose=2)

            assert mesos_status == {
                "running_task_count":
                2,
                "running_tasks": [
                    {
                        "id": "fake--service.fake--instance.1"
                    },
                    {
                        "id": "fake--service.fake--instance.2"
                    },
                ],
                "non_running_tasks": [{
                    "id": "fake--service.fake--instance.3",
                    "state": "TASK_LOST"
                }],
            }

            assert mock_get_mesos_running_task_dict.call_count == 2
            mock_get_mesos_running_task_dict.assert_has_calls(
                [mock.call(running_task_1, 10),
                 mock.call(running_task_2, 10)],
                any_order=True,
            )
            mock_get_mesos_non_running_task_dict.assert_called_once_with(
                non_running_task, 10)