| #!/usr/bin/python |
| # Copyright 2016 The LUCI Authors. All rights reserved. |
| # Use of this source code is governed under the Apache License, Version 2.0 |
| # that can be found in the LICENSE file. |
| |
| """Unit tests for instance_group_managers.py.""" |
| |
| import unittest |
| |
| import test_env |
| test_env.setup_test_env() |
| |
| from google.appengine.ext import ndb |
| |
| from components import datastore_utils |
| from components import net |
| from test_support import test_case |
| |
| import instance_group_managers |
| import models |
| |
| |
| class CountInstancesTest(test_case.TestCase): |
| """Tests for instance_group_managers.count_instances.""" |
| |
| def test_no_instance_group_managers(self): |
| self.failIf(instance_group_managers.count_instances()) |
| |
| def test_one_instance_group_manager_no_instances(self): |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| expected = {'base-name': 0} |
| |
| actual = instance_group_managers.count_instances() |
| self.assertEqual(actual, expected) |
| |
| def test_one_instance_group_manager(self): |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| instances=[ |
| ndb.Key(models.Instance, 'fake-key-1'), |
| ndb.Key(models.Instance, 'fake-key-2'), |
| ], |
| ).put() |
| expected = {'base-name': 2} |
| |
| actual = instance_group_managers.count_instances() |
| self.assertEqual(actual, expected) |
| |
| def test_several_instance_group_manager(self): |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name-1', |
| 'revision', |
| 'zone-a', |
| ), |
| instances=[ |
| ndb.Key(models.Instance, 'fake-key-1'), |
| ndb.Key(models.Instance, 'fake-key-2'), |
| ], |
| ).put() |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name-1', |
| 'revision', |
| 'zone-b', |
| ), |
| instances=[ |
| ndb.Key(models.Instance, 'fake-key-3'), |
| ], |
| ).put() |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name-2', |
| 'revision', |
| 'zone', |
| ), |
| instances=[ |
| ndb.Key(models.Instance, 'fake-key-4'), |
| ], |
| ).put() |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name-3', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| expected = {'base-name-1': 3, 'base-name-2': 1, 'base-name-3': 0} |
| |
| actual = instance_group_managers.count_instances() |
| self.assertEqual(actual, expected) |
| |
| |
| class CreateTest(test_case.TestCase): |
| """Tests for instance_group_managers.create.""" |
| |
| def test_entity_doesnt_exist(self): |
| """Ensures nothing happens when the entity doesn't exist.""" |
| key = ndb.Key(models.InstanceGroupManager, 'fake-key') |
| |
| instance_group_managers.create(key) |
| |
| self.failIf(key.get()) |
| |
| def test_url_specified(self): |
| """Ensures nothing happens when URL is already specified.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='url', |
| ).put() |
| expected_url = 'url' |
| |
| instance_group_managers.create(key) |
| self.assertEqual(key.get().url, expected_url) |
| |
| def test_parent_doesnt_exist(self): |
| """Ensures nothing happens when the parent doesn't exist.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| |
| instance_group_managers.create(key) |
| self.failIf(key.get().url) |
| |
| def test_parent_project_unspecified(self): |
| """Ensures nothing happens when parent doesn't specify project.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| models.InstanceTemplateRevision(key=key.parent(), url='url').put() |
| |
| instance_group_managers.create(key) |
| self.failIf(key.get().url) |
| |
| def test_parent_url_unspecified(self): |
| """Ensures nothing happens when parent doesn't specify URL.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| models.InstanceTemplateRevision(key=key.parent(), project='project').put() |
| |
| instance_group_managers.create(key) |
| self.failIf(key.get().url) |
| |
| def test_creates(self): |
| """Ensures an instance group manager is created.""" |
| def create_instance_group_manager(*args, **kwargs): |
| return {'targetLink': 'url'} |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'create_instance_group_manager', |
| create_instance_group_manager, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=2, |
| maximum_size=2, |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='project', |
| url='instance-template-url', |
| ).put() |
| expected_url = 'url' |
| |
| instance_group_managers.create(key) |
| self.assertEqual(key.get().url, expected_url) |
| |
| def test_updates_when_already_created(self): |
| """Ensures an instance group manager is updated when already created.""" |
| def create_instance_group_manager(*args, **kwargs): |
| raise net.Error('', 409, '') |
| def get_instance_group_manager(*args, **kwargs): |
| return {'selfLink': 'url'} |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'create_instance_group_manager', |
| create_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=2, |
| maximum_size=2, |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='project', |
| url='instance-template-url', |
| ).put() |
| expected_url = 'url' |
| |
| instance_group_managers.create(key) |
| self.assertEqual(key.get().url, expected_url) |
| |
| def test_doesnt_update_when_creation_fails(self): |
| """Ensures an instance group manager is not updated when creation fails.""" |
| def create_instance_group_manager(*args, **kwargs): |
| raise net.Error('', 400, '') |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'create_instance_group_manager', |
| create_instance_group_manager, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=2, |
| maximum_size=2, |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='project', |
| url='instance-template-url', |
| ).put() |
| |
| self.assertRaises(net.Error, instance_group_managers.create, key) |
| self.failIf(key.get().url) |
| |
| |
| class DeleteTest(test_case.TestCase): |
| """Tests for instance_group_managers.delete.""" |
| |
| def test_entity_doesnt_exist(self): |
| """Ensures nothing happens when the entity doesn't exist.""" |
| key = ndb.Key(models.InstanceGroupManager, 'fake-key') |
| |
| instance_group_managers.delete(key) |
| self.failIf(key.get()) |
| |
| def test_deletes(self): |
| """Ensures an instance group manager is deleted.""" |
| def json_request(url, *args, **kwargs): |
| return {'targetLink': url} |
| self.mock(instance_group_managers.net, 'json_request', json_request) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='url', |
| ).put() |
| |
| instance_group_managers.delete(key) |
| self.failIf(key.get().url) |
| |
| def test_target_link_mismatch(self): |
| """Ensures nothing happens when targetLink doesn't match.""" |
| def json_request(*args, **kwargs): |
| return {'targetLink': 'mismatch'} |
| self.mock(instance_group_managers.net, 'json_request', json_request) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='url', |
| ).put() |
| |
| instance_group_managers.delete(key) |
| self.assertEqual(key.get().url, 'url') |
| |
| def test_url_unspecified(self): |
| """Ensures nothing happens when URL is unspecified.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| |
| instance_group_managers.delete(key) |
| self.failIf(key.get().url) |
| |
| def test_url_not_found(self): |
| """Ensures URL is updated when the instance group manager is not found.""" |
| def json_request(url, *args, **kwargs): |
| raise net.Error('', 404, '') |
| self.mock(instance_group_managers.net, 'json_request', json_request) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='url', |
| ).put() |
| |
| instance_group_managers.delete(key) |
| self.failIf(key.get().url) |
| |
| def test_deletion_fails(self): |
| """Ensures nothing happens when instance group manager deletion fails.""" |
| def json_request(url, *args, **kwargs): |
| raise net.Error('', 400, '') |
| self.mock(instance_group_managers.net, 'json_request', json_request) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='url', |
| ).put() |
| expected_url = 'url' |
| |
| self.assertRaises(net.Error, instance_group_managers.delete, key) |
| self.assertEqual(key.get().url, expected_url) |
| |
| |
| class GetDrainedInstanceGroupManagersTest(test_case.TestCase): |
| """Tests for instance_group_managers.get_drained_instance_group_managers.""" |
| |
| def test_no_entities(self): |
| """Ensures nothing is returned when there are no entities.""" |
| self.failIf(instance_group_managers.get_drained_instance_group_managers()) |
| |
| def test_nothing_active_or_drained(self): |
| """Ensures nothing is returned when there are no active/drained entities.""" |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| |
| self.failIf(instance_group_managers.get_drained_instance_group_managers()) |
| |
| def test_active_only(self): |
| """Ensures nothing is returned when there are only active entities.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| active=[ |
| key, |
| ], |
| ).put() |
| |
| self.failIf(instance_group_managers.get_drained_instance_group_managers()) |
| |
| def test_drained(self): |
| """Ensures drained entities are returned.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| drained=[ |
| key, |
| ], |
| ).put() |
| expected_keys = [key] |
| |
| self.assertItemsEqual( |
| instance_group_managers.get_drained_instance_group_managers(), |
| expected_keys, |
| ) |
| |
| def test_implicitly_drained(self): |
| """Ensures implicitly drained entities are returned.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| active=[ |
| key, |
| ], |
| ).put() |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| drained=[ |
| key.parent(), |
| ], |
| ).put() |
| expected_keys = [ |
| key, |
| ] |
| |
| self.assertItemsEqual( |
| instance_group_managers.get_drained_instance_group_managers(), |
| expected_keys, |
| ) |
| |
| |
| class GetBaseNameTest(test_case.TestCase): |
| """Tests for instance_group_managers.get_base_name.""" |
| |
| def test_get_base_name(self): |
| """Ensures base instance name is generated correctly.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision-extra-long', |
| 'zone', |
| ), |
| minimum_size=10, |
| maximum_size=10, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| self.assertEqual( |
| instance_group_managers.get_base_name(key.get()), |
| 'base-name-revision-zone', |
| ) |
| |
| |
| class GetInstanceGroupManagerToDeleteTest(test_case.TestCase): |
| """Tests for instance_group_managers.get_instance_group_manager_to_delete.""" |
| |
| def test_entity_doesnt_exist(self): |
| """Ensures no URL when the entity doesn't exist.""" |
| key = ndb.Key(models.InstanceGroupManager, 'fake-key') |
| self.failIf( |
| instance_group_managers.get_instance_group_manager_to_delete(key)) |
| |
| def test_instances(self): |
| """Ensures no URL when there are active instances.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| instances=[ |
| ndb.Key(models.Instance, 'fake-key'), |
| ], |
| url='url', |
| ).put() |
| |
| self.failIf( |
| instance_group_managers.get_instance_group_manager_to_delete(key)) |
| |
| def test_url_unspecified(self): |
| """Ensures no URL when URL is unspecified.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| |
| self.failIf( |
| instance_group_managers.get_instance_group_manager_to_delete(key)) |
| |
| def test_returns_url(self): |
| """Ensures URL is returned.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='url', |
| ).put() |
| expected_url = 'url' |
| |
| self.assertEqual( |
| instance_group_managers.get_instance_group_manager_to_delete(key), |
| expected_url, |
| ) |
| |
| |
| class ResizeTest(test_case.TestCase): |
| """Tests for instance_group_managers.resize.""" |
| |
| def test_entity_doesnt_exist(self): |
| def get_instance_group_manager(*args, **kwargs): |
| self.fail('get_instance_group_manager called') |
| |
| def resize_managed_instance_group(*args, **kwargs): |
| self.fail('resize_managed_instance_group called') |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = ndb.Key(models.InstanceGroupManager, 'fake-key') |
| instance_group_managers.resize(key) |
| self.failIf(key.get()) |
| |
| def test_no_url(self): |
| def get_instance_group_manager(*args, **kwargs): |
| self.fail('get_instance_group_manager called') |
| |
| def resize_managed_instance_group(*args, **kwargs): |
| self.fail('resize_managed_instance_group called') |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=10, |
| maximum_size=10, |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='fake-project', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_parent_doesnt_exist(self): |
| def get_instance_group_manager(*args, **kwargs): |
| self.fail('get_instance_group_manager called') |
| |
| def resize_managed_instance_group(*args, **kwargs): |
| self.fail('resize_managed_instance_group called') |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=10, |
| maximum_size=10, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_no_project(self): |
| def get_instance_group_manager(*args, **kwargs): |
| self.fail('get_instance_group_manager called') |
| |
| def resize_managed_instance_group(*args, **kwargs): |
| self.fail('resize_managed_instance_group called') |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=10, |
| maximum_size=10, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_resize_no_actions(self): |
| def get_instance_group_manager(*args, **kwargs): |
| return { |
| 'name': 'name', |
| } |
| |
| def resize_managed_instance_group(*args, **kwargs): |
| self.fail('resize_managed_instance_group called') |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=10, |
| maximum_size=10, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='fake-project', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_resize_none_created(self): |
| def get_instance_group_manager(*args, **kwargs): |
| return { |
| 'currentActions': { |
| 'none': 0, |
| }, |
| 'name': 'name', |
| 'targetSize': 0, |
| } |
| |
| def resize_managed_instance_group(_, name, zone, size): |
| self.assertEqual(name, 'name') |
| self.assertEqual(zone, 'zone') |
| self.assertEqual(size, 10) |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=10, |
| maximum_size=10, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='fake-project', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_resize_some_created(self): |
| def get_instance_group_manager(*args, **kwargs): |
| return { |
| 'currentActions': { |
| 'none': 3, |
| }, |
| 'name': 'name', |
| 'targetSize': 3, |
| } |
| |
| def resize_managed_instance_group(_, name, zone, size): |
| self.assertEqual(name, 'name') |
| self.assertEqual(zone, 'zone') |
| self.assertEqual(size, 103) |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=1000, |
| maximum_size=1000, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='fake-project', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_resize_all_created(self): |
| def get_instance_group_manager(*args, **kwargs): |
| return { |
| 'currentActions': { |
| 'none': 10, |
| }, |
| 'name': 'name', |
| 'targetSize': 10, |
| } |
| |
| def resize_managed_instance_group(_, name, zone, size): |
| self.failIf(True) |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=10, |
| maximum_size=10, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='fake-project', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_resize_excess_created(self): |
| def get_instance_group_manager(*args, **kwargs): |
| return { |
| 'currentActions': { |
| 'none': 2, |
| }, |
| 'name': 'name', |
| 'targetSize': 2, |
| } |
| |
| def resize_managed_instance_group(_, name, zone, size): |
| self.failIf(True) |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| minimum_size=1, |
| maximum_size=1, |
| url='https://example.com', |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='fake-project', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| def test_resize_other_revisions_created(self): |
| def get_instance_group_manager(*args, **kwargs): |
| return { |
| 'currentActions': { |
| 'none': 0, |
| }, |
| 'name': 'name', |
| 'targetSize': 0, |
| } |
| |
| def resize_managed_instance_group(_, name, zone, size): |
| self.assertEqual(name, 'name') |
| self.assertEqual(zone, 'zone') |
| self.assertEqual(size, 4) |
| |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'get_instance_group_manager', |
| get_instance_group_manager, |
| ) |
| self.mock( |
| instance_group_managers.gce.Project, |
| 'resize_managed_instance_group', |
| resize_managed_instance_group, |
| ) |
| |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision-1', |
| 'zone', |
| ), |
| minimum_size=7, |
| maximum_size=7, |
| url='https://example.com', |
| ).put() |
| models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision-2', |
| 'zone', |
| ), |
| instances=[ |
| ndb.Key(models.Instance, 'instance-name-1'), |
| ndb.Key(models.Instance, 'instance-name-2'), |
| ndb.Key(models.Instance, 'instance-name-3'), |
| ], |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| project='fake-project', |
| ).put() |
| models.InstanceTemplate(key=key.parent().parent()).put() |
| |
| instance_group_managers.resize(key) |
| |
| |
| class ScheduleCreationTest(test_case.TestCase): |
| """Tests for instance_group_managers.schedule_creation.""" |
| |
| def setUp(self, *args, **kwargs): |
| def enqueue_task(taskqueue, key): |
| entity = key.get() |
| entity.url = key.urlsafe() |
| entity.put() |
| return True |
| |
| super(ScheduleCreationTest, self).setUp(*args, **kwargs) |
| self.mock(instance_group_managers.utilities, 'enqueue_task', enqueue_task) |
| |
| def test_enqueues_task(self): |
| """Ensures a task is enqueued.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| active=key.parent(), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| active=[ |
| key, |
| ], |
| url='url', |
| ).put() |
| models.InstanceGroupManager(key=key).put() |
| expected_url = key.urlsafe() |
| |
| instance_group_managers.schedule_creation() |
| |
| self.assertEqual(key.get().url, expected_url) |
| |
| def test_instance_template_revision_inactive(self): |
| """Ensures no task is enqueued for inactive instance template revisions.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| active=[ |
| key, |
| ], |
| url='url', |
| ).put() |
| models.InstanceGroupManager(key=key).put() |
| |
| instance_group_managers.schedule_creation() |
| |
| self.failIf(key.get().url) |
| |
| def test_instance_template_revision_missing(self): |
| """Ensures no task is enqueued for missing instance template revisions.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| active=key.parent(), |
| ).put() |
| models.InstanceGroupManager(key=key).put() |
| |
| instance_group_managers.schedule_creation() |
| |
| self.failIf(key.get().url) |
| |
| def test_instance_template_revision_no_url(self): |
| """Ensures no task is enqueued when instance template URL is missing.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| active=key.parent(), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| active=[ |
| key, |
| ], |
| ).put() |
| models.InstanceGroupManager(key=key).put() |
| |
| instance_group_managers.schedule_creation() |
| |
| self.failIf(key.get().url) |
| |
| def test_instance_group_manager_inactive(self): |
| """Ensures no task is enqueued for inactive instance group managers.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| active=key.parent(), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| url='url', |
| ).put() |
| models.InstanceGroupManager(key=key).put() |
| |
| instance_group_managers.schedule_creation() |
| |
| self.failIf(key.get().url) |
| |
| def test_instance_group_manager_drained(self): |
| """Ensures no task is enqueued for drained instance group managers.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| active=key.parent(), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| drained=[ |
| key, |
| ], |
| url='url', |
| ).put() |
| models.InstanceGroupManager(key=key).put() |
| |
| instance_group_managers.schedule_creation() |
| |
| self.failIf(key.get().url) |
| |
| def test_instance_group_manager_missing(self): |
| """Ensures no task is enqueued for missing instance group managers.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| active=key.parent(), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| active=[ |
| key, |
| ], |
| url='url', |
| ).put() |
| key = models.InstanceGroupManager().put() |
| |
| instance_group_managers.schedule_creation() |
| |
| self.failIf(key.get().url) |
| |
| def test_instance_group_manager_already_created(self): |
| """Ensures no task is enqueued for existing instance group managers.""" |
| key = instance_group_managers.get_instance_group_manager_key( |
| 'base-name', 'revision', 'zone') |
| models.InstanceTemplate( |
| key=key.parent().parent(), |
| active=key.parent(), |
| ).put() |
| models.InstanceTemplateRevision( |
| key=key.parent(), |
| active=[ |
| key, |
| ], |
| url='instance-template-url', |
| ).put() |
| models.InstanceGroupManager(key=key, url='url').put() |
| expected_url = 'url' |
| |
| instance_group_managers.schedule_creation() |
| |
| self.assertEqual(key.get().url, expected_url) |
| |
| |
| class UpdateURLTest(test_case.TestCase): |
| """Tests for instance_group_managers.update_url.""" |
| |
| def test_entity_doesnt_exist(self): |
| """Ensures nothing happens when the entity doesn't exist.""" |
| key = ndb.Key(models.InstanceGroupManager, 'fake-key') |
| instance_group_managers.update_url(key, 'url') |
| self.failIf(key.get()) |
| |
| def test_url_matches(self): |
| """Ensures nothing happens when the URL already matches.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='url', |
| ).put() |
| |
| instance_group_managers.update_url(key, 'url') |
| |
| self.assertEqual(key.get().url, 'url') |
| |
| def test_url_mismatch(self): |
| """Ensures the URL is updated when it doesn't match.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| url='old-url', |
| ).put() |
| |
| instance_group_managers.update_url(key, 'new-url') |
| |
| self.assertEqual(key.get().url, 'new-url') |
| |
| def test_url_updated(self): |
| """Ensures the URL is updated.""" |
| key = models.InstanceGroupManager( |
| key=instance_group_managers.get_instance_group_manager_key( |
| 'base-name', |
| 'revision', |
| 'zone', |
| ), |
| ).put() |
| |
| instance_group_managers.update_url(key, 'url') |
| |
| self.assertEqual(key.get().url, 'url') |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
