Example #1
0
 def test_DBConnectedObject_queries(self):
     self.test_targets.append(database_f.DBConnectedObject.insert)
     self.test_targets.append(database_f.DBConnectedObject.update)
     self.test_targets.append(database_f.DBConnectedObject.delete)
     
     # First we insert it
     fc = FakeConnected({
         "s1":   1,
         "v1":   "abc",
         "v2":   "xyz",
         "i1":   1,
         "i2":   2,
         "t1":   "abc abc",
         "t2":   "xyz xyz",
         
         "b1":   True,
         
         "afield":   [1,2,3],
         "bfield":   [1,2,3],
         
         "date_field":   common_f.convert_date("01-08-1999"),
         "time_field":   common_f.convert_date("01-08-1999 04:05:06"),
     })
     
     self.assertEqual(fc.insert(test_mode=True), [
         'INSERT INTO fake_connected ("v1", "v2", "i1", "i2", "t1", "t2", "d1", "b1", "afield", "bfield", "date_field", "time_field") VALUES (\'abc\', \'xyz\', \'1\', \'2\', \'abc abc\', \'xyz xyz\', \'1.1\', \'True\', \'{1,2,3}\', \'{1,2,3}\', \'1999-08-01\', \'1999-08-01 04:05:06\');'
     ])
     
     # Now we update it
     fc.v1 = "zzz"
     self.assertEqual(fc.update(test_mode=True), [
         "UPDATE fake_connected SET v1 = 'zzz',v2 = 'xyz',i1 = '1',i2 = '2',t1 = 'abc abc',t2 = 'xyz xyz',d1 = '1.1',b1 = 'True',afield = '{1, 2, 3}',bfield = '{1, 2, 3}',date_field = '1999-08-01',time_field = '1999-08-01 04:05:06' WHERE s1 = 1;"
     ])
     
     # Test for partial update
     del(fc.i1)
     del(fc.i2)
     del(fc.t1)
     del(fc.t2)
     del(fc.d1)
     del(fc.afield)
     del(fc.bfield)
     del(fc.b1)
     del(fc.date_field)
     del(fc.time_field)
     self.assertEqual(fc.update(test_mode=True), [
         "UPDATE fake_connected SET v1 = 'zzz',v2 = 'xyz' WHERE s1 = 1;"
     ])
     
     # Finally we kill it
     self.assertEqual(fc.delete(test_mode=True), [
         'DELETE FROM fake_connected WHERE s1 = 1;'
     ])
Example #2
0
 def test_convert_date(self):
     self.test_targets.append(common_f.convert_date)
     this_year = datetime.date.today().year
     
     vals = (
         # Two sections
         ("01-02", datetime.date(this_year, 2, 1)),
         ("01/03", datetime.date(this_year, 3, 1)),
         ("01 04", datetime.date(this_year, 4, 1)),
         
         ("11-12", datetime.date(this_year, 12, 11)),
         ("21/10", datetime.date(this_year, 10, 21)),
         ("30 11", datetime.date(this_year, 11, 30)),
         
         # Three sections
         ("01-02-10", datetime.date(2010, 2, 1)),
         ("01/03-11", datetime.date(2011, 3, 1)),
         ("01 04-12", datetime.date(2012, 4, 1)),
         
         ("11-12-2010", datetime.date(2010, 12, 11)),
         ("21/10-2011", datetime.date(2011, 10, 21)),
         ("30 11-2012", datetime.date(2012, 11, 30)),
     )
     
     for str_in, expected in vals:
         answer = common_f.convert_date(str_in)
         self.assertEqual(answer, expected)
Example #3
0
 def validate(self, value):
     if type(value) == str:
         v = common_f.convert_date(value)
         
         if v == None:
             raise Exception("Could not convert input '{}'".format(value))
         value = v
     
     if type(value) == datetime.datetime:
         return value
     
     if type(value) == datetime.date:
         return datetime.datetime(value.year, value.month, value.day)
     
     if type(value) in (int, float):
         return datetime.datetime.fromtimestamp(value)
     
     raise Exception("No handler for type '{}'" % type(value))
Example #4
0
    def test_DBConnectedObject_creation(self):
        self.test_targets.append(database_f.DBConnectedObject.__eq__)
        self.test_targets.append(database_f.DBConnectedObject.__str__)
        self.test_targets.append(database_f.DBConnectedObject.compare)
        self.test_targets.append(database_f.DBConnectedObject.get_from_form)
        self.test_targets.append(database_f.DBConnectedObject.get_from_dict)
        
        f1 = FakeConnected({
            "s1":   1,
            "v1":   "abc",
            "v2":   "xyz",
            "i1":   1,
            "i2":   2,
            "t1":   "abc abc",
            "t2":   "xyz xyz",
            
            "d1":   1.1,
            "b1":   False,
            
            "afield":   [1,2,3],
            "bfield":   [1,2,3],
            
            # This uses strings
            "date_field":   common_f.convert_date("08-01-1999"),
            "time_field":   common_f.convert_date("08-01-1999 04:05:06"),
        })
        
        f2 = FakeConnected({
            "s1":   2,
            "v1":   "zabc",
            "v2":   "zxyz",
            "i1":   3,
            "i2":   4,
            "t1":   "zabc abc",
            "t2":   "zxyz xyz",
            
            "d1":   1.2,
            "b1":   True,
            
            "afield":   [4,2,3],
            "bfield":   [1,2,3],
            
            # This uses strings too
            "date_field":   common_f.convert_date("20-02-2000"),
            "time_field":   common_f.convert_date("20-02-2000 23:59:59"),
        })
        
        gui_test_utils.new_cgi_form((
            ("s1",   2),
            ("v1",   "zabc"),
            ("v2",   "zxyz"),
            ("i1",   3),
            ("i2",   4),
            ("t1",   "zabc abc"),
            ("t2",   "zxyz xyz"),
            
            ("d1",   1.2),
            ("b1",   True),
            
            ("afield",   "[4,2,3]"),
            ("bfield",   "[1,2,3]"),
            
            # This convets strings
            ("date_field",   datetime.date(2000, 2, 20)),
            ("time_field",   datetime.datetime(year=2000, month=2, day=20, hour=23, minute=59, second=59)),
        ))
        
        f3 = FakeConnected()
        f3.get_from_form(cursor=None, form_list=common_f.cgi_form.list)
        
        # Test __eq__
        self.assertNotEqual(f1, f2)
        if f2 != f3:
            print(f2.compare(f3))
            self.assertEqual(f2, f3)
        
        # Test __str__
        self.assertEqual(str(f1), """s1: 1
v1: abc
v2: xyz
i1: 1
i2: 2
t1: abc abc
t2: xyz xyz
d1: 1.1
b1: False
afield: [1, 2, 3]
bfield: [1, 2, 3]
date_field: 1999-01-08
time_field: 1999-01-08 04:05:06""")
        
        self.assertEqual(str(f2), """s1: 2
v1: zabc
v2: zxyz
i1: 3
i2: 4
t1: zabc abc
t2: zxyz xyz
d1: 1.2
b1: True
afield: [4, 2, 3]
bfield: [1, 2, 3]
date_field: 2000-02-20
time_field: 2000-02-20 23:59:59""")
        
        self.assertEqual(str(f3), str(f2))
        
        # Test compare
        self.assertEqual(f2.compare(f3), "")
        self.assertEqual(f1.compare(f2), """s1 = 1 vs 2
v1 = abc vs zabc
v2 = xyz vs zxyz
i1 = 1 vs 3
i2 = 2 vs 4
t1 = abc abc vs zabc abc
t2 = xyz xyz vs zxyz xyz
d1 = 1.1 vs 1.2
b1 = False vs True
afield = [1, 2, 3] vs [4, 2, 3]
date_field = 1999-01-08 vs 2000-02-20
time_field = 1999-01-08 04:05:06 vs 2000-02-20 23:59:59""")