pyUnit and dynamic test functions

[Sakcee]

Hi

I am trying to use pyUnit to create a framework for testing functions

I am reading function name, expected output, from a text file.
and in python generating dynamic test functions
something like this

class getUsStatesTest( unittest.TestCase ):

self.setUp = lambda : function_call
self.testReturnVal = lambda : self.assertEqual( fileInput,
function_returnedVals )
self.testLength = lambda : self.assertEqual( len(returnedVals)
, len(inp) )

is it possible to load these dynamic functions via pyUnit, instead of
defining in text form ,
can i use loadfromname etc to load these dynamic test functions.

something like this

unittest.TestSuite(unittest.defaultTestLoader.loadTestsFromName(
getUsStatesTest() ))

in this way I can completely automate every function that returns some
output by dynamically generating its
test functions

thanks

[Sakcee]

Please anyone help, is this kind of dynamin thing possible? any
suggestion for creating frameworks for automated testing ,

all comments appreciated

thanks

[Kent Johnson]

Sakcee wrote:
> Hi
>
> I am trying to use pyUnit to create a framework for testing functions
>
> I am reading function name, expected output, from a text file.

Can you show a sample of what the text file might look like, and what tests you want to
generate from it?

> and in python generating dynamic test functions
> something like this
>
>
> class getUsStatesTest( unittest.TestCase ):
>
> self.setUp = lambda : function_call
> self.testReturnVal = lambda : self.assertEqual( fileInput,
> function_returnedVals )
> self.testLength = lambda : self.assertEqual( len(returnedVals)
> , len(inp) )

I don't understand the above at all. What do function_call, function_returnedVals,
returnedVals and inp refer to? What is the point of the lambdas and the assignment to
attributes of (undefined) self?

Kent

[Sakcee]

Thanks for reply, here is the script with trucated datafile

The data file is following ,

--- data file--------
getUSStates~~dict~
{AK: Alaska,
AL: Alabama,
AR: Arkansas,
AZ: Arizona,
CA: California,
CO: Colorado,
....
....
WY: Wyoming }
----data file--------

I want to test function:getUSStates that takes input none and outputs a
dict
of us states.the first line shows function
name~input~output_format~expected_output

Now I have following class and loadTestInfoFromFile function for
loading the values for file and assinging the data to self.outputOfFunc
etc

class getUsStates( unittest.TestCase ):

func_name = None
inputToFunc = None
outputOfFunc = None
outputType = None

setup = None
testUsStates = None
testLength = None

def loadTestInfoFromFile(self):
""" read function name, input to function, output format
and output from file"""

rest = file('data.txt').read()
self.func_name , self.inputToFunc,
self.outputType,outputOfFuncRaw = rest.split("~")

if self.outputType == 'dict':
outputOfFuncRaw = outputOfFuncRaw.split(",")
self.outputOfFunc = {}

for i in range(0,len(outputOfFuncRaw)):
li= ( (outputOfFuncRaw[i].strip()).replace('}','')
).split(':')
self.outputOfFunc[li[0]]=li[1]

def buildTestFunctions( self, returnedVals, func_name, inp ):

self.testReturnVal = lambda : self.assertEqual( inp,

returnedVals )
self.testLength = lambda : self.assertEqual(
len(returnedVals) , len(inp) )

def runFunction():
g = getUsStatesTest()
g.loadTestInfoFromFile()
g.buildFunctions(g.returnedVals,g.func_name,g.outputOfFunc)

if __name__ == "__main__":
unittest.main(defaultTest="runFunction")

Now in the buildTestFunctions() I want to setup 2 unittest test
function that do assertEqual
so that I have 2 functions which are dynamically created from file ,
now I want to associate
these function with unittest and run them.

the above runs correctly reads the data and make 2 funcitons
testReturnVal and testLength
but then I want to associate those funcitons to unittest. and run unit
test but that part i dont
know how to do.

in this way I can define 100 functions with inputs and expected outputs
in a data file
and this type of script will generate similar assert functions for all
of them on fly
and run them

thanks for any input or any alternate approach to it

[Fabrizio Milo]

> thanks for any input or any alternate approach to it

I think that your approach is not fair.

You should create a TestCase for each of your data input, add it to a TestSuite
and run the test suite.

Here is a stub for loading just a 'dict' type, hoping it is helpful

import unittest
import glob
from string import split,strip

def getUSStates(*args):
#Fake
return {'AK:': 'Alaska', 'CA:': 'California', 'AR:': 'Arkansas',
'CO:': 'Colorado', 'WY:': 'Wyoming', 'AZ:': 'Arizona', 'AL:':
'Alabama'}

class TestStubException( Exception ):
'''
Test case creation failed.
'''

class TestStub( unittest.TestCase ):

def __init__( self, fname, farg, t_out, out ):
unittest.TestCase.__init__(self,'testRun')
self.fname = eval(fname,globals())
self.input = farg
self.fparse = getattr(self,'load_%s' % t_out)
self.output = self.fparse( out )

def load_dict(self,data):
assert data[0] is '{', 'Wrong dict format %s' % data
assert data[-1] is '}', 'Wrong dict format %s' % data
items = data[1:-1].split(',')
return dict( map( split, map( strip, items ) ) )

def testRun(self):
self.assertEquals( self.fname(self.input), self.output )

def build_tests( filename ):
try:
fd = open( filename, 'r')
tc = TestStub( *fd.read().split("~") )
del fd
return tc
except:
import traceback; traceback.print_exc()
raise TestStubException( 'Failed creating test case from file
: %s'%filename )

if __name__== '__main__':

tc_data = glob.glob('*.txt') # all text files with data

ts = unittest.TestSuite()

for tc_file in tc_data:
ts.addTest( build_tests( tc_file ) )

unittest.TextTestRunner().run(ts)

Fabrizio Milo aka Misto

[Sakcee]

Excellent , your example is elegant and runs beautifully

so the idea is to create a testcase which runs a general function
"testRun" (which calls the function defined in file )and loads data
based on type ,

add this testcase to suite and run suite.

thanks , this is exactly what I was looking for.