blob: 42b5ed1833db000e1eb6051ed01d43c644aba1fd [file] [log] [blame]
#!/usr/bin/env vpython3
# Copyright 2015 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.
import test_env
from recipe_engine import recipe_api, config
def make_prop(**kwargs):
name = kwargs.pop('name', 'dumb_name')
return recipe_api.Property(**kwargs).bind(
name, RECIPE_PROPERTY, 'fake_repo::fake_recipe')
class TestProperties(test_env.RecipeEngineUnitTest):
def testDefault(self):
"""Tests the default option of properties."""
for val in (1, {}, 'test', None):
prop = make_prop(default=val)
self.assertEqual(val, prop.interpret(recipe_api.PROPERTY_SENTINEL, {}))
def testRequired(self):
"""Tests that a required property errors when not provided."""
prop = make_prop()
with self.assertRaises(ValueError):
prop.interpret(recipe_api.PROPERTY_SENTINEL, {})
def testTypeSingle(self):
"""Tests a simple typed property."""
prop = make_prop(kind=bool)
with self.assertRaises(TypeError):
prop.interpret(1, {})
self.assertEqual(True, prop.interpret(True, {}))
def testTypeFancy(self):
"""Tests a config style type property."""
prop = make_prop(kind=config.List(int))
for value in (1, 'hi', [3, 'test']):
with self.assertRaises(TypeError):
prop.interpret(value, {})
self.assertEqual([2, 3], prop.interpret([2, 3], {}))
def testFromEnviron(self):
"""Tests that properties can pick up values from environment."""
prop = make_prop(default='def', from_environ='ENV_VAR')
# Nothing is given => falls back to hardcoded default.
self.assertEqual('def', prop.interpret(recipe_api.PROPERTY_SENTINEL, {}))
# Only env var is given => uses it.
'var', prop.interpret(recipe_api.PROPERTY_SENTINEL, {'ENV_VAR': 'var'}))
# Explicit values override the environment.
self.assertEqual('value', prop.interpret('value', {'ENV_VAR': 'var'}))
def testValidTypes(self):
check = recipe_api.BoundProperty.legal_name
for test, result, is_param_name in (
('', False, False),
('.', False, False),
('foo', True, False),
('', True, False),
('', False, True),
('rietveld_url', True, False),):
check(test, is_param_name=is_param_name), result,
"name {} should be {}. is_param_name={}".format(
test, result, is_param_name))
def testParamName(self):
Tests setting a param name correctly carries through to a bound property.
prop = recipe_api.Property(param_name='b')
bound = prop.bind('a', RECIPE_PROPERTY, 'fake_repo::fake_recipe')
self.assertEqual('b', bound.param_name)
def testParamNameDotted(self):
Tests setting a param name correctly carries through to a bound property.
prop = recipe_api.Property(param_name='good_name')
bound = prop.bind('', RECIPE_PROPERTY,
self.assertEqual('good_name', bound.param_name)
def testModuleName(self):
Tests declaring $repo_name/module properties.
prop = recipe_api.Property(param_name='foo')
prop.bind('$fake_repo/fake_module', MODULE_PROPERTY,
with self.assertRaises(ValueError):
prop.bind('$fake_repo/wrong_module', MODULE_PROPERTY,
with self.assertRaises(ValueError):
prop.bind('$fake_repo/fake_module', RECIPE_PROPERTY,
class TestProtoProperties(test_env.RecipeEngineUnitTest):
def setUp(self):
super(TestProtoProperties, self).setUp()
self.deps = self.FakeRecipeDeps()
main = self.deps.main_repo
with main.write_file('recipe_proto/proto_props/props.proto') as proto:
syntax = "proto3";
message Props {
string best_prop = 1;
int32 worst_prop = 2;
message ModProps {
string mod_prop = 1;
message EnvProps {
string STR_ENVVAR = 1;
int32 NUM_ENVVAR = 2;
def testRecipeProperties(self):
main = self.deps.main_repo
with main.write_recipe('recipe') as recipe:
recipe.imports = ['from PB.proto_props import props']
recipe.DEPS += ['recipe_engine/properties']
recipe.PROPERTIES = 'props.Props'
recipe.ENV_PROPERTIES = 'props.EnvProps'
recipe.RunSteps_args += ['props', 'env_props']
api.step('dump', ['echo', '[ normal prop:', props.best_prop, ']'])
api.step('dump', ['echo', '[ env prop:', env_props.STR_ENVVAR, ']'])
output, retcode = main.recipes_py(
'run', 'recipe', 'best_prop="best property"', env={
'STR_ENVVAR': 'coolio',
self.assertEqual(retcode, 0, output)
self.assertIn('[ normal prop: best property ]', output)
self.assertIn('[ env prop: coolio ]', output)
def testModuleProperties(self):
main = self.deps.main_repo
with main.write_module('modname') as mod:
mod.imports = ['from PB.proto_props import props']
mod.PROPERTIES = 'props.ModProps'
mod.GLOBAL_PROPERTIES = 'props.Props'
mod.ENV_PROPERTIES = 'props.EnvProps'
def __init__(self, props, global_props, env_props, **kwargs):
super(ModnameApi, self).__init__(**kwargs)
self.value = global_props.best_prop
self.mod_value = props.mod_prop
self.env_value_str = env_props.STR_ENVVAR
self.env_value_num = env_props.NUM_ENVVAR
with main.write_recipe('recipe') as recipe:
recipe.DEPS += ['modname']
api.step('dump global', ['echo', '[ global:', api.modname.value, ']'])
api.step('dump mod', ['echo', '[ mod:', api.modname.mod_value, ']'])
api.step('dump env str', ['echo', '[ env str:', api.modname.env_value_str, ']'])
api.step('dump env num', ['echo', '[ env num:', api.modname.env_value_num, ']'])
output, retcode = main.recipes_py(
'run', 'recipe', 'best_prop="best property"',
'$main/modname={"mod_prop": "mod property"}',
'STR_ENVVAR': 'env property',
'NUM_ENVVAR': '9000',
self.assertEqual(retcode, 0, output)
self.assertIn('[ global: best property ]', output)
self.assertIn('[ mod: mod property ]', output)
self.assertIn('[ env str: env property ]', output)
self.assertIn('[ env num: 9000 ]', output)
def testBadPropertyType(self):
main = self.deps.main_repo
with main.write_recipe('recipe') as recipe:
recipe.imports = ['from PB.proto_props import props']
recipe.PROPERTIES = 'props.Props'
recipe.RunSteps_args += ['properties']
output, retcode = main.recipes_py('run', 'recipe',
'worst_prop="invalid value"')
self.assertNotEqual(retcode, 0, output)
self.assertRegexpMatches(output, r'ParseError.*worst_prop.*invalid value')
if __name__ == '__main__':