def test_bad_result(self):
poolcfg = self.parse("""
task_template: {
name: "a"
env: {var: "VAR" }
}
""")
pools_config._resolve_task_template_inclusions(self.ctx,
poolcfg.task_template)
self.assertEqual(
[x.text for x in self.ctx.result().messages],
['template[u\'a\']: env[u\'VAR\']: empty value AND prefix'])
def test_resolve_deployments(self):
poolcfg = self.parse("""
task_template: {name: "prod" env: {var: "VAR" value: "prod"}}
task_template: {name: "canary" env: {var: "VAR" value: "canary"}}
task_template_deployment: {
name: "standard"
prod: {include: "prod"}
canary: {include: "canary"}
canary_chance: 5000
}
""")
tmap = pools_config._resolve_task_template_inclusions(
self.ctx, poolcfg.task_template)
dmap = pools_config._resolve_task_template_deployments(
self.ctx, tmap, poolcfg.task_template_deployment)
self.assertSetEqual({'standard'}, set(dmap.keys()))
self.assertEqual(
dmap['standard'],
pools_config.TaskTemplateDeployment(
prod=self.tt(env=[
self.PE(var='VAR', value='prod'),
],
inclusions={'prod'}),
canary=self.tt(env=[
self.PE(var='VAR', value='canary'),
],
inclusions={'canary'}),
canary_chance=5000))
def test_resolve_repeated_inclusion(self):
poolcfg = self.parse("""
task_template: {name: "a"}
task_template: {
name: "b"
include: "a"
include: "a"
}
""")
pools_config._resolve_task_template_inclusions(self.ctx,
poolcfg.task_template)
self.assertEqual(
[x.text for x in self.ctx.result().messages],
['template[u\'b\']: template u\'a\' included multiple times'])
def test_resolve_tree_inclusion(self):
poolcfg = self.parse("""
task_template: {
name: "a"
env: {var: "VAR" value: "1"}
}
task_template: {
name: "b"
env: {var: "VAR" prefix: "pfx"}
}
task_template: {
name: "c"
include: "a"
include: "b"
}
task_template: {
name: "d"
include: "c"
}
""")
template_map = pools_config._resolve_task_template_inclusions(
self.ctx, poolcfg.task_template)
self.assertSetEqual(set('abcd'), set(template_map.keys()))
self.assertEqual(
template_map['d'],
self.tt(
env=[self.PE(var='VAR', value='1', prefix=['pfx'])],
inclusions='abc',
))
def test_no_name(self):
poolcfg = self.parse("""
task_template: {}
""")
self.assertIsNone(
pools_config._resolve_task_template_inclusions(
self.ctx, poolcfg.task_template))
self.assertEqual([x.text for x in self.ctx.result().messages],
['one or more templates has a blank name'])
def test_resolve_diamond_inclusion(self):
poolcfg = self.parse("""
task_template: {name: "a"}
task_template: {
name: "b"
include: "a"
}
task_template: {
name: "c"
include: "a"
}
task_template: {
name: "d"
include: "b" include: "c"
}
""")
pools_config._resolve_task_template_inclusions(self.ctx,
poolcfg.task_template)
self.assertEqual([x.text for x in self.ctx.result().messages], [
'template[u\'d\']: template u\'a\' included (transitively) multiple '
'times'
])
def test_resolve_single_deployment(self):
poolcfg = self.parse("""
task_template: {name: "a" env: {var: "VAR" value: "1"} }
task_template_deployment: {
name: "std"
prod: {include: "a"}
}
pool {
task_template_deployment: "std"
}
pool {
task_template_deployment_inline: {
prod: {include: "a"}
canary: {
include: "a"
env: {var: "WAT" value: "yes"}
}
canary_chance: 5000
}
}
""")
tmap = pools_config._resolve_task_template_inclusions(
self.ctx, poolcfg.task_template)
dmap = pools_config._resolve_task_template_deployments(
self.ctx, tmap, poolcfg.task_template_deployment)
self.assertEqual(
pools_config.TaskTemplateDeployment(
prod=self.tt(env=[self.PE(var='VAR', value='1')],
inclusions='a'),
canary=None,
canary_chance=0,
),
pools_config._resolve_deployment(self.ctx, poolcfg.pool[0], tmap,
dmap))
self.assertEqual(
pools_config.TaskTemplateDeployment(
prod=self.tt(env=[self.PE(var='VAR', value='1')],
inclusions='a'),
canary=self.tt(env=(self.PE(var='VAR', value='1'),
self.PE(var='WAT', value='yes')),
inclusions={'a'}),
canary_chance=5000,
),
pools_config._resolve_deployment(self.ctx, poolcfg.pool[1], tmap,
dmap))
def test_bad_include(self):
poolcfg = self.parse("""
task_template: {name: "a" include: "nope"}
task_template: {name: "b" include: "nope"}
""")
template_map = pools_config._resolve_task_template_inclusions(
self.ctx, poolcfg.task_template)
self.assertDictEqual(template_map, {
'a': None,
'b': None,
})
self.assertEqual([x.text for x in self.ctx.result().messages], [
'template[u\'a\']: unknown include: u\'nope\'',
'template[u\'b\']: unknown include: u\'nope\'',
])
def test_inclusion_cycle(self):
poolcfg = self.parse("""
task_template: {name: "a" include: "b"}
task_template: {name: "b" include: "a"}
""")
template_map = pools_config._resolve_task_template_inclusions(
self.ctx, poolcfg.task_template)
self.assertDictEqual(
template_map, {
'a': pools_config.TaskTemplate.CYCLE,
'b': pools_config.TaskTemplate.CYCLE,
})
tail = ', which causes an import cycle'
self.assertEqual([x.text for x in self.ctx.result().messages], [
'template[u\'a\']: template[u\'b\']: depends on u\'a\'' + tail,
'template[u\'a\']: depends on u\'b\'' + tail,
])
