def test_parse_text_generator(self): """ Test the text generator parsing """ config = dict() config['type'] = 'random_text' config['character_set'] = 'reallyINVALID' try: gen = generators.parse_generator(config) self.fail( "Should never parse an invalid character_set successfully, but did!" ) except ValueError: pass # Test for character set handling for charset in generators.CHARACTER_SETS: try: config['character_set'] = charset gen = generators.parse_generator(config) myset = set(generators.CHARACTER_SETS[charset]) for x in xrange(0, 50): val = gen.next() self.assertTrue(set(val).issubset(set(myset))) except Exception, e: print 'Exception occurred with charset: ' + charset raise e
def test_parse_text_generator(self): """ Test the text generator parsing """ config = dict() config['type'] = 'random_text' config['character_set'] = 'reallyINVALID' try: gen = generators.parse_generator(config) self.fail( "Should never parse an invalid character_set successfully, but did!" ) except ValueError: pass # Test for character set handling for charset in generators.CHARACTER_SETS: try: config['character_set'] = charset gen = generators.parse_generator(config) myset = set(generators.CHARACTER_SETS[charset]) for x in xrange(0, 50): val = gen.next() self.assertTrue(set(val).issubset(set(myset))) except Exception as e: print('Exception occurred with charset: ' + charset) raise e my_min = 1 my_max = 10 # Test for explicit character setting del config['character_set'] temp_chars = 'ay78%&' config['characters'] = temp_chars gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: set(x).issubset(set(temp_chars))) # Test for length setting config['length'] = '3' gen = generators.parse_generator(config) self.generator_basic_test(gen, value_test_function=lambda x: len(x) == 3) del config['length'] # Test for explicit min/max length config['min_length'] = '9' config['max_length'] = 12 gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: len(x) >= 9 and len(x) <= 12)
def test_parse_text_generator(self): """ Test the text generator parsing """ config = dict() config['type'] = 'random_text' config['character_set'] = 'reallyINVALID' try: gen = generators.parse_generator(config) self.fail( "Should never parse an invalid character_set successfully, but did!") except ValueError: pass # Test for character set handling for charset in generators.CHARACTER_SETS: try: config['character_set'] = charset gen = generators.parse_generator(config) myset = set(generators.CHARACTER_SETS[charset]) for x in xrange(0, 50): val = next(gen) self.assertTrue(set(val).issubset(set(myset))) except Exception as e: print('Exception occurred with charset: ' + charset) raise e my_min = 1 my_max = 10 # Test for explicit character setting del config['character_set'] temp_chars = 'ay78%&' config['characters'] = temp_chars gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: set(x).issubset(set(temp_chars))) # Test for length setting config['length'] = '3' gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: len(x) == 3) del config['length'] # Test for explicit min/max length config['min_length'] = '9' config['max_length'] = 12 gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: len(x) >= 9 and len(x) <= 12)
def parse_configuration(node, base_config=None): """ Parse input config to configuration information """ test_config = base_config if not test_config: test_config = TestConfig() node = lowercase_keys(flatten_dictionaries(node)) # Make it usable for key, value in node.items(): if key == u'timeout': test_config.timeout = int(value) elif key == u'print_bodies': test_config.print_bodies = safe_to_bool(value) elif key == u'retries': test_config.retries = int(value) elif key == u'variable_binds': if not test_config.variable_binds: test_config.variable_binds = dict() test_config.variable_binds.update(flatten_dictionaries(value)) elif key == u'generators': flat = flatten_dictionaries(value) gen_map = dict() for generator_name, generator_config in flat.items(): gen = parse_generator(generator_config) gen_map[str(generator_name)] = gen test_config.generators = gen_map return test_config
def test_parse_basic(self): """ Test basic parsing, simple cases that should succeed or throw known errors """ config = {'type': 'unsupported'} try: gen = generators.parse_generator(config) self.fail( "Expected failure due to invalid generator type, did not emit it" ) except ValueError: pass # Try creating a random_int generator config['type'] = 'random_int' gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: isinstance(x, int)) self.generator_repeat_test(gen) # Sample variable os.environ['SAMPLEVAR'] = 'goober' config['type'] = 'env_variable' config['variable_name'] = 'SAMPLEVAR' gen = generators.parse_generator(config) self.generator_basic_test(gen) del config['variable_name'] config['type'] = 'env_string' config['string'] = '$SAMPLEVAR' gen = generators.parse_generator(config) self.generator_basic_test(gen) del config['string'] config['type'] = 'number_sequence' config['start'] = '1' config['increment'] = '10' gen = generators.parse_generator(config) self.assertEqual(1, next(gen)) self.assertEqual(11, next(gen)) self.generator_basic_test(gen) del config['type']
def test_parse_basic(self): """ Test basic parsing, simple cases that should succeed or throw known errors """ config = {'type': 'unsupported'} try: gen = generators.parse_generator(config) self.fail( "Expected failure due to invalid generator type, did not emit it") except ValueError: pass # Try creating a random_int generator config['type'] = 'random_int' gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: isinstance(x, int)) self.generator_repeat_test(gen) # Sample variable os.environ['SAMPLEVAR'] = 'goober' config['type'] = 'env_variable' config['variable_name'] = 'SAMPLEVAR' gen = generators.parse_generator(config) self.generator_basic_test(gen) del config['variable_name'] config['type'] = 'env_string' config['string'] = '$SAMPLEVAR' gen = generators.parse_generator(config) self.generator_basic_test(gen) del config['string'] config['type'] = 'number_sequence' config['start'] = '1' config['increment'] = '10' gen = generators.parse_generator(config) self.assertEqual(1, next(gen)) self.assertEqual(11, next(gen)) self.generator_basic_test(gen) del config['type']
def test_parse_text_generator(self): """ Test the text generator parsing """ config = dict() config['type'] = 'random_text' config['character_set'] = 'reallyINVALID' try: gen = generators.parse_generator(config) self.fail("Should never parse an invalid character_set successfully, but did!") except ValueError: pass # Test for character set handling for charset in generators.CHARACTER_SETS: try: config['character_set'] = charset gen = generators.parse_generator(config) myset = set(generators.CHARACTER_SETS[charset]) for x in xrange(0, 50): val = gen.next() self.assertTrue(set(val).issubset(set(myset))) except Exception, e: print 'Exception occurred with charset: '+charset raise e
def test_parse_choice_generatpr(self): vals = ['moobie', 'moby', 'moo'] config = {'type': 'choice', 'values': vals} gen = generators.parse_generator(config) self.generator_basic_test(gen, lambda x: x in vals)
def test_parse_fixed_sequence(self): vals = ['moobie', 'moby', 'moo'] config = {'type': 'fixed_sequence', 'values': vals} gen = generators.parse_generator(config) self.generator_basic_test(gen, lambda x: x in vals)
class GeneratorTest(unittest.TestCase): """ Tests for generators """ def generator_basic_test(self, generator, value_test_function=None): """ Basic test for a generator, checks values and applies test function """ self.assertTrue(isinstance(generator, types.GeneratorType)) for x in xrange(0, 100): val = generator.next() self.assertTrue(val is not None) if value_test_function: self.assertTrue(value_test_function(val), 'Test failed with value {0}'.format(val)) def generator_repeat_test(self, generator_input): """ Basic test of a configured generator """ val = generator_input.next() # Check for not repeating easily for x in xrange(0, 5): val2 = generator_input.next() self.assertTrue(val) self.assertTrue(val != val2) val = val2 def test_factory_ids(self): f = generators.factory_generate_ids(1)() f2 = generators.factory_generate_ids(101)() f3 = generators.factory_generate_ids(1)() vals = [f.next(), f.next()] vals2 = [f2.next(), f2.next()] vals3 = [f3.next(), f3.next()] self.assertEqual(1, vals[0]) self.assertEqual(2, vals[1]) self.assertEqual(101, vals2[0]) self.assertEqual(102, vals2[1]) # Check for accidental closure self.assertEqual(1, vals3[0]) self.assertEqual(2, vals3[1]) def test_basic_ids(self): """ Test starting ids """ ids1 = generators.generator_basic_ids() ids2 = generators.generator_basic_ids() self.generator_repeat_test(ids1) self.generator_repeat_test(ids2) self.assertEqual(ids1.next(), ids2.next()) def test_random_ids(self): """ Test random in ids generator """ gen = generators.generator_random_int32() print gen.next() self.generator_repeat_test(gen) def test_system_variables(self): """ Test generator for binding system variables """ variable = 'FOOBARBAZ' value = 'myTestVal' old_val = os.environ.get(variable) generator = generators.factory_env_variable(variable)() self.assertTrue(generator.next() is None) os.environ[variable] = value self.assertEqual(value, generator.next()) self.assertEqual(generator.next(), os.path.expandvars('$' + variable)) # Restore environment if old_val is not None: os.environ[variable] = old_val else: del os.environ[variable] def test_factory_text(self): """ Test the basic generator """ charsets = [ string.letters, string.digits, string.uppercase, string.hexdigits ] # Test multiple charsets and string lengths for charset in charsets: # Test different lengths for charset for my_length in xrange(1, 17): gen = generators.factory_generate_text( legal_characters=charset, min_length=my_length, max_length=my_length)() for x in xrange(0, 10): val = gen.next() self.assertEqual(my_length, len(val)) def test_factory_sequence(self): """ Tests linear sequences """ vals = [1] gen = generators.factory_fixed_sequence(vals)() self.generator_basic_test(gen, lambda x: x in vals) vals = ['moobie', 'moby', 'moo'] gen = generators.factory_fixed_sequence(vals)() self.generator_basic_test(gen, lambda x: x in vals) vals = {'a', 'b', 'c'} gen = generators.factory_fixed_sequence(vals)() self.generator_basic_test(gen, lambda x: x in vals) def test_parse_fixed_sequence(self): vals = ['moobie', 'moby', 'moo'] config = {'type': 'fixed_sequence', 'values': vals} gen = generators.parse_generator(config) self.generator_basic_test(gen, lambda x: x in vals) def test_factory_choice(self): """ Tests linear sequences """ vals = [1] gen = generators.factory_choice_generator(vals)() self.generator_basic_test(gen, lambda x: x in vals) vals = ['moobie', 'moby', 'moo'] gen = generators.factory_choice_generator(vals)() self.generator_basic_test(gen, lambda x: x in vals) vals = {'a', 'b', 'c'} gen = generators.factory_choice_generator(vals)() self.generator_basic_test(gen, lambda x: x in vals) def test_parse_choice_generatpr(self): vals = ['moobie', 'moby', 'moo'] config = {'type': 'choice', 'values': vals} gen = generators.parse_generator(config) self.generator_basic_test(gen, lambda x: x in vals) def test_factory_text_multilength(self): """ Test that the random text generator can handle multiple lengths """ gen = generators.factory_generate_text(legal_characters='abcdefghij', min_length=1, max_length=100)() lengths = set() for x in xrange(0, 100): lengths.add(len(gen.next())) self.assertTrue( len(lengths) > 1, "Variable length string generator did not generate multiple string lengths" ) def test_character_sets(self): """ Verify all charsets are valid """ sets = generators.CHARACTER_SETS for key, value in sets.items(): self.assertTrue(value) def test_parse_text_generator(self): """ Test the text generator parsing """ config = dict() config['type'] = 'random_text' config['character_set'] = 'reallyINVALID' try: gen = generators.parse_generator(config) self.fail( "Should never parse an invalid character_set successfully, but did!" ) except ValueError: pass # Test for character set handling for charset in generators.CHARACTER_SETS: try: config['character_set'] = charset gen = generators.parse_generator(config) myset = set(generators.CHARACTER_SETS[charset]) for x in xrange(0, 50): val = gen.next() self.assertTrue(set(val).issubset(set(myset))) except Exception, e: print 'Exception occurred with charset: ' + charset raise e my_min = 1 my_max = 10 # Test for explicit character setting del config['character_set'] temp_chars = 'ay78%&' config['characters'] = temp_chars gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: set(x).issubset(set(temp_chars))) # Test for length setting config['length'] = '3' gen = generators.parse_generator(config) self.generator_basic_test(gen, value_test_function=lambda x: len(x) == 3) del config['length'] # Test for explicit min/max length config['min_length'] = '9' config['max_length'] = 12 gen = generators.parse_generator(config) self.generator_basic_test( gen, value_test_function=lambda x: len(x) >= 9 and len(x) <= 12)