def test_not_drained(self): """Ensures nothing happens when the parent is not drained.""" def json_request(*args, **kwargs): self.fail('json_request called') self.mock(cleanup.net, 'json_request', json_request) key = instances.get_instance_key( 'base-name', 'revision', 'zone', 'instance-name', ) key = models.Instance( key=key, instance_group_manager=instances.get_instance_group_manager_key( key), url='url', ).put() models.InstanceGroupManager( key=instances.get_instance_group_manager_key(key), ).put() models.InstanceTemplateRevision( key=instances.get_instance_group_manager_key( key).parent(), ).put() models.InstanceTemplate(key=instances.get_instance_group_manager_key( key).parent().parent(), ).put() cleanup.cleanup_drained_instance(key) self.failIf(key.get().deleted)
def test_deletes_implicitly_drained(self): """Ensures an implicitly drained entity is deleted.""" key = models.InstanceGroupManager( key=instance_group_managers.get_instance_group_manager_key( 'base-name', 'revision', 'zone', ), ).put() models.InstanceTemplateRevision( key=key.parent(), active=[ ndb.Key(models.InstanceGroupManager, 'fake-key-1'), key, ndb.Key(models.InstanceGroupManager, 'fake-key-2'), ], ).put() models.InstanceTemplate( key=key.parent().parent(), drained=[ key.parent(), ], ).put() expected_active = [ ndb.Key(models.InstanceGroupManager, 'fake-key-1'), ndb.Key(models.InstanceGroupManager, 'fake-key-2'), ] future = cleanup.delete_instance_group_manager(key) future.wait() self.failIf(key.get()) self.assertItemsEqual(key.parent().get().active, expected_active)
def test_active_instances(self): """Ensures nothing happens 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'), ], ).put() models.InstanceTemplateRevision( key=key.parent(), drained=[ key, ], ).put() models.InstanceTemplate( key=key.parent().parent(), active=key.parent(), ).put() future = cleanup.delete_instance_group_manager(key) future.wait() self.failUnless(key.get())
def test_deletes(self): """Ensures the entity is deleted.""" key = models.InstanceTemplateRevision( key=instance_templates.get_instance_template_revision_key( 'base-name', 'revision', ), ).put() models.InstanceTemplate( key=key.parent(), drained=[ ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'), key, ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'), ], ).put() expected_drained = [ ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'), ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'), ] future = cleanup.delete_instance_template_revision(key) future.wait() self.failIf(key.get()) self.assertItemsEqual(key.parent().get().drained, expected_drained)
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, )
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_url_specified(self): """Ensures nothing happens when the entity still has a URL.""" key = models.InstanceGroupManager( key=instance_group_managers.get_instance_group_manager_key( 'base-name', 'revision', 'zone', ), url='url', ).put() models.InstanceTemplateRevision( key=key.parent(), drained=[ key, ], ).put() models.InstanceTemplate( key=key.parent().parent(), active=key.parent(), ).put() future = cleanup.delete_instance_group_manager(key) future.wait() self.failUnless(key.get())
def test_deletes(self): """Ensures the entity is deleted.""" key = models.InstanceTemplate().put() future = cleanup.delete_instance_template(key) future.wait() self.failIf(key.get())
def test_nothing_active(self): """Ensures nothing happens when nothing is active.""" key = models.InstanceTemplate( key=instance_templates.get_instance_template_key( 'base-name'), ).put() parse.ensure_instance_template_revision_drained(key).wait() self.failIf(key.get().active) self.failIf(key.get().drained)
def test_active_instance_template_revisions(self): """Ensures nothing happens when an instance template revision is active.""" key = models.InstanceTemplate(active=ndb.Key( models.InstanceTemplateRevision, 'fake-key'), ).put() future = cleanup.delete_instance_template(key) future.wait() self.failUnless(key.get())
def test_multiple_instance_templates_drained_revisions(self): models.InstanceTemplate(drained=[ ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'), ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'), ], ).put() models.InstanceTemplate( active=ndb.Key(models.InstanceTemplateRevision, 'fake-key-3'), drained=[ ndb.Key(models.InstanceTemplateRevision, 'fake-key-4'), ], ).put() expected = [ ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'), ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'), ndb.Key(models.InstanceTemplateRevision, 'fake-key-4'), ] actual = instance_templates.get_drained_instance_template_revisions() self.assertItemsEqual(actual, expected)
def test_drained_instance_template_revisions(self): """Ensures nothing happens when instance template revisions are drained.""" key = models.InstanceTemplate(drained=[ ndb.Key(models.InstanceTemplateRevision, 'fake-key'), ], ).put() future = cleanup.delete_instance_template(key) future.wait() self.failUnless(key.get())
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)
def test_enqueues_task(self): """Ensures a task is enqueued.""" key = instance_templates.get_instance_template_revision_key( 'base-name', 'revision') models.InstanceTemplate(key=key.parent(), active=key).put() models.InstanceTemplateRevision(key=key).put() expected_url = key.urlsafe() instance_templates.schedule_creation() self.assertEqual(key.get().url, expected_url)
def test_activates(self): """Ensures that the instance template revision is activated.""" template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate( base_name='base-name', ) expected_active_key = parse.get_instance_template_revision_key( template_cfg) instance_template = models.InstanceTemplate() self.failUnless( parse.ensure_instance_template_revision_active( template_cfg, instance_template)) self.assertEqual(instance_template.active, expected_active_key)
def test_deletes(self): @ndb.tasklet def delete_instance_template(key): yield key.delete_async() self.mock( cleanup, 'delete_instance_template', delete_instance_template, ) models.InstanceTemplate(key=ndb.Key(models.InstanceTemplate, 'fake-key-1'), ).put() models.InstanceTemplate(key=ndb.Key(models.InstanceTemplate, 'fake-key-2'), ).put() models.InstanceTemplate(key=ndb.Key(models.InstanceTemplate, 'fake-key-3'), ).put() cleanup.cleanup_instance_templates(max_concurrent=2) self.failIf(ndb.Key(models.InstanceTemplate, 'fake-key-1').get()) self.failIf(ndb.Key(models.InstanceTemplate, 'fake-key-2').get()) self.failIf(ndb.Key(models.InstanceTemplate, 'fake-key-3').get())
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_drains_and_activates(self): """Ensures that the active instance template revision is drained.""" template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate( base_name='base-name', ) expected_active_key = parse.get_instance_template_revision_key( template_cfg) instance_template = models.InstanceTemplate(active=ndb.Key( models.InstanceTemplateRevision, 'fake-key'), ) self.failUnless( parse.ensure_instance_template_revision_active( template_cfg, instance_template)) self.assertEqual(instance_template.active, expected_active_key) self.assertEqual(instance_template.drained[0].id(), 'fake-key')
def test_enqueues_tasks(self): """Ensures tasks are enqueued.""" # Instance template should be created for key1. key1 = instance_templates.get_instance_template_revision_key( 'base-name-1', 'revision') models.InstanceTemplate(key=key1.parent(), active=key1).put() models.InstanceTemplateRevision(key=key1).put() # key2 refers to an inactive instance template revision. No instance # template should be created. key2 = instance_templates.get_instance_template_revision_key( 'base-name-2', 'revision') models.InstanceTemplate(key=key2.parent()).put() models.InstanceTemplateRevision(key=key2).put() # key3 refers to a drained instance template revision. No instance # template should be created. key3 = instance_templates.get_instance_template_revision_key( 'base-name-3', 'revision') models.InstanceTemplate(key=key3.parent(), drained=[key3]).put() models.InstanceTemplateRevision(key=key3).put() # key4 refers to an active instance template revision that does not # exist. No instance template should be created. key4 = instance_templates.get_instance_template_revision_key( 'base-name-4', 'revision') models.InstanceTemplate(key=key4.parent(), active=key4).put() # Instance template should be created for key5. key5 = instance_templates.get_instance_template_revision_key( 'base-name-5', 'revision') models.InstanceTemplate(key=key5.parent(), active=key5).put() models.InstanceTemplateRevision(key=key5).put() instance_templates.schedule_creation() self.assertEqual(key1.get().url, key1.urlsafe()) self.failIf(key2.get().url) self.failIf(key3.get().url) self.failIf(key4.get()) self.assertEqual(key5.get().url, key5.urlsafe())
def test_active(self): """Ensures nothing happens when the entity is active.""" key = models.InstanceTemplateRevision( key=instance_templates.get_instance_template_revision_key( 'base-name', 'revision', ), ).put() models.InstanceTemplate( key=key.parent(), active=key, ).put() future = cleanup.delete_instance_template_revision(key) future.wait() self.failUnless(key.get())
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() models.InstanceTemplate( key=key.parent().parent(), active=key.parent(), ).put() future = cleanup.delete_instance_group_manager(key) future.wait() self.failUnless(key.get())
def test_drains(self): """Ensures active InstanceTemplateRevision is drained.""" key = instance_templates.get_instance_template_revision_key( 'base-name', 'revision', ) models.InstanceTemplate( key=key.parent(), active=key, ).put() expected_drained = [ key, ] parse.ensure_instance_template_revision_drained(key.parent()).wait() self.failIf(key.parent().get().active) self.assertEqual(key.parent().get().drained, expected_drained)
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_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', )
def test_already_active(self): """Ensures that the active instance template revision remains active.""" template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate( base_name='base-name', ) expected_active_key = parse.get_instance_template_revision_key( template_cfg) instance_template = models.InstanceTemplate( active=parse.get_instance_template_revision_key(template_cfg), drained=[ ndb.Key(models.InstanceTemplateRevision, 'fake-key'), ], ) self.failIf( parse.ensure_instance_template_revision_active( template_cfg, instance_template)) self.assertEqual(instance_template.active, expected_active_key) self.assertEqual(len(instance_template.drained), 1) self.assertEqual(instance_template.drained[0].id(), 'fake-key')
def test_reactivates(self): """Ensures that the drained instance template revision is reactivated.""" template_cfg = config_pb2.InstanceTemplateConfig.InstanceTemplate( base_name='base-name', ) expected_active_key = parse.get_instance_template_revision_key( template_cfg) instance_template = models.InstanceTemplate(drained=[ ndb.Key(models.InstanceTemplateRevision, 'fake-key-1'), parse.get_instance_template_revision_key(template_cfg), ndb.Key(models.InstanceTemplateRevision, 'fake-key-2'), ], ) self.failUnless( parse.ensure_instance_template_revision_active( template_cfg, instance_template)) self.assertEqual(instance_template.active, expected_active_key) self.assertEqual(len(instance_template.drained), 2) self.assertEqual(instance_template.drained[0].id(), 'fake-key-1') self.assertEqual(instance_template.drained[1].id(), 'fake-key-2')
def test_resize_some_created(self): def get_instance_group_manager(*args, **kwargs): return { 'currentActions': { 'none': 3, }, 'name': 'name', } 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, 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_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_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)