def test_impossible_type_conversions(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.integer)], ['inf'], {}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.boolean)], ['1'], {}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.boolean)], [3], {}, )
def test_param_type_int_or_inf(self): self.assertTrue( validateParams( 'TestParam', [Param('param', ParamTypes.intOrInf)], [1], {}, )) self.assertTrue( validateParams( 'TestParam', [Param('param', ParamTypes.intOrInf)], [float('inf')], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.intOrInf)], [1.2], {}, )
def test_default_value(self): # if no value is specified, but there is a default value, we don't # want the validator to raise an exception because 'None' is invalid self.assertEqual( validateParams('TestParam', [ Param('one', ParamTypes.aggFunc, default='sum'), ], [], {}), ([], {}), )
def test_use_series_function_as_aggregator(self): # powSeries is a series function which is marked as a valid aggregator self.assertEqual( validateParams('TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['powSeries'], {}), (['powSeries'], {}), ) # squareRoot is a series function which is not marked as a valid aggregator self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['squareRoot'], {}, )
def test_options_property(self): self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', '3'], {}, )) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'three'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'four'], {}, )
def test_unexpected_kwargs(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.integer)], [], { 'param': 1, 'param2': 2 }, )
def test_multiple_property(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param( 'three', ParamTypes.string, required=True, multiple=False), ], ['one', 'two', 'three', 'four'], {}, ) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three', 'four'], {}, ))
def test_multiple_property(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param( 'three', ParamTypes.string, required=True, multiple=False), ], ['one', 'two', 'three', 'four'], {}, ) self.assertEqual( validateParams('TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three', 'four'], {}), (['one', 'two', 'three', 'four'], {}), ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three'], # should fail because parameters which are specified multiple times # cannot be in kwargs, only args {'three': '3'}, )
from graphite.functions.params import Param, ParamTypes def test(seriesList): """This is a test function""" return seriesList test.params = [ Param('seriesList', ParamTypes.seriesList, required=True), ] SeriesFunctions = { 'testFunc': test, }
class TestParam(unittest.TestCase): params = [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True), ] def test_simple_args(self): self.assertEqual( validateParams('TestParam', self.params, ['arg1', 'arg2', 'arg3'], {}), (['arg1', 'arg2', 'arg3'], {}), ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['arg1', 'arg2'], {}, ) def test_simple_kwargs(self): self.assertEqual( validateParams('TestParam', self.params, [], { 'one': '1', 'two': '2', 'three': '3' }), ([], { 'one': '1', 'two': '2', 'three': '3' }), ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2', 'four': '4' }, ) def test_mixed_cases(self): self.assertEqual( validateParams('TestParam', self.params, ['one', 'two'], {'three': '3'}), (['one', 'two'], { 'three': '3' })) self.assertEqual( validateParams('TestParam', self.params, ['one'], { 'three': '3', 'two': '2' }), (['one'], { 'three': '3', 'two': '2' }), ) # positional args don't check the name self.assertEqual( validateParams('TestParam', self.params, ['one', 'two', 'four'], {}), (['one', 'two', 'four'], {})) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'three'], {'two': '2'}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['three'], { 'one': '1', 'two': '2' }, ) def test_repeated_args(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one'], { 'three': '3', 'one': '1' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two'], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two', 'three'], {'one': '1'}, ) def test_multiple_property(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param( 'three', ParamTypes.string, required=True, multiple=False), ], ['one', 'two', 'three', 'four'], {}, ) self.assertEqual( validateParams('TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three', 'four'], {}), (['one', 'two', 'three', 'four'], {}), ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three'], # should fail because parameters which are specified multiple times # cannot be in kwargs, only args {'three': '3'}, ) def test_options_property(self): self.assertEqual( validateParams('TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', '3'], {}), (['one', 'two', '3'], {}), ) self.assertEqual( validateParams('TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'three'], {}), (['one', 'two', 'three'], {}), ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'four'], {}, ) def test_use_series_function_as_aggregator(self): # powSeries is a series function which is marked as a valid aggregator self.assertEqual( validateParams('TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['powSeries'], {}), (['powSeries'], {}), ) # squareRoot is a series function which is not marked as a valid aggregator self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['squareRoot'], {}, ) def test_param_type_int_or_inf(self): self.assertEqual( validateParams('TestParam', [Param('param', ParamTypes.intOrInf)], [1], {}), ([1], {}), ) self.assertEqual( validateParams('TestParam', [Param('param', ParamTypes.intOrInf)], [float('inf')], {}), ([float('inf')], {}), ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.intOrInf)], [1.2], {}, ) def test_unexpected_kwargs(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.integer)], [], { 'param': 1, 'param2': 2 }, ) def test_default_value(self): # if no value is specified, but there is a default value, we don't # want the validator to raise an exception because 'None' is invalid self.assertEqual( validateParams('TestParam', [ Param('one', ParamTypes.aggFunc, default='sum'), ], [], {}), ([], {}), ) def test_various_type_conversions(self): self.assertEqual( validateParams('TestParam', [ Param('bool', ParamTypes.boolean), ], ['true'], {}), ([True], {}), ) self.assertEqual( validateParams('TestParam', [ Param('bool', ParamTypes.boolean), ], [], {'bool': 'false'}), ([], { 'bool': False }), ) self.assertEqual( validateParams('TestParam', [ Param('bool1', ParamTypes.boolean), Param('bool2', ParamTypes.boolean), ], [0], {'bool2': 1}), ([False], { 'bool2': True }), ) self.assertEqual( validateParams('TestParam', [ Param('float', ParamTypes.float), ], ['1e3'], {}), ([float(1000)], {}), ) self.assertEqual( validateParams('TestParam', [ Param('float', ParamTypes.float), ], ['0.123'], {}), ([float(0.123)], {}), ) self.assertEqual( validateParams('TestParam', [ Param('float', ParamTypes.float), ], [], {'float': 'inf'}), ([], { 'float': float('inf') }), ) self.assertEqual( validateParams('TestParam', [ Param('int', ParamTypes.integer), ], ['123'], {}), ([123], {}), ) self.assertEqual( validateParams('TestParam', [ Param('int', ParamTypes.integer), ], [], {'int': '-123'}), ([], { 'int': -123 }), ) self.assertEqual( validateParams('TestParam', [ Param('intOrInf', ParamTypes.intOrInf), ], ['123'], {}), ([123], {}), ) self.assertEqual( validateParams('TestParam', [ Param('intOrInf', ParamTypes.intOrInf), ], [], {'intOrInf': float('inf')}), ([], { 'intOrInf': float('inf') }), ) def test_impossible_type_conversions(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.integer)], ['inf'], {}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.boolean)], ['1'], {}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.boolean)], [3], {}, )
def test_various_type_conversions(self): self.assertEqual( validateParams('TestParam', [ Param('bool', ParamTypes.boolean), ], ['true'], {}), ([True], {}), ) self.assertEqual( validateParams('TestParam', [ Param('bool', ParamTypes.boolean), ], [], {'bool': 'false'}), ([], { 'bool': False }), ) self.assertEqual( validateParams('TestParam', [ Param('bool1', ParamTypes.boolean), Param('bool2', ParamTypes.boolean), ], [0], {'bool2': 1}), ([False], { 'bool2': True }), ) self.assertEqual( validateParams('TestParam', [ Param('float', ParamTypes.float), ], ['1e3'], {}), ([float(1000)], {}), ) self.assertEqual( validateParams('TestParam', [ Param('float', ParamTypes.float), ], ['0.123'], {}), ([float(0.123)], {}), ) self.assertEqual( validateParams('TestParam', [ Param('float', ParamTypes.float), ], [], {'float': 'inf'}), ([], { 'float': float('inf') }), ) self.assertEqual( validateParams('TestParam', [ Param('int', ParamTypes.integer), ], ['123'], {}), ([123], {}), ) self.assertEqual( validateParams('TestParam', [ Param('int', ParamTypes.integer), ], [], {'int': '-123'}), ([], { 'int': -123 }), ) self.assertEqual( validateParams('TestParam', [ Param('intOrInf', ParamTypes.intOrInf), ], ['123'], {}), ([123], {}), ) self.assertEqual( validateParams('TestParam', [ Param('intOrInf', ParamTypes.intOrInf), ], [], {'intOrInf': float('inf')}), ([], { 'intOrInf': float('inf') }), )
results = [] interval = int(to_seconds(parseTimeOffset(intervalString))) for series in seriesList: if series.step < interval: values_per_point = interval // series.step series.consolidate(values_per_point) series.step = interval results.append(series) return results smooth.group = 'Custom' smooth.params = [ Param('seriesList', ParamTypes.seriesList, required=True), Param('intervalString', ParamTypes.interval, required=True) ] def points(requestContext, seriesList, maxPoints): results = [] for series in seriesList: if not maxPoints or len(series) < maxPoints: results.append(series) continue if len(series) % maxPoints != 0: values_per_point = len(series) // maxPoints + 1 else: values_per_point = len(series) // maxPoints series.consolidate(values_per_point)
class TestParam(unittest.TestCase): params = [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True), ] def test_simple_args(self): self.assertTrue( validateParams( 'TestParam', self.params, ['arg1', 'arg2', 'arg3'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['arg1', 'arg2'], {}, ) def test_simple_kwargs(self): self.assertTrue( validateParams( 'TestParam', self.params, [], { 'one': '1', 'two': '2', 'three': '3' }, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2', 'four': '4' }, ) def test_mixed_cases(self): self.assertTrue( validateParams( 'TestParam', self.params, ['one', 'two'], {'three': '3'}, )) self.assertTrue( validateParams( 'TestParam', self.params, ['one'], { 'three': '3', 'two': '2' }, )) # positional args don't check the name self.assertTrue( validateParams( 'TestParam', self.params, ['one', 'two', 'four'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'three'], {'two': '2'}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['three'], { 'one': '1', 'two': '2' }, ) def test_repeated_args(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one'], { 'three': '3', 'one': '1' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two'], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two', 'three'], {'one': '1'}, ) def test_multiple_property(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param( 'three', ParamTypes.string, required=True, multiple=False), ], ['one', 'two', 'three', 'four'], {}, ) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three', 'four'], {}, )) def test_options_property(self): self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', '3'], {}, )) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'three'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'four'], {}, )
from graphite.functions.params import Param def test(seriesList): """This is a test function""" return seriesList test.group = 'Test' test.params = [ Param('seriesList', 'bad', required=True), ] SeriesFunctions = { 'testFunc': test, }
# Format the data into TimeSeries result = [] timeSeriesCount = matrix.shape[1] startTime = seriesLists[0].start stepTime = seriesLists[0].step endTime = startTime + clusterCount * stepTime for j in range(timeSeriesCount): result.append( TimeSeries(name = "master.kmeans.dim" + str(j), start = startTime, end = endTime, step = stepTime, values = clusters.T[j].tolist()) ) return result applyKmeans.group = 'Custom' applyKmeans.params = [ Param('seriesLists', ParamTypes.seriesLists, required=True), ] def applyCD(requestContext, seriesLists): """Custom function that runs cd""" # Extract the data into 2D numpy.array matrix = [] for i in range(len(seriesLists)): datapoints = seriesLists[i].datapoints() current_measurements = [] for j in range(len(datapoints)): if datapoints[j][0] == None:
) newSeries.pathExpression = newName # detect "none" lists if len([v for v in series if v is not None]) <= 1: newSeries.extend(series) else: # the "resolution" is a suggestion, # the algo will alter it some inorder # to get the best view for things new_s = smooth(series, windowPoints) # steps need to be ints, so we must force the issue new_step = round((series.end - series.start) / len(new_s)) newSeries.step = new_step newSeries.extend(new_s) result.append(newSeries) return result # optionally set the group attribute ASAP.group = 'Custom' ASAP.params = [ Param('seriesList', ParamTypes.seriesList, required=True), Param('resolution', ParamTypes.intOrInterval, required=False), ] SeriesFunctions = { 'asap': ASAP, }
class TestParam(unittest.TestCase): params = [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True), ] def test_simple_args(self): self.assertTrue( validateParams( 'TestParam', self.params, ['arg1', 'arg2', 'arg3'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['arg1', 'arg2'], {}, ) def test_simple_kwargs(self): self.assertTrue( validateParams( 'TestParam', self.params, [], { 'one': '1', 'two': '2', 'three': '3' }, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2', 'four': '4' }, ) def test_mixed_cases(self): self.assertTrue( validateParams( 'TestParam', self.params, ['one', 'two'], {'three': '3'}, )) self.assertTrue( validateParams( 'TestParam', self.params, ['one'], { 'three': '3', 'two': '2' }, )) # positional args don't check the name self.assertTrue( validateParams( 'TestParam', self.params, ['one', 'two', 'four'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'three'], {'two': '2'}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['three'], { 'one': '1', 'two': '2' }, ) def test_repeated_args(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one'], { 'three': '3', 'one': '1' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two'], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two', 'three'], {'one': '1'}, ) def test_multiple_property(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param( 'three', ParamTypes.string, required=True, multiple=False), ], ['one', 'two', 'three', 'four'], {}, ) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three', 'four'], {}, )) def test_options_property(self): self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', '3'], {}, )) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'three'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'four'], {}, ) def test_use_series_function_as_aggregator(self): # powSeries is a series function which is marked as a valid aggregator self.assertTrue( validateParams( 'TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['powSeries'], {}, )) # squareRoot is a series function which is not marked as a valid aggregator self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['squareRoot'], {}, ) def test_param_type_int_or_inf(self): self.assertTrue( validateParams( 'TestParam', [Param('param', ParamTypes.intOrInf)], [1], {}, )) self.assertTrue( validateParams( 'TestParam', [Param('param', ParamTypes.intOrInf)], [float('inf')], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', [Param('param', ParamTypes.intOrInf)], [1.2], {}, ) def test_default_value(self): # if no value is specified, but there is a default value, we don't # want the validator to raise an exception because 'None' is invalid self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.aggFunc, default='sum'), ], [], {}, ))
class TestParam(unittest.TestCase): params = [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True), ] def test_simple_args(self): self.assertTrue( validateParams( 'TestParam', self.params, ['arg1', 'arg2', 'arg3'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['arg1', 'arg2'], {}, ) def test_simple_kwargs(self): self.assertTrue( validateParams( 'TestParam', self.params, [], { 'one': '1', 'two': '2', 'three': '3' }, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'one': '1', 'two': '2', 'four': '4' }, ) def test_mixed_cases(self): self.assertTrue( validateParams( 'TestParam', self.params, ['one', 'two'], {'three': '3'}, )) self.assertTrue( validateParams( 'TestParam', self.params, ['one'], { 'three': '3', 'two': '2' }, )) # positional args don't check the name self.assertTrue( validateParams( 'TestParam', self.params, ['one', 'two', 'four'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, [], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'three'], {'two': '2'}, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['three'], { 'one': '1', 'two': '2' }, ) def test_repeated_args(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one'], { 'three': '3', 'one': '1' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two'], { 'three': '3', 'two': '2' }, ) self.assertRaises( InputParameterError, validateParams, 'TestParam', self.params, ['one', 'two', 'three'], {'one': '1'}, ) def test_multiple_property(self): self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param( 'three', ParamTypes.string, required=True, multiple=False), ], ['one', 'two', 'three', 'four'], {}, ) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, multiple=True), ], ['one', 'two', 'three', 'four'], {}, )) def test_options_property(self): self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', '3'], {}, )) self.assertTrue( validateParams( 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'three'], {}, )) self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('one', ParamTypes.string, required=True), Param('two', ParamTypes.string, required=True), Param('three', ParamTypes.string, required=True, options=['3', 'three']), ], ['one', 'two', 'four'], {}, ) def test_use_series_function_as_aggregator(self): # powSeries is a series function which is marked as a valid aggregator self.assertTrue( validateParams( 'TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['powSeries'], {}, )) # squareRoot is a series function which is not marked as a valid aggregator self.assertRaises( InputParameterError, validateParams, 'TestParam', [ Param('func', ParamTypes.aggOrSeriesFunc, required=True), ], ['squareRoot'], {}, )