class NPreservingPolicyTest(unittest.TestCase): def setUp(self): self.mock_schedule = Mock() self.mock_terminate = Mock() self.policy = NPreservingPolicy( schedule_process_callback=self.mock_schedule, terminate_process_callback=self.mock_terminate ) def test_apply_policy(self): parameters = {"preserve_n": 2, "execution_engine_id": "some_ee", "node_exclusive": "hats"} self.policy.parameters = parameters upids = [] all_procs = {"pd0": []} self.policy.apply_policy(all_procs, upids) schedule_call = call(ANY, ANY, configuration=None, execution_engine_id="some_ee", node_exclusive="hats") self.assertEqual(self.mock_schedule.call_args_list, [schedule_call, schedule_call]) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() owner = "fred" upids = ["myupid0", "myupid1"] definition = None state = None all_procs = { "pd0": [ ProcessRecord.new(owner, upids[0], definition, state), ProcessRecord.new(owner, upids[1], definition, state), ] } parameters["preserve_n"] = 1 self.policy.parameters = parameters self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_terminate.call_count, 1) self.assertEqual(self.mock_schedule.call_count, 0) def test_rejected_procs(self): parameters = {"preserve_n": 2, "execution_engine_id": "some_ee", "node_exclusive": "hats"} self.policy.parameters = parameters upids = [] all_procs = {"pd0": []} self.policy.apply_policy(all_procs, upids) schedule_call = call(ANY, ANY, configuration=None, execution_engine_id="some_ee", node_exclusive="hats") self.assertEqual(self.mock_schedule.call_args_list, [schedule_call, schedule_call]) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() owner = "fred" upids = ["myupid0", "myupid1"] definition = None state_running = ProcessState.RUNNING state_rejected = ProcessState.REJECTED all_procs = { "pd0": [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_rejected), ] } self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_schedule.call_count, 1) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() upids = ["myupid0", "myupid1", "myupid2"] all_procs = { "pd0": [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_rejected), ProcessRecord.new(owner, upids[2], definition, state_running), ] } self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_schedule.call_count, 0) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() parameters["preserve_n"] = 1 self.policy.parameters = parameters self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_terminate.call_count, 1) self.assertEqual(self.mock_schedule.call_count, 0) def test_set_status(self): self.assertEqual(self.policy.status(), HAState.PENDING) owner = "fred" upids = ["myupid0", "myupid1"] definition = None state_running = ProcessState.RUNNING state_pending = ProcessState.PENDING to_rebalance = 0 parameters = {"preserve_n": 3} self.policy.parameters = parameters self.assertEqual(self.policy.status(), HAState.PENDING) upids = ["myupid0"] all_procs = {"pd0": [ProcessRecord.new(owner, upids[0], definition, state_pending)]} self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.PENDING) upids = ["myupid0"] all_procs = {"pd0": [ProcessRecord.new(owner, upids[0], definition, state_running)]} self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.READY) upids = ["myupid0", "myupid1"] all_procs = { "pd0": [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_running), ] } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.READY) upids = ["myupid0", "myupid1", "myupid2"] all_procs = { "pd0": [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_running), ProcessRecord.new(owner, upids[2], definition, state_pending), ] } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.READY) upids = ["myupid0", "myupid1", "myupid2"] all_procs = { "pd0": [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_running), ProcessRecord.new(owner, upids[2], definition, state_running), ] } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.STEADY) self.policy._status = HAState.FAILED self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.FAILED)
class NPreservingPolicyTest(unittest.TestCase): def setUp(self): self.mock_schedule = Mock() self.mock_terminate = Mock() self.policy = NPreservingPolicy(schedule_process_callback=self.mock_schedule, terminate_process_callback=self.mock_terminate,) def test_apply_policy(self): parameters = { 'preserve_n': 2, 'execution_engine_id': 'some_ee', 'node_exclusive': 'hats' } self.policy.parameters = parameters upids = [] all_procs = {'pd0': []} self.policy.apply_policy(all_procs, upids) schedule_call = call(ANY, ANY, configuration=None, execution_engine_id='some_ee', node_exclusive='hats') self.assertEqual(self.mock_schedule.call_args_list, [schedule_call, schedule_call]) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() owner = 'fred' upids = ['myupid0', 'myupid1'] definition = None state = None all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state), ProcessRecord.new(owner, upids[1], definition, state), ], } parameters['preserve_n'] = 1 self.policy.parameters = parameters self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_terminate.call_count, 1) self.assertEqual(self.mock_schedule.call_count, 0) def test_rejected_procs(self): parameters = { 'preserve_n': 2, 'execution_engine_id': 'some_ee', 'node_exclusive': 'hats' } self.policy.parameters = parameters upids = [] all_procs = {'pd0': []} self.policy.apply_policy(all_procs, upids) schedule_call = call(ANY, ANY, configuration=None, execution_engine_id='some_ee', node_exclusive='hats') self.assertEqual(self.mock_schedule.call_args_list, [schedule_call, schedule_call]) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() owner = 'fred' upids = ['myupid0', 'myupid1'] definition = None state_running = ProcessState.RUNNING state_rejected = ProcessState.REJECTED all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_rejected), ], } self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_schedule.call_count, 1) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() upids = ['myupid0', 'myupid1', 'myupid2'] all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_rejected), ProcessRecord.new(owner, upids[2], definition, state_running), ], } self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_schedule.call_count, 0) self.assertEqual(self.mock_terminate.call_count, 0) self.mock_schedule.reset_mock() self.mock_terminate.reset_mock() parameters['preserve_n'] = 1 self.policy.parameters = parameters self.policy.apply_policy(all_procs, upids) self.assertEqual(self.mock_terminate.call_count, 1) self.assertEqual(self.mock_schedule.call_count, 0) def test_set_status(self): self.assertEqual(self.policy.status(), HAState.PENDING) owner = 'fred' upids = ['myupid0', 'myupid1'] definition = None state_running = ProcessState.RUNNING state_pending = ProcessState.PENDING to_rebalance = 0 parameters = { 'preserve_n': 3, } self.policy.parameters = parameters self.assertEqual(self.policy.status(), HAState.PENDING) upids = ['myupid0'] all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state_pending), ], } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.PENDING) upids = ['myupid0'] all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state_running), ], } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.READY) upids = ['myupid0', 'myupid1'] all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_running), ], } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.READY) upids = ['myupid0', 'myupid1', 'myupid2'] all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_running), ProcessRecord.new(owner, upids[2], definition, state_pending), ], } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.READY) upids = ['myupid0', 'myupid1', 'myupid2'] all_procs = { 'pd0': [ ProcessRecord.new(owner, upids[0], definition, state_running), ProcessRecord.new(owner, upids[1], definition, state_running), ProcessRecord.new(owner, upids[2], definition, state_running), ], } self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.STEADY) self.policy._status = HAState.FAILED self.policy._set_status(to_rebalance, upids, all_procs) self.assertEqual(self.policy.status(), HAState.FAILED)