rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/test/zxjdbc/runner.py

@@ -0,0 +1,204 @@
+
+# Jython Database Specification API 2.0
+#
+# $Id: runner.py 2094 2002-05-09 01:03:37Z bzimmer $
+#
+# Copyright (c) 2001 brian zimmer <bzimmer@ziclix.com>
+
+"""
+To run the tests, simply invoke this script from the commandline:
+
+ jython runner.py <xml config file> [vendor, ...]
+
+If no vendors are given, then all vendors will be tested.  If a
+vendor is given, then only that vendor will be tested.
+"""
+
+import unittest, os
+import xmllib, __builtin__, re
+
+def __imp__(module, attr=None):
+	if attr:
+		j = __import__(module, globals(), locals())
+		return getattr(j, attr)
+	else:
+		last = module.split(".")[-1]
+		return __import__(module, globals(), locals(), last)
+
+class Factory:
+	def __init__(self, classname, method):
+		self.classname = classname
+		self.method = method
+		self.arguments = []
+		self.keywords = {}
+
+class Testcase:
+	def __init__(self, frm, impt):
+		self.frm = frm
+		self.impt = impt
+		self.ignore = []
+
+class Test:
+	def __init__(self, name, os):
+		self.name = name
+		self.os = os
+		self.factory = None
+		self.tests = []
+
+class Vendor:
+	def __init__(self, name, datahandler=None):
+		self.name = name
+		self.scroll = None
+		self.datahandler = datahandler
+		self.tests = []
+		self.tables = {}
+
+class ConfigParser(xmllib.XMLParser):
+	"""
+	A simple XML parser for the config file.
+	"""
+	def __init__(self, **kw):
+		apply(xmllib.XMLParser.__init__, (self,), kw)
+		self.vendors = []
+		self.table_stack = []
+		self.re_var = re.compile(r"\${(.*?)}")
+
+	def vendor(self):
+		assert len(self.vendors) > 0, "no vendors"
+		return self.vendors[-1]
+
+	def test(self):
+		v = self.vendor()
+		assert len(v.tests) > 0, "no tests"
+		return v.tests[-1]
+
+	def factory(self):
+		c = self.test()
+		assert c.factory, "no factory"
+		return c.factory
+
+	def testcase(self):
+		s = self.test()
+		assert len(s.tests) > 0, "no testcases"
+		return s.tests[-1]
+
+	def value(self, value):
+		def repl(sub):
+			from java.lang import System
+			return System.getProperty(sub.group(1), sub.group(1))
+		value = self.re_var.sub(repl, value)
+		return value
+
+	def start_vendor(self, attrs):
+		if attrs.has_key('datahandler'):
+			v = Vendor(attrs['name'], attrs['datahandler'])
+		else:
+			v = Vendor(attrs['name'])
+		if attrs.has_key('scroll'):
+			v.scroll = attrs['scroll']
+		self.vendors.append(v)
+
+	def start_test(self, attrs):
+		v = self.vendor()
+		c = Test(attrs['name'], attrs['os'])
+		v.tests.append(c)
+
+	def start_factory(self, attrs):
+		c = self.test()
+		f = Factory(attrs['class'], attrs['method'])
+		c.factory = f
+
+	def start_argument(self, attrs):
+		f = self.factory()
+		if attrs.has_key('type'):
+			f.arguments.append((attrs['name'], getattr(__builtin__, attrs['type'])(self.value(attrs['value']))))
+		else:
+			f.arguments.append((attrs['name'], self.value(attrs['value'])))
+
+	def start_keyword(self, attrs):
+		f = self.factory()
+		if attrs.has_key('type'):
+			f.keywords[attrs['name']] = getattr(__builtin__, attrs['type'])(self.value(attrs['value']))
+		else:
+			f.keywords[attrs['name']] = self.value(attrs['value'])
+
+	def start_ignore(self, attrs):
+		t = self.testcase()
+		t.ignore.append(attrs['name'])
+
+	def start_testcase(self, attrs):
+		c = self.test()
+		c.tests.append(Testcase(attrs['from'], attrs['import']))
+
+	def start_table(self, attrs):
+		self.table_stack.append((attrs['ref'], attrs['name']))
+
+	def end_table(self):
+		del self.table_stack[-1]
+
+	def handle_data(self, data):
+		if len(self.table_stack):
+			ref, tabname = self.table_stack[-1]
+			self.vendor().tables[ref] = (tabname, data.strip())
+
+class SQLTestCase(unittest.TestCase):
+	"""
+	Base testing class.  It contains the list of table and factory information
+	to run any tests.
+	"""
+	def __init__(self, name, vendor, factory):
+		unittest.TestCase.__init__(self, name)
+		self.vendor = vendor
+		self.factory = factory
+		if self.vendor.datahandler:
+			self.datahandler = __imp__(self.vendor.datahandler)
+
+	def table(self, name):
+		return self.vendor.tables[name]
+
+	def has_table(self, name):
+		return self.vendor.tables.has_key(name)
+
+def make_suite(vendor, testcase, factory, mask=None):
+	clz = __imp__(testcase.frm, testcase.impt)
+	caseNames = filter(lambda x, i=testcase.ignore: x not in i, unittest.getTestCaseNames(clz, "test"))
+	if mask is not None:
+		caseNames = filter(lambda x, mask=mask: x == mask, caseNames)
+	tests = [clz(caseName, vendor, factory) for caseName in caseNames]
+	return unittest.TestSuite(tests)
+
+def test(vendors, include=None, mask=None):
+	for vendor in vendors:
+		if not include or vendor.name in include:
+			print
+			print "testing [%s]" % (vendor.name)
+			for test in vendor.tests:
+				if not test.os or test.os == os.name:
+					for testcase in test.tests:
+						suite = make_suite(vendor, testcase, test.factory, mask)
+						unittest.TextTestRunner().run(suite)
+		else:
+			print
+			print "skipping [%s]" % (vendor.name)
+
+if __name__ == '__main__':
+	import sys, getopt
+
+	try:
+		opts, args = getopt.getopt(sys.argv[1:], "t:", [])
+	except getopt.error, msg:
+		print "%s -t [testmask] <vendor>[,<vendor>]"
+		sys.exit(0)
+
+	mask = None
+	for a in opts:
+		opt, arg = a
+		if opt == '-t':
+			mask = arg
+
+	configParser = ConfigParser()
+	fp = open(args[0], "r")
+	configParser.feed(fp.read())
+	fp.close()
+	test(configParser.vendors, args[1:], mask=mask)
+	sys.exit(0)

