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_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_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_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_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_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,
).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,
).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)
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_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(),
drained=[
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_drained = [
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().drained, expected_drained)
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,
).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_instances_with_page_token(self):
"""Ensures all instances are returned."""
def get_instances_in_instance_group(*args, **kwargs):
if kwargs.get('page_token'):
return {
'items': [
{'instance': 'url/instance-2'},
],
}
return {
'items': [
{'instance': 'url/instance-1'},
],
'nextPageToken': 'page-token',
}
self.mock(
instances.gce.Project,
'get_instances_in_instance_group',
get_instances_in_instance_group,
)
key = models.InstanceGroupManager(
key=instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
),
url='url',
).put()
models.InstanceTemplateRevision(key=key.parent(), project='project').put()
expected_urls = ['url/instance-1', 'url/instance-2']
urls = instances.fetch(key)
self.assertItemsEqual(urls, expected_urls)
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_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_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)
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_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_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)
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_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()
instances.ensure_entities_exist(key)
self.failIf(key.get().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_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_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_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 get_instance_group_manager_key(key):
"""Returns a key for the InstanceGroupManager the given Instance belongs to.
Args:
key: ndb.Key for a models.Instance.
Returns:
ndb.Key for a models.InstanceGroupManager entity.
"""
return instance_group_managers.get_instance_group_manager_key(
*key.id().split()[:-1])
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_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_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_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')
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_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()
models.InstanceTemplateRevision(key=key.parent(), project='project').put()
urls= instances.fetch(key)
self.failIf(urls)
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_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_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_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_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_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_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_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,
)
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_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,
)
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_equal(self):
expected = instance_group_managers.get_instance_group_manager_key(
'base-name',
'revision',
'zone',
)
key = instances.get_instance_key(
'base-name',
'revision',
'zone',
'instance-name',
)
self.assertEqual(instances.get_instance_group_manager_key(key),
expected)
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_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_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_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_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_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_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 get_instance_key(base_name, revision, zone, instance_name):
"""Returns a key for an Instance.
Args:
base_name: Base name for the models.InstanceTemplate.
revision: Revision string for the models.InstanceTemplateRevision.
zone: Zone for the models.InstanceGroupManager.
instance_name: Name of the models.Instance.
Returns:
ndb.Key for a models.InstanceTemplate entity.
"""
return ndb.Key(
models.Instance,
instance_name,
parent=instance_group_managers.get_instance_group_manager_key(
base_name, revision, zone),
)
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)
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)
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)
