home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_291 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.0 KB  |  475 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import re
  6.  
  7. try:
  8.     import cPickle
  9.     pickle = cPickle
  10. except ImportError:
  11.     import pickle
  12.  
  13. import unittest
  14. from test_all import db, dbtables, test_support, verbose, get_new_environment_path, get_new_database_path
  15.  
  16. class TableDBTestCase(unittest.TestCase):
  17.     db_name = 'test-table.db'
  18.     
  19.     def setUp(self):
  20.         import sys
  21.         if sys.version_info[0] >= 3:
  22.             do_proxy_db_py3k = do_proxy_db_py3k
  23.             import test_all
  24.             self._flag_proxy_db_py3k = do_proxy_db_py3k(False)
  25.         
  26.         self.testHomeDir = get_new_environment_path()
  27.         self.tdb = dbtables.bsdTableDB(filename = 'tabletest.db', dbhome = self.testHomeDir, create = 1)
  28.  
  29.     
  30.     def tearDown(self):
  31.         self.tdb.close()
  32.         import sys
  33.         if sys.version_info[0] >= 3:
  34.             do_proxy_db_py3k = do_proxy_db_py3k
  35.             import test_all
  36.             do_proxy_db_py3k(self._flag_proxy_db_py3k)
  37.         
  38.         test_support.rmtree(self.testHomeDir)
  39.  
  40.     
  41.     def test01(self):
  42.         tabname = 'test01'
  43.         colname = 'cool numbers'
  44.         
  45.         try:
  46.             self.tdb.Drop(tabname)
  47.         except dbtables.TableDBError:
  48.             pass
  49.  
  50.         self.tdb.CreateTable(tabname, [
  51.             colname])
  52.         import sys
  53.         if sys.version_info[0] < 3:
  54.             self.tdb.Insert(tabname, {
  55.                 colname: pickle.dumps(3.14159, 1) })
  56.         else:
  57.             self.tdb.Insert(tabname, {
  58.                 colname: pickle.dumps(3.14159, 1).decode('iso8859-1') })
  59.         if verbose:
  60.             self.tdb._db_print()
  61.         
  62.         values = self.tdb.Select(tabname, [
  63.             colname], conditions = {
  64.             colname: None })
  65.         import sys
  66.         if sys.version_info[0] < 3:
  67.             colval = pickle.loads(values[0][colname])
  68.         else:
  69.             colval = pickle.loads(bytes(values[0][colname], 'iso8859-1'))
  70.         self.assert_(colval > 3.141)
  71.         self.assert_(colval < 3.142)
  72.  
  73.     
  74.     def test02(self):
  75.         tabname = 'test02'
  76.         col0 = 'coolness factor'
  77.         col1 = 'but can it fly?'
  78.         col2 = 'Species'
  79.         import sys
  80.         if sys.version_info[0] < 3:
  81.             testinfo = [
  82.                 {
  83.                     col0: pickle.dumps(8, 1),
  84.                     col1: 'no',
  85.                     col2: 'Penguin' },
  86.                 {
  87.                     col0: pickle.dumps(-1, 1),
  88.                     col1: 'no',
  89.                     col2: 'Turkey' },
  90.                 {
  91.                     col0: pickle.dumps(9, 1),
  92.                     col1: 'yes',
  93.                     col2: 'SR-71A Blackbird' }]
  94.         else:
  95.             testinfo = [
  96.                 {
  97.                     col0: pickle.dumps(8, 1).decode('iso8859-1'),
  98.                     col1: 'no',
  99.                     col2: 'Penguin' },
  100.                 {
  101.                     col0: pickle.dumps(-1, 1).decode('iso8859-1'),
  102.                     col1: 'no',
  103.                     col2: 'Turkey' },
  104.                 {
  105.                     col0: pickle.dumps(9, 1).decode('iso8859-1'),
  106.                     col1: 'yes',
  107.                     col2: 'SR-71A Blackbird' }]
  108.         
  109.         try:
  110.             self.tdb.Drop(tabname)
  111.         except dbtables.TableDBError:
  112.             pass
  113.  
  114.         self.tdb.CreateTable(tabname, [
  115.             col0,
  116.             col1,
  117.             col2])
  118.         for row in testinfo:
  119.             self.tdb.Insert(tabname, row)
  120.         
  121.         import sys
  122.         if sys.version_info[0] < 3:
  123.             values = self.tdb.Select(tabname, [
  124.                 col2], conditions = {
  125.                 col0: (lambda x: pickle.loads(x) >= 8) })
  126.         else:
  127.             values = self.tdb.Select(tabname, [
  128.                 col2], conditions = {
  129.                 col0: (lambda x: pickle.loads(bytes(x, 'iso8859-1')) >= 8) })
  130.         self.assertEqual(len(values), 2)
  131.         if values[0]['Species'] == 'Penguin':
  132.             self.assertEqual(values[1]['Species'], 'SR-71A Blackbird')
  133.         elif values[0]['Species'] == 'SR-71A Blackbird':
  134.             self.assertEqual(values[1]['Species'], 'Penguin')
  135.         elif verbose:
  136.             print 'values= %r' % (values,)
  137.         
  138.         raise RuntimeError('Wrong values returned!')
  139.  
  140.     
  141.     def test03(self):
  142.         tabname = 'test03'
  143.         
  144.         try:
  145.             self.tdb.Drop(tabname)
  146.         except dbtables.TableDBError:
  147.             pass
  148.  
  149.         if verbose:
  150.             print '...before CreateTable...'
  151.             self.tdb._db_print()
  152.         
  153.         self.tdb.CreateTable(tabname, [
  154.             'a',
  155.             'b',
  156.             'c',
  157.             'd',
  158.             'e'])
  159.         if verbose:
  160.             print '...after CreateTable...'
  161.             self.tdb._db_print()
  162.         
  163.         self.tdb.Drop(tabname)
  164.         if verbose:
  165.             print '...after Drop...'
  166.             self.tdb._db_print()
  167.         
  168.         self.tdb.CreateTable(tabname, [
  169.             'a',
  170.             'b',
  171.             'c',
  172.             'd',
  173.             'e'])
  174.         
  175.         try:
  176.             self.tdb.Insert(tabname, {
  177.                 'a': '',
  178.                 'e': pickle.dumps([
  179.                     {
  180.                         4: 5,
  181.                         6: 7 },
  182.                     'foo'], 1),
  183.                 'f': 'Zero' })
  184.             self.fail('Expected an exception')
  185.         except dbtables.TableDBError:
  186.             pass
  187.  
  188.         
  189.         try:
  190.             self.tdb.Select(tabname, [], conditions = {
  191.                 'foo': '123' })
  192.             self.fail('Expected an exception')
  193.         except dbtables.TableDBError:
  194.             pass
  195.  
  196.         self.tdb.Insert(tabname, {
  197.             'a': '42',
  198.             'b': 'bad',
  199.             'c': 'meep',
  200.             'e': 'Fuzzy wuzzy was a bear' })
  201.         self.tdb.Insert(tabname, {
  202.             'a': '581750',
  203.             'b': 'good',
  204.             'd': 'bla',
  205.             'c': 'black',
  206.             'e': 'fuzzy was here' })
  207.         self.tdb.Insert(tabname, {
  208.             'a': '800000',
  209.             'b': 'good',
  210.             'd': 'bla',
  211.             'c': 'black',
  212.             'e': 'Fuzzy wuzzy is a bear' })
  213.         if verbose:
  214.             self.tdb._db_print()
  215.         
  216.         values = self.tdb.Select(tabname, [
  217.             'b',
  218.             'a',
  219.             'd'], conditions = {
  220.             'e': re.compile('wuzzy').search,
  221.             'a': re.compile('^[0-9]+$').match })
  222.         self.assertEqual(len(values), 2)
  223.         self.tdb.Delete(tabname, conditions = {
  224.             'b': dbtables.ExactCond('good') })
  225.         values = self.tdb.Select(tabname, [
  226.             'a',
  227.             'd',
  228.             'b'], conditions = {
  229.             'e': dbtables.PrefixCond('Fuzzy') })
  230.         self.assertEqual(len(values), 1)
  231.         self.assertEqual(values[0]['d'], None)
  232.         values = self.tdb.Select(tabname, [
  233.             'b'], conditions = {
  234.             'c': (lambda c: c == 'meep') })
  235.         self.assertEqual(len(values), 1)
  236.         self.assertEqual(values[0]['b'], 'bad')
  237.  
  238.     
  239.     def test04_MultiCondSelect(self):
  240.         tabname = 'test04_MultiCondSelect'
  241.         
  242.         try:
  243.             self.tdb.Drop(tabname)
  244.         except dbtables.TableDBError:
  245.             pass
  246.  
  247.         self.tdb.CreateTable(tabname, [
  248.             'a',
  249.             'b',
  250.             'c',
  251.             'd',
  252.             'e'])
  253.         
  254.         try:
  255.             self.tdb.Insert(tabname, {
  256.                 'a': '',
  257.                 'e': pickle.dumps([
  258.                     {
  259.                         4: 5,
  260.                         6: 7 },
  261.                     'foo'], 1),
  262.                 'f': 'Zero' })
  263.             self.fail('Expected an exception')
  264.         except dbtables.TableDBError:
  265.             pass
  266.  
  267.         self.tdb.Insert(tabname, {
  268.             'a': 'A',
  269.             'b': 'B',
  270.             'c': 'C',
  271.             'd': 'D',
  272.             'e': 'E' })
  273.         self.tdb.Insert(tabname, {
  274.             'a': '-A',
  275.             'b': '-B',
  276.             'c': '-C',
  277.             'd': '-D',
  278.             'e': '-E' })
  279.         self.tdb.Insert(tabname, {
  280.             'a': 'A-',
  281.             'b': 'B-',
  282.             'c': 'C-',
  283.             'd': 'D-',
  284.             'e': 'E-' })
  285.         if verbose:
  286.             self.tdb._db_print()
  287.         
  288.         values = self.tdb.Select(tabname, [
  289.             'b',
  290.             'a',
  291.             'd'], conditions = {
  292.             'e': dbtables.ExactCond('E'),
  293.             'a': dbtables.ExactCond('A'),
  294.             'd': dbtables.PrefixCond('-') })
  295.         self.assertEqual(len(values), 0, values)
  296.  
  297.     
  298.     def test_CreateOrExtend(self):
  299.         tabname = 'test_CreateOrExtend'
  300.         self.tdb.CreateOrExtendTable(tabname, [
  301.             'name',
  302.             'taste',
  303.             'filling',
  304.             'alcohol content',
  305.             'price'])
  306.         
  307.         try:
  308.             self.tdb.Insert(tabname, {
  309.                 'taste': 'crap',
  310.                 'filling': 'no',
  311.                 'is it Guinness?': 'no' })
  312.             self.fail("Insert should've failed due to bad column name")
  313.         except:
  314.             pass
  315.  
  316.         self.tdb.CreateOrExtendTable(tabname, [
  317.             'name',
  318.             'taste',
  319.             'is it Guinness?'])
  320.         self.tdb.Insert(tabname, {
  321.             'taste': 'crap',
  322.             'filling': 'no',
  323.             'is it Guinness?': 'no' })
  324.         self.tdb.Insert(tabname, {
  325.             'taste': 'great',
  326.             'filling': 'yes',
  327.             'is it Guinness?': 'yes',
  328.             'name': 'Guinness' })
  329.  
  330.     
  331.     def test_CondObjs(self):
  332.         tabname = 'test_CondObjs'
  333.         self.tdb.CreateTable(tabname, [
  334.             'a',
  335.             'b',
  336.             'c',
  337.             'd',
  338.             'e',
  339.             'p'])
  340.         self.tdb.Insert(tabname, {
  341.             'a': 'the letter A',
  342.             'b': 'the letter B',
  343.             'c': 'is for cookie' })
  344.         self.tdb.Insert(tabname, {
  345.             'a': 'is for aardvark',
  346.             'e': 'the letter E',
  347.             'c': 'is for cookie',
  348.             'd': 'is for dog' })
  349.         self.tdb.Insert(tabname, {
  350.             'a': 'the letter A',
  351.             'e': 'the letter E',
  352.             'c': 'is for cookie',
  353.             'p': 'is for Python' })
  354.         values = self.tdb.Select(tabname, [
  355.             'p',
  356.             'e'], conditions = {
  357.             'e': dbtables.PrefixCond('the l') })
  358.         self.assertEqual(len(values), 2, values)
  359.         self.assertEqual(values[0]['e'], values[1]['e'], values)
  360.         self.assertNotEqual(values[0]['p'], values[1]['p'], values)
  361.         values = self.tdb.Select(tabname, [
  362.             'd',
  363.             'a'], conditions = {
  364.             'a': dbtables.LikeCond('%aardvark%') })
  365.         self.assertEqual(len(values), 1, values)
  366.         self.assertEqual(values[0]['d'], 'is for dog', values)
  367.         self.assertEqual(values[0]['a'], 'is for aardvark', values)
  368.         values = self.tdb.Select(tabname, None, {
  369.             'b': dbtables.Cond(),
  370.             'e': dbtables.LikeCond('%letter%'),
  371.             'a': dbtables.PrefixCond('is'),
  372.             'd': dbtables.ExactCond('is for dog'),
  373.             'c': dbtables.PrefixCond('is for'),
  374.             'p': (lambda s: not s) })
  375.         self.assertEqual(len(values), 1, values)
  376.         self.assertEqual(values[0]['d'], 'is for dog', values)
  377.         self.assertEqual(values[0]['a'], 'is for aardvark', values)
  378.  
  379.     
  380.     def test_Delete(self):
  381.         tabname = 'test_Delete'
  382.         self.tdb.CreateTable(tabname, [
  383.             'x',
  384.             'y',
  385.             'z'])
  386.         self.tdb.Insert(tabname, {
  387.             'x': 'X1',
  388.             'y': 'Y1' })
  389.         self.tdb.Insert(tabname, {
  390.             'x': 'X2',
  391.             'y': 'Y2',
  392.             'z': 'Z2' })
  393.         self.tdb.Delete(tabname, conditions = {
  394.             'x': dbtables.PrefixCond('X') })
  395.         values = self.tdb.Select(tabname, [
  396.             'y'], conditions = {
  397.             'x': dbtables.PrefixCond('X') })
  398.         self.assertEqual(len(values), 0)
  399.  
  400.     
  401.     def test_Modify(self):
  402.         tabname = 'test_Modify'
  403.         self.tdb.CreateTable(tabname, [
  404.             'Name',
  405.             'Type',
  406.             'Access'])
  407.         self.tdb.Insert(tabname, {
  408.             'Name': 'Index to MP3 files.doc',
  409.             'Type': 'Word',
  410.             'Access': '8' })
  411.         self.tdb.Insert(tabname, {
  412.             'Name': 'Nifty.MP3',
  413.             'Access': '1' })
  414.         self.tdb.Insert(tabname, {
  415.             'Type': 'Unknown',
  416.             'Access': '0' })
  417.         
  418.         def set_type(type):
  419.             if type == None:
  420.                 return 'MP3'
  421.             return type
  422.  
  423.         
  424.         def increment_access(count):
  425.             return str(int(count) + 1)
  426.  
  427.         
  428.         def remove_value(value):
  429.             pass
  430.  
  431.         self.tdb.Modify(tabname, conditions = {
  432.             'Access': dbtables.ExactCond('0') }, mappings = {
  433.             'Access': remove_value })
  434.         self.tdb.Modify(tabname, conditions = {
  435.             'Name': dbtables.LikeCond('%MP3%') }, mappings = {
  436.             'Type': set_type })
  437.         self.tdb.Modify(tabname, conditions = {
  438.             'Name': dbtables.LikeCond('%') }, mappings = {
  439.             'Access': increment_access })
  440.         
  441.         try:
  442.             self.tdb.Modify(tabname, conditions = {
  443.                 'Name': dbtables.LikeCond('%') }, mappings = {
  444.                 'Access': 'What is your quest?' })
  445.         except TypeError:
  446.             pass
  447.  
  448.         raise RuntimeError, 'why was TypeError not raised for bad callable?'
  449.         values = self.tdb.Select(tabname, None, conditions = {
  450.             'Type': dbtables.ExactCond('Unknown') })
  451.         self.assertEqual(len(values), 1, values)
  452.         self.assertEqual(values[0]['Name'], None, values)
  453.         self.assertEqual(values[0]['Access'], None, values)
  454.         values = self.tdb.Select(tabname, None, conditions = {
  455.             'Name': dbtables.ExactCond('Nifty.MP3') })
  456.         self.assertEqual(len(values), 1, values)
  457.         self.assertEqual(values[0]['Type'], 'MP3', values)
  458.         self.assertEqual(values[0]['Access'], '2', values)
  459.         values = self.tdb.Select(tabname, None, conditions = {
  460.             'Name': dbtables.LikeCond('%doc%') })
  461.         self.assertEqual(len(values), 1, values)
  462.         self.assertEqual(values[0]['Type'], 'Word', values)
  463.         self.assertEqual(values[0]['Access'], '9', values)
  464.  
  465.  
  466.  
  467. def test_suite():
  468.     suite = unittest.TestSuite()
  469.     suite.addTest(unittest.makeSuite(TableDBTestCase))
  470.     return suite
  471.  
  472. if __name__ == '__main__':
  473.     unittest.main(defaultTest = 'test_suite')
  474.  
  475.