data/lib/rubyfox/server/data/lib/Lib/test/zxjdbc/sptest.py

@@ -0,0 +1,227 @@
+
+# Jython Database Specification API 2.0
+#
+# $Id: sptest.py 2101 2002-05-10 16:11:41Z bzimmer $
+#
+# Copyright (c) 2001 brian zimmer <bzimmer@ziclix.com>
+
+from zxtest import zxCoreTestCase
+
+class OracleSPTest(zxCoreTestCase):
+
+	def setUp(self):
+		zxCoreTestCase.setUp(self)
+
+		c = self.cursor()
+
+		try:
+			try:
+				c.execute("drop table sptest")
+			except:
+				self.db.rollback()
+			try:
+				c.execute("create table sptest (x varchar2(20))")
+				c.execute("create or replace procedure procnone is begin insert into sptest values ('testing'); end;")
+				c.execute("create or replace procedure procin (y in varchar2) is begin insert into sptest values (y); end;")
+				c.execute("create or replace procedure procout (y out varchar2) is begin y := 'tested'; end;")
+				c.execute("create or replace procedure procinout (y out varchar2, z in varchar2) is begin insert into sptest values (z); y := 'tested'; end;")
+				c.execute("create or replace function funcnone return varchar2 is begin return 'tested'; end;")
+				c.execute("create or replace function funcin (y varchar2) return varchar2 is begin return y || y; end;")
+				c.execute("create or replace function funcout (y out varchar2) return varchar2 is begin y := 'tested'; return 'returned'; end;")
+				self.db.commit()
+			except:
+				self.db.rollback()
+				self.fail("procedure creation failed")
+
+			self.proc_errors("PROC")
+			self.proc_errors("FUNC")
+
+		finally:
+			c.close()
+
+	def tearDown(self):
+		zxCoreTestCase.tearDown(self)
+
+	def proc_errors(self, name):
+		c = self.cursor()
+		try:
+			c.execute("select * from user_errors where name like '%s%%'" % (name.upper()))
+			errors = c.fetchall()
+			try:
+				assert not errors, "found errors"
+			except AssertionError, e:
+				print "printing errors:"
+				for a in errors:
+					print a
+				raise e
+		finally:
+			c.close()
+
+	def testCursor(self):
+		c = self.cursor()
+		try:
+
+			c.execute("insert into sptest values ('a')")
+			c.execute("insert into sptest values ('b')")
+			c.execute("insert into sptest values ('c')")
+			c.execute("insert into sptest values ('d')")
+			c.execute("insert into sptest values ('e')")
+
+			c.execute("""
+				CREATE OR REPLACE PACKAGE types
+				AS
+					TYPE ref_cursor IS REF CURSOR;
+				END;
+			""")
+
+			c.execute("""
+				CREATE OR REPLACE FUNCTION funccur(v_x IN VARCHAR)
+					RETURN types.ref_cursor
+				AS
+					funccur_cursor types.ref_cursor;
+				BEGIN
+					OPEN funccur_cursor FOR
+						SELECT x FROM sptest WHERE x < v_x;
+					RETURN funccur_cursor;
+				END;
+			""")
+
+			self.proc_errors("funccur")
+
+			c.callproc("funccur", ("z",))
+			data = c.fetchall()
+			self.assertEquals(5, len(data))
+			c.callproc("funccur", ("c",))
+			data = c.fetchall()
+			self.assertEquals(2, len(data))
+
+		finally:
+			c.close()
+
+	def testProcin(self):
+		c = self.cursor()
+		try:
+			params = ["testProcin"]
+			c.callproc("procin", params)
+			self.assertEquals([], c.fetchall())
+			c.execute("select * from sptest")
+			self.assertEquals(1, len(c.fetchall()))
+		finally:
+			c.close()
+
+	def testProcinout(self):
+		c = self.cursor()
+		try:
+			params = [None, "testing"]
+			c.callproc("procinout", params)
+			data = c.fetchone()
+			assert data is None, "data was not None"
+			c.execute("select * from sptest")
+			data = c.fetchone()
+			self.assertEquals("testing", data[0])
+			self.assertEquals("tested", params[0])
+		finally:
+			c.close()
+
+	def testFuncnone(self):
+		c = self.cursor()
+		try:
+			c.callproc("funcnone")
+			data = c.fetchone()
+			assert data is not None, "data was None"
+			self.assertEquals(1, len(data))
+			self.assertEquals("tested", data[0])
+		finally:
+			c.close()
+
+	def testFuncin(self):
+		c = self.cursor()
+		try:
+			params = ["testing"]
+			c.callproc("funcin", params)
+			self.assertEquals(1, c.rowcount)
+			data = c.fetchone()
+			assert data is not None, "data was None"
+			self.assertEquals(1, len(data))
+			self.assertEquals("testingtesting", data[0])
+		finally:
+			c.close()
+
+	def testCallingWithKws(self):
+		c = self.cursor()
+		try:
+			params = ["testing"]
+			c.callproc("funcin", params=params)
+			self.assertEquals(1, c.rowcount)
+			data = c.fetchone()
+			assert data is not None, "data was None"
+			self.assertEquals(1, len(data))
+			self.assertEquals("testingtesting", data[0])
+		finally:
+			c.close()
+
+	def testFuncout(self):
+		c = self.cursor()
+		try:
+			params = [None]
+			c.callproc("funcout", params)
+			data = c.fetchone()
+			assert data is not None, "data was None"
+			self.assertEquals(1, len(data))
+			self.assertEquals("returned", data[0])
+			self.assertEquals("tested", params[0].strip())
+		finally:
+			c.close()
+
+	def testMultipleFetch(self):
+		"""testing the second fetch call to a callproc() is None"""
+		c = self.cursor()
+		try:
+			c.callproc("funcnone")
+			data = c.fetchone()
+			assert data is not None, "data was None"
+			data = c.fetchone()
+			assert data is None, "data was not None"
+		finally:
+			c.close()
+
+class SQLServerSPTest(zxCoreTestCase):
+
+	def testProcWithResultSet(self):
+		c = self.cursor()
+		try:
+			for a in (("table", "sptest"), ("procedure", "sp_proctest")):
+				try:
+					c.execute("drop %s %s" % (a))
+				except:
+					pass
+
+			c.execute("create table sptest (a int, b varchar(32))")
+			c.execute("insert into sptest values (1, 'hello')")
+			c.execute("insert into sptest values (2, 'there')")
+			c.execute("insert into sptest values (3, 'goodbye')")
+
+			c.execute(""" create procedure sp_proctest (@A int) as select a, b from sptest where a <= @A """)
+			self.db.commit()
+
+			c.callproc("sp_proctest", (2,))
+			data = c.fetchall()
+			self.assertEquals(2, len(data))
+			self.assertEquals(2, len(c.description))
+			assert c.nextset() is not None, "expected an additional result set"
+			data = c.fetchall()
+			self.assertEquals(1, len(data))
+			self.assertEquals(1, len(c.description))
+		finally:
+			c.close()
+
+#	def testSalesByCategory(self):
+#		c = self.cursor()
+#		try:
+#			c.execute("use northwind")
+#			c.callproc(("northwind", "dbo", "SalesByCategory"), ["Seafood", "1998"])
+#			data = c.fetchall()
+#			assert data is not None, "no results from SalesByCategory"
+#			assert len(data) > 0, "expected numerous results"
+#		finally:
+#			c.close()