Python DBApiModule.deleteFromTable方法代码示例

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropPWByUser(self):
     self.insertUser(self.id, self.name, self.email)
     self.insertPW(self.pw.userId, self.pw.value, self.pw.salt)
     
     db.deleteFromTable(self.conn, "user", id=self.id) 
     row = db.selectFrom(self.conn, {"pw_hash"}, "*", user_id=self.id)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropTagByUser(self):
     self.insertUser(self.id, self.name, self.email)
     self.insertTag(self.tag.id, self.tag.name)
     
     db.deleteFromTable(self.conn, "user", id=self.id)
     row = db.selectFrom(self.conn, {"tag"}, "*" , id=self.tag.id)
     # FIXME: when a user is deleted all of his tags must be removed 
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropGroupByUser(self):
     self.insertUser(self.id, self.name, self.email)
     self.insertGroup(self.group.id, self.group.name, self.group.public)
     
     db.deleteFromTable(self.conn, "user", id=self.id)
     row = db.selectFrom(self.conn, {"link_group"}, "*" , id=self.group.id)
     # FIXME: when a user is deleted all of his groups must be removed
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropMetaDataByLink(self):
     self.insertLink(self.id, self.userId, self.url, self.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     self.insertMetaData(self.metaData.linkId, self.metaData.key, self.metaData.value)
     
     db.deleteFromTable(self.conn, "link", id=self.id)
     row = db.selectFrom(self.conn, {"meta_data"}, "*", link_id=self.metaData.linkId)
     self.assertEqual(row, []) 

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropLinkTagMapByLink(self):
     self.insertLink(self.id, self.userId, self.url, self.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     self.insertTag(self.tag.id, self.tag.name)
     self.insertLinkTagMap(self.linkTagMap.tagId, self.linkTagMap.linkId)
     
     db.deleteFromTable(self.conn, "link", id=self.id)
     row = db.selectFrom(self.conn, {"link_tag_map"}, "*", link_id=self.linkTagMap.linkId)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropLinkGroupMapByLink(self):
     self.insertLink(self.id, self.userId, self.url, self.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     self.insertGroup(self.group.id, self.group.name, self.group.public)
     self.insertLinkGroupMap(self.linkGroupMap.groupId, self.linkGroupMap.linkId)
     
     db.deleteFromTable(self.conn, "link", id=self.id)
     row = db.selectFrom(self.conn, {"link_group_map"}, "*", link_id=self.linkGroupMap.linkId)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropLinkGroupMapByGroup(self):
     self.insertUser(self.user.id, self.user.name, self.user.email)
     self.insertLink(self.link.id, self.link.userId, self.link.url, self.link.urlHash, self.link.title,
                     self.link.description, self.link.typeName , self.link.modifiedAt)
     self.insertGroup(self.id, self.name, self.public)
     self.insertLinkGroupMap(self.linkGroupMap.groupId, self.linkGroupMap.linkId)
     
     db.deleteFromTable(self.conn, "link_group", id=self.id)
     row = db.selectFrom(self.conn, {"link_group_map"}, "*", group_id=self.id)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropLinkTagMapByTag(self):
     self.insertUser(self.user.id, self.user.name, self.user.email)
     self.insertLink(self.link.id, self.link.userId, self.link.url, self.link.urlHash, self.link.title,
                     self.link.description, self.link.typeName , self.link.modifiedAt)
     self.insertTag(self.id, self.name)
     self.insertLinkTagMap(self.linkTagMap.tagId, self.linkTagMap.linkId)
     
     db.deleteFromTable(self.conn, "tag", id=self.id)
     row = db.selectFrom(self.conn, {"link_tag_map"}, "*", tag_id=self.id)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropSearchTableByLink(self):
     self.insertLink(self.id, self.userId, self.url, self.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     self.insertSearchTable(self.searchTable.userId,
                            self.searchTable.linkId,
                            self.searchTable.groups,
                            self.searchTable.tags,
                            self.searchTable.text)
     db.deleteFromTable(self.conn, "link", id=self.id)
     row = db.selectFrom(self.conn, {"search_table"}, "*" , link_id=self.searchTable.linkId)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropLinkByUser(self):
     self.insertUser(self.id, self.name, self.email)
     self.insertLink(self.link.id,
                     self.link.userId,
                     self.link.url,
                     self.link.urlHash,
                     self.link.title,
                     self.link.description,
                     self.link.typeName,
                     self.link.modifiedAt)
     
     db.deleteFromTable(self.conn, "user", id=self.id) 
     row = db.selectFrom(self.conn, {"link"}, "*", id=self.link.id)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testLinkGroupMap(self):
     self.insertLinkGroupMap(self.groupId, self.linkId)
     db.deleteFromTable(self.conn, "link_group_map", group_id=self.groupId)
     rows = db.selectFrom(self.conn, {"link_group_map"}, "*", group_id=self.groupId)
     self.assertEquals(rows, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropLink(self):
     self.insertLink(self.id, self.userId, self.url, self.link.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     db.deleteFromTable(self.conn, "link", id=self.id) 
     row = db.selectFrom(self.conn, {"link"}, "*", id=self.id)
     self.assertEqual(row, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testPW(self):
     self.insertPW(self.userId, self.value, self.salt)
     db.deleteFromTable(self.conn, "pw_hash", user_id=self.userId)
     rows = db.selectFrom(self.conn, {"pw_hash"}, "*", user_id=self.userId)
     self.assertEquals(rows, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testLinkTagMap(self):
     self.insertLinkTagMap(self.tagId, self.linkId)
     db.deleteFromTable(self.conn, "link_tag_map", tag_id=self.tagId)
     rows = db.selectFrom(self.conn, {"link_tag_map"}, "*", tag_id=self.tagId)
     self.assertEquals(rows, [])

# 需要导入模块: from app.db import DBApiModule [as 别名]
# 或者: from app.db.DBApiModule import deleteFromTable [as 别名]
 def testDropGroup(self):
     self.insertGroup(self.id, self.name, self.public)
     db.deleteFromTable(self.conn, "link_group", id=self.id)
     rows = db.selectFrom(self.conn, {"link_group"}, "*", id=self.id)
     self.assertEquals(rows, [])