def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Chemical self.entity = namedtuple('Chemical', 'pmid idx name') self.defaults = self.entity(1, 1, 'chem')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = PublicationType self.entity = namedtuple('PublicationType', 'pmid value') self.defaults = self.entity(1, 'type')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Database self.entity = namedtuple('Database', 'pmid name accession') self.defaults = self.entity(1, 'name', 'accession')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Identifier self.entity = namedtuple('Identifier', 'pmid namespace value') self.defaults = self.entity(1, 'ns', 'id')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.klass = Medline self.entity = namedtuple('Medline', 'pmid status journal pub_date created') self.defaults = self.entity(1, 'MEDLINE', 'journal', 'published', date.today())
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Author self.entity = namedtuple('Author', 'pmid pos name') self.defaults = self.entity(1, 1, 'last')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Keyword self.entity = namedtuple('Keyword', 'pmid owner cnt name') self.defaults = self.entity(1, 'NASA', 1, 'keyword')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Identifier self.entity = namedtuple('Identifier', 'pmid namespace value') self.defaults = self.entity(1, 'ns', 'id')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Section self.entity = namedtuple('Section', 'pmid seq name content') self.defaults = self.entity(1, 1, 'Title', 'The Title')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Descriptor self.entity = namedtuple('Descriptor', 'pmid num name') self.defaults = self.entity(1, 1, 'name')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Keyword self.entity = namedtuple('Keyword', 'pmid owner cnt name') self.defaults = self.entity(1, 'NASA', 1, 'keyword')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Chemical self.entity = namedtuple('Chemical', 'pmid idx name') self.defaults = self.entity(1, 1, 'chem')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = PublicationType self.entity = namedtuple('PublicationType', 'pmid value') self.defaults = self.entity(1, 'type')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Author self.entity = namedtuple('Author', 'pmid pos name') self.defaults = self.entity(1, 1, 'last')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.klass = Citation self.entity = namedtuple('Citation', 'pmid status title journal pub_date created') self.defaults = self.entity(1, 'MEDLINE', 'title', 'journal', '1990 published', date.today())
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Database self.entity = namedtuple('Database', 'pmid name accession') self.defaults = self.entity(1, 'name', 'accession')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.sess.add(Abstract(1, 'NLM')) self.klass = Section self.entity = namedtuple('Section', 'pmid source seq name content') self.defaults = self.entity(1, 'NLM', 1, 'Title', 'The Title')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.D = Descriptor(1, 1, 'd_name', True) self.sess.add(self.D) self.klass = Qualifier self.entity = namedtuple('Qualifier', 'pmid num sub name') self.defaults = self.entity(1, 1, 1, 'name')
def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.D = Descriptor(1, 1, 'd_name', True) self.sess.add(self.D) self.klass = Qualifier self.entity = namedtuple('Qualifier', 'pmid num sub name') self.defaults = self.entity(1, 1, 1, 'name')
class ChemicalTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Chemical self.entity = namedtuple('Chemical', 'pmid idx name') self.defaults = self.entity(1, 1, 'chem') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(name='other') self.assertDifference(idx=2) self.assertNotEqual(Chemical(1, 1, 'name', 'other'), Chemical(1, 1, 'name', 'uid')) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # IDX def testRequireIdx(self): self.assertNonNullValue(TypeError, 'idx') def testRequirePositiveIdx(self): self.assertPositiveValue(AssertionError, 'idx') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # UID def testRequireNonEmptyUid(self): self.assertBadExtraValue(AssertionError, 'uid', '') # METHODS def testToString(self): self.assertEqual('1\t1\tuid\tname\n', str(Chemical(1, 1, 'name', 'uid'))) def testToRepr(self): self.assertEqual('Chemical<1:1>', repr(Chemical(1, 1, 'name'))) def testMedlineRelations(self): i = Chemical(1, 1, 'name') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.chemicals) self.assertEqual(self.M, i.medline)
class DatabaseTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Database self.entity = namedtuple('Database', 'pmid name accession') self.defaults = self.entity(1, 'name', 'accession') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(name='other') self.assertDifference(accession='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # ACCESSION def testRequireAccession(self): self.assertNonNullValue(AssertionError, 'accession') def testRequireNonEmptyAccession(self): self.assertNonEmptyValue(AssertionError, 'accession') # METHODS def testToString(self): self.assertEqual('1\tname\taccession\n', str(Database(1, 'name', 'accession'))) def testToRepr(self): self.assertEqual('Database<1:name:accession>', repr(Database(1, 'name', 'accession'))) def testRelations(self): i = Database(1, 'name', 'accession') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.databases) self.assertEqual(self.M, i.citation)
class DatabaseTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Database self.entity = namedtuple('Database', 'pmid name accession') self.defaults = self.entity(1, 'name', 'accession') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(name='other') self.assertDifference(accession='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # ACCESSION def testRequireAccession(self): self.assertNonNullValue(AssertionError, 'accession') def testRequireNonEmptyAccession(self): self.assertNonEmptyValue(AssertionError, 'accession') # METHODS def testToString(self): self.assertEqual('1\tname\taccession\n', str(Database(1, 'name', 'accession'))) def testToRepr(self): self.assertEqual('Database<1:name:accession>', repr(Database(1, 'name', 'accession'))) def testMedlineRelations(self): i = Database(1, 'name', 'accession') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.databases) self.assertEqual(self.M, i.medline)
class PublicationTypeTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = PublicationType self.entity = namedtuple('PublicationType', 'pmid value') self.defaults = self.entity(1, 'type') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(value='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # VALUE def testRequireValue(self): self.assertNonNullValue(AssertionError, 'value') def testRequireNonEmptyValue(self): self.assertNonEmptyValue(AssertionError, 'value') # METHODS def testToString(self): self.assertEqual('1\ttype\n', str(PublicationType(1, 'type'))) def testToRepr(self): self.assertEqual('PublicationType<1:type>', repr(PublicationType(1, 'type'))) def testRelations(self): i = PublicationType(1, 'type') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.publication_types) self.assertEqual(self.M, i.citation)
class PublicationTypeTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = PublicationType self.entity = namedtuple('PublicationType', 'pmid value') self.defaults = self.entity(1, 'type') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(value='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # VALUE def testRequireValue(self): self.assertNonNullValue(AssertionError, 'value') def testRequireNonEmptyValue(self): self.assertNonEmptyValue(AssertionError, 'value') # METHODS def testToString(self): self.assertEqual('1\ttype\n', str(PublicationType(1, 'type'))) def testToRepr(self): self.assertEqual('PublicationType<1:type>', repr(PublicationType(1, 'type'))) def testMedlineRelations(self): i = PublicationType(1, 'type') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.publication_types) self.assertEqual(self.M, i.medline)
class QualifierTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.D = Descriptor(1, 1, 'd_name', True) self.sess.add(self.D) self.klass = Qualifier self.entity = namedtuple('Qualifier', 'pmid num sub name') self.defaults = self.entity(1, 1, 1, 'name') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(num=2) self.assertDifference(sub=2) self.assertDifference(name='other') self.assertNotEqual(Qualifier(1, 1, 1, 'q_name', True), Qualifier(1, 1, 1, 'q_name', False)) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # NUM def testRequireNum(self): self.assertNonNullValue(TypeError, 'num') def testRequireExistingDescriptor(self): self.sess.add(Qualifier(1, 2, 1, 'q_name')) self.assertRaises(IntegrityError, self.sess.commit) # SUB def testRequireSub(self): self.assertNonNullValue(TypeError, 'sub') def testRequirePositiveSub(self): self.assertPositiveValue(AssertionError, 'sub') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # MAJOR def testMajorIsBool(self): self.sess.add(Qualifier(1, 1, 1, 'q_name', None)) self.assertRaises(IntegrityError, self.sess.commit) # METHODS def testToString(self): self.assertEqual('1\t1\t1\tT\tmajor\n', str(Qualifier(1, 1, 1, 'major', True))) self.assertEqual('1\t1\t1\tF\tminor\n', str(Qualifier(1, 1, 1, 'minor'))) def testToRepr(self): self.assertEqual('Qualifier<1:2:3>', repr(Qualifier(1, 2, 3, 'name'))) def testRelations(self): q = Qualifier(1, 1, 1, 'name') self.sess.add(q) self.sess.commit() self.assertListEqual([q], self.M.qualifiers) self.assertEqual(self.M, q.citation) self.assertEqual(self.D, q.descriptor) def testSelect(self): self.sess.add(Qualifier(1, 1, 1, 'q1')) self.sess.add(Qualifier(1, 1, 2, 'q2')) self.sess.add(Qualifier(1, 1, 3, 'q3')) self.sess.commit() for row in Qualifier.select((1, 1), ['sub', 'name']): if row['sub'] == 1: self.assertEqual(row['name'], 'q1') elif row[0] == 2: self.assertEqual(row[1], 'q2') elif row[0] == 3: self.assertEqual(row[1], 'q3') else: self.fail(str(row)) def testSelectAll(self): self.sess.add(Qualifier(1, 1, 1, 'q1')) self.sess.add(Qualifier(1, 1, 2, 'q2')) self.sess.add(Qualifier(1, 1, 3, 'q3')) self.sess.commit() for row in Qualifier.selectAll((1, 1)): if row['sub'] == 1: self.assertEqual(row['name'], 'q1') elif row['sub'] == 2: self.assertFalse(row[Qualifier.major.name]) elif row['sub'] == 3: self.assertEqual(row['name'], 'q3') else: self.fail(str(row))
class MedlineTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.klass = Medline self.entity = namedtuple('Medline', 'pmid status journal pub_date created') self.defaults = self.entity(1, 'MEDLINE', 'journal', 'published', date.today()) def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(pmid=2) self.assertDifference(status='In-Data-Review') self.assertDifference(journal='other') self.assertDifference(pub_date='other') def testBigPmids(self): big = 987654321098765432 # up to 18 decimals r = Medline(big, 'MEDLINE', 'journal', 'PubDate', date.today()) self.sess.add(r) self.sess.commit() self.assertEqual(big, r.pmid) self.assertEqual(big, self.sess.query(Medline).first().pmid) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') def testRequirePositivePmid(self): self.assertPositiveValue(AssertionError, 'pmid') # STATUS def testRequireStatus(self): self.assertNonNullValue(AssertionError, 'status') def testRequireValidStatus(self): self.assertBadValue('invalid', AssertionError, 'status') def testValidStatusNames(self): d = date.today() for pmid, status in enumerate(Medline.STATES): self.sess.add(Medline(pmid + 1, status, 'journal', 'pubdate', d)) self.sess.commit() self.assertTrue(True) # JOURNAL def testRequireJournal(self): self.assertNonNullValue(AssertionError, 'journal') def testRequireNonEmptyJournal(self): self.assertNonEmptyValue(AssertionError, 'journal') # CREATED def testRequireCreated(self): self.assertNonNullValue(AssertionError, 'created') # COMPLETED def testRequireCompletedDateOrNone(self): self.assertBadExtraValue(AssertionError, 'completed', '') # REVISED def testRequireRevisedDateOrNone(self): self.assertBadExtraValue(AssertionError, 'revised', '') # MODIFIED def testRequireModifiedDateOrNone(self): m = Medline(*self.defaults) m.modified = '' self.sess.add(m) self.assertRaises(StatementError, self.sess.commit) def testAutomaticModified(self): r = Medline(1, 'MEDLINE', 'journal', 'PubDate', date.today()) self.sess.add(r) self.sess.commit() self.assertEqual(date.today(), r.modified) def testModifiedBefore(self): today = date.today() yesterday = today - timedelta(days=1) m1 = Medline(1, 'MEDLINE', 'Journal 1', 'PubDate', today) m2 = Medline(2, 'MEDLINE', 'Journal 1', 'PubDate', today) m1.modified = today m2.modified = yesterday self.sess.add(m1) self.sess.add(m2) self.sess.commit() self.assertListEqual([2], list(Medline.modifiedBefore([1, 2], date.today()))) # METHODS def testToString(self): d = date.today() r = Medline(1, 'MEDLINE', 'journal\\.', 'PubDate', d) line = "1\tMEDLINE\tjournal\\.\tPubDate\t\\N\t\\N\t{}\t\\N\t\\N\t{}\n".format( d.isoformat(), d.isoformat() ) self.assertEqual(line, str(r)) def testToRepr(self): r = Medline(1, 'MEDLINE', 'journal', 'PubDate', date.today()) self.assertEqual("Medline<1>", repr(r)) def testInsert(self): data = { Medline.__tablename__: [ dict(pmid=1, status='MEDLINE', journal='Journal', pub_date='PubDate', created=date.today()) ], Section.__tablename__: [ dict(pmid=1, seq=1, name='Title', content='The title.') ], Author.__tablename__: [ dict(pmid=1, pos=1, name='Author') ], Descriptor.__tablename__: [ dict(pmid=1, num=1, major=True, name='descriptor') ], Qualifier.__tablename__: [ dict(pmid=1, num=1, sub=1, major=True, name='descriptor') ], Identifier.__tablename__: [ dict(pmid=1, namespace='ns', value='id') ], Database.__tablename__: [ dict(pmid=1, name='name', accession='accession') ], Chemical.__tablename__: [ dict(pmid=1, idx=1, name='name') ], Keyword.__tablename__: [ dict(pmid=1, owner='NLM', cnt=1, major=True, value='name') ], } Medline.insert(data) for m in self.sess.query(Medline): self.assertEqual(1, m.pmid) for t in Medline.CHILDREN: self.assertEqual(1, list(self.sess.query(t))[0].pmid) def testInsertMultiple(self): d = date.today() data = {Medline.__tablename__: [ dict(pmid=1, status='MEDLINE', journal='Journal 1', pub_date='PubDate', created=d), dict(pmid=2, status='MEDLINE', journal='Journal 2', pub_date='PubDate', created=d), dict(pmid=3, status='MEDLINE', journal='Journal 3', pub_date='PubDate', created=d) ]} Medline.insert(data) count = 0 for m in self.sess.query(Medline): if m.pmid not in (1, 2, 3): self.fail(m) else: count += 1 self.assertEqual(3, count) def addThree(self, d): self.sess.add(Medline(1, 'MEDLINE', 'Journal 1', 'PubDate', d)) self.sess.add(Medline(2, 'MEDLINE', 'Journal 2', 'PubDate', d)) self.sess.add(Medline(3, 'MEDLINE', 'Journal X', 'PubDate', d)) self.sess.commit() def testSelect(self): self.addThree(date.today()) count = 0 for row in Medline.select([1, 2], ['journal']): self.assertEqual('Journal {}'.format(row['pmid']), row['journal']) count += 1 self.assertEqual(2, count) def testSelectAll(self): d = date.today() self.addThree(d) count = 0 for row in Medline.selectAll([1, 2]): self.assertEqual('Journal {}'.format(row['pmid']), row['journal']) self.assertEqual(d, row['created']) self.assertEqual('MEDLINE', row[1]) count += 1 self.assertEqual(2, count) def testDelete(self): self.addThree(date.today()) Medline.delete([1, 2]) count = 0 for m in self.sess.query(Medline): self.assertEqual(3, m.pmid) count += 1 self.assertEqual(1, count) def testExisting(self): self.addThree(date.today()) self.assertListEqual([1, 3], list(Medline.existing([1, 3, 5])))
class ChemicalTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Chemical self.entity = namedtuple('Chemical', 'pmid idx name') self.defaults = self.entity(1, 1, 'chem') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(name='other') self.assertDifference(idx=2) self.assertNotEqual(Chemical(1, 1, 'name', 'other'), Chemical(1, 1, 'name', 'uid')) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # IDX def testRequireIdx(self): self.assertNonNullValue(TypeError, 'idx') def testRequirePositiveIdx(self): self.assertPositiveValue(AssertionError, 'idx') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # UID def testRequireNonEmptyUid(self): self.assertBadExtraValue(AssertionError, 'uid', '') # METHODS def testToString(self): self.assertEqual('1\t1\tuid\tname\n', str(Chemical(1, 1, 'name', 'uid'))) def testToRepr(self): self.assertEqual('Chemical<1:1>', repr(Chemical(1, 1, 'name'))) def testRelations(self): i = Chemical(1, 1, 'name') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.chemicals) self.assertEqual(self.M, i.citation)
class KeywordTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Keyword self.entity = namedtuple('Keyword', 'pmid owner cnt name') self.defaults = self.entity(1, 'NASA', 1, 'keyword') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(cnt=2) self.assertDifference(owner='NLM') self.assertDifference(name='other') self.assertNotEqual(Keyword(1, 'NASA', 1, 'name', True), Keyword(1, 'NASA', 1, 'name', False)) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # OWNER def testRequireOwner(self): self.assertNonNullValue(AssertionError, 'owner') def testRequireValidOwner(self): self.assertBadValue('WRONG', AssertionError, 'owner') # CNT def testRequireCnt(self): self.assertNonNullValue(TypeError, 'cnt') def testRequirePositiveCnt(self): self.assertPositiveValue(AssertionError, 'cnt') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # MAJOR def testMajorIsBool(self): self.sess.add(Keyword(1, 'NLM', 1, 'name', None)) self.assertRaises(IntegrityError, self.sess.commit) # METHODS def testToString(self): self.assertEqual('1\tNASA\t1\tF\tname\n', str(Keyword(1, 'NASA', 1, 'name'))) self.assertEqual('1\tNASA\t1\tT\tname\n', str(Keyword(1, 'NASA', 1, 'name', True))) def testToRepr(self): self.assertEqual('Keyword<1:NASA:1>', repr(Keyword(1, 'NASA', 1, 'name'))) def testMedlineRelations(self): i = Keyword(1, 'NASA', 1, 'name') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.keywords) self.assertEqual(self.M, i.medline)
class SectionTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.sess.add(Abstract(1, 'NLM')) self.klass = Section self.entity = namedtuple('Section', 'pmid source seq name content') self.defaults = self.entity(1, 'NLM', 1, 'Title', 'The Title') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(content='other') self.assertDifference(name='other') self.assertDifference(seq=2) self.assertDifference(source='Publisher') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') def testRequireExistingPmid(self): self.sess.add(Section(2, 'NLM', 1, 'Title', 'The Title')) self.assertRaises(IntegrityError, self.sess.commit) # SEQ def testRequireSeq(self): self.assertNonNullValue(TypeError, 'seq') def testRequirePositiveSeq(self): self.assertPositiveValue(AssertionError, 'seq') # NAME def testRequireSectionName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptySectionName(self): self.assertNonEmptyValue(AssertionError, 'name') # CONTENT def testRequireContent(self): self.assertNonNullValue(AssertionError, 'content') def testRequireNonEmptyContent(self): self.assertNonEmptyValue(AssertionError, 'content') # LABEL def testNonEmptyLabel(self): self.assertBadExtraValue(AssertionError, 'label', '') # METHODS def testToString(self): self.assertEqual( '1\tNLM\t1\tTitle\tlabel\t"co\\n\\tent"\\\\\tF\n', str(Section(1, 'NLM', 1, 'Title', "\"co\n\tent\"\\", 'label'))) def testToRepr(self): self.assertEqual( 'Section<1:NLM:1>', repr(Section(1, 'NLM', 1, 'Title', 'content', 'label'))) def testCitation(self): section = Section(1, 'NLM', 1, 'Abstract', 'The Abstract.') self.sess.add(section) self.sess.commit() self.assertListEqual([section], self.M.sections) self.assertEqual(self.M, section.citation)
class AuthorTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Author self.entity = namedtuple('Author', 'pmid pos name') self.defaults = self.entity(1, 1, 'last') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(pos=2) self.assertDifference(name='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # POS def testRequirePos(self): self.assertNonNullValue(TypeError, 'pos') def testRequirePositivePos(self): self.assertPositiveValue(AssertionError, 'pos') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # INITIALS def testAssignInitials(self): self.sess.add(Author(1, 1, 'last', initials='test')) self.assertEqual('test', self.sess.query(Author).first().initials) # FORENAME def testAssignFirstName(self): self.sess.add(Author(1, 1, 'last', forename='test')) self.assertEqual('test', self.sess.query(Author).first().forename) # SUFFIX def testAssignSuffix(self): self.sess.add(Author(1, 1, 'last', suffix='test')) self.assertEqual('test', self.sess.query(Author).first().suffix) # METHODS def testFullNameDefault(self): a = Author(1, 1, 'last', initials='init', forename='first', suffix='suffix') self.assertEqual('first last suffix', a.fullName()) def testFullNameNoFirst(self): a = Author(1, 1, 'last', initials='init', forename='', suffix='suffix') self.assertEqual('init last suffix', a.fullName()) def testFullNameNoFirstOrInitials(self): a = Author(1, 1, 'last', initials='', forename='', suffix='suffix') self.assertEqual('last suffix', a.fullName()) def testFullNameNoSuffix(self): a = Author(1, 1, 'last', initials='init', forename='first', suffix='') self.assertEqual('first last', a.fullName()) def testShortNameDefault(self): a = Author(1, 1, 'last', initials='init', forename='first', suffix='suffix') self.assertEqual('init last', a.shortName()) def testShortNameNoInitials(self): a = Author(1, 1, 'last', initials='', forename='first second', suffix='suffix') self.assertEqual('fs last', a.shortName()) def testShortNameNoFirstOrInitials(self): a = Author(1, 1, 'last', initials='', forename='', suffix='suffix') self.assertEqual('last', a.shortName()) def testToString(self): self.assertEqual('1\t1\tlast\t\\N\tfirst\t\n', str(Author(1, 1, 'last', forename='first', suffix=''))) def testToRepr(self): self.assertEqual('Author<1:1>', repr(Author(1, 1, 'name'))) def testMedlineRelations(self): a = Author(1, 1, 'last') self.sess.add(a) self.sess.commit() self.assertListEqual([a], self.M.authors) self.assertEqual(self.M, a.medline)
class CitationTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.klass = Citation self.entity = namedtuple('Citation', 'pmid status title journal pub_date created') self.defaults = self.entity(1, 'MEDLINE', 'title', 'journal', '1990 published', date.today()) def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(pmid=2) self.assertDifference(status='In-Data-Review') self.assertDifference(journal='other') self.assertDifference(pub_date='1960 other') def testBigPmids(self): big = 987654321098765432 # up to 18 decimals r = DefaultCitation(big) self.sess.add(r) self.sess.commit() self.assertEqual(big, r.pmid) self.assertEqual(big, self.sess.query(Citation).first().pmid) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') def testRequirePositivePmid(self): self.assertPositiveValue(AssertionError, 'pmid') # STATUS def testRequireStatus(self): self.assertNonNullValue(AssertionError, 'status') def testRequireValidStatus(self): self.assertBadValue('invalid', AssertionError, 'status') def testValidStatusNames(self): for pmid, status in enumerate(Citation.STATES): self.sess.add(DefaultCitation(pmid + 1, status)) self.sess.commit() self.assertTrue(True) # JOURNAL def testRequireJournal(self): self.assertNonNullValue(AssertionError, 'journal') def testRequireNonEmptyJournal(self): self.assertNonEmptyValue(AssertionError, 'journal') # CREATED def testRequireCreated(self): self.assertNonNullValue(AssertionError, 'created') # COMPLETED def testRequireCompletedDateOrNone(self): self.assertBadExtraValue(AssertionError, 'completed', '') # REVISED def testRequireRevisedDateOrNone(self): self.assertBadExtraValue(AssertionError, 'revised', '') # MODIFIED def testRequireModifiedDateOrNone(self): m = Citation(*self.defaults) m.modified = '' self.sess.add(m) self.assertRaises(StatementError, self.sess.commit) def testAutomaticModified(self): r = DefaultCitation() self.sess.add(r) self.sess.commit() self.assertEqual(date.today(), r.modified) def testModifiedBefore(self): today = date.today() yesterday = today - timedelta(days=1) m1 = DefaultCitation() m2 = DefaultCitation(2) m1.modified = today m2.modified = yesterday self.sess.add(m1) self.sess.add(m2) self.sess.commit() self.assertListEqual([2], list(Citation.modifiedBefore([1, 2], date.today()))) # METHODS def testToString(self): d = date.today() r = Citation(1, 'MEDLINE', 'title', 'journal\\.', '1990 PubDate', d) line = "1\tMEDLINE\t1990\ttitle\tjournal\\\\.\t1990 PubDate\t\\N\t\\N\t{}\t\\N\t\\N\t{}\n".format( d.isoformat(), d.isoformat()) self.assertEqual(line, str(r)) def testToRepr(self): r = DefaultCitation(123) self.assertEqual("Citation<123>", repr(r)) def testInsert(self): data = { Citation.__tablename__: [ dict(pmid=1, status='MEDLINE', year=1990, title='Title', journal='Journal', pub_date='1990 PubDate', created=date.today()) ], Abstract.__tablename__: [dict(pmid=1, source='NLM')], Section.__tablename__: [ dict(pmid=1, source='NLM', seq=1, name='Title', content='The title.') ], Author.__tablename__: [dict(pmid=1, pos=1, name='Author')], Descriptor.__tablename__: [dict(pmid=1, num=1, major=True, name='descriptor')], Qualifier.__tablename__: [dict(pmid=1, num=1, sub=1, major=True, name='descriptor')], Identifier.__tablename__: [dict(pmid=1, namespace='ns', value='id')], Database.__tablename__: [dict(pmid=1, name='name', accession='accession')], Chemical.__tablename__: [dict(pmid=1, idx=1, name='name')], Keyword.__tablename__: [dict(pmid=1, owner='NLM', cnt=1, major=True, value='name')], } Citation.insert(data) for m in self.sess.query(Citation): self.assertEqual(1, m.pmid) for t in Citation.CHILDREN: self.assertEqual(1, list(self.sess.query(t))[0].pmid) def testInsertMultiple(self): d = date.today() data = { Citation.__tablename__: [ dict(pmid=1, status='MEDLINE', year=1990, title='Title 1', journal='Journal 1', pub_date='1990 PubDate', created=d), dict(pmid=2, status='MEDLINE', year=1990, title='Title 2', journal='Journal 2', pub_date='1990 PubDate', created=d), dict(pmid=3, status='MEDLINE', year=1990, title='Title 3', journal='Journal 3', pub_date='1990 PubDate', created=d) ] } Citation.insert(data) count = 0 for m in self.sess.query(Citation): if m.pmid not in (1, 2, 3): self.fail(m) else: count += 1 self.assertEqual(3, count) def addThree(self, d): self.sess.add(DefaultCitation(1, journal='Journal 1', created=d)) self.sess.add(DefaultCitation(2, journal='Journal 2', created=d)) self.sess.add(DefaultCitation(3, created=d)) self.sess.commit() def testSelect(self): self.addThree(date.today()) count = 0 for row in Citation.select([1, 2], ['journal']): self.assertEqual('Journal {}'.format(row['pmid']), row['journal']) count += 1 self.assertEqual(2, count) def testSelectAll(self): d = date.today() self.addThree(d) count = 0 for row in Citation.selectAll([1, 2]): self.assertEqual('Journal {}'.format(row['pmid']), row['journal']) self.assertEqual(d, row['created']) self.assertEqual('MEDLINE', row[1]) count += 1 self.assertEqual(2, count) def testDelete(self): self.addThree(date.today()) Citation.delete([1, 2]) count = 0 for m in self.sess.query(Citation): self.assertEqual(3, m.pmid) count += 1 self.assertEqual(1, count) def testExisting(self): self.addThree(date.today()) self.assertListEqual([1, 3], list(Citation.existing([1, 3, 5])))
class QualifierTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.D = Descriptor(1, 1, 'd_name', True) self.sess.add(self.D) self.klass = Qualifier self.entity = namedtuple('Qualifier', 'pmid num sub name') self.defaults = self.entity(1, 1, 1, 'name') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(num=2) self.assertDifference(sub=2) self.assertDifference(name='other') self.assertNotEqual(Qualifier(1, 1, 1, 'q_name', True), Qualifier(1, 1, 1, 'q_name', False)) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # NUM def testRequireNum(self): self.assertNonNullValue(TypeError, 'num') def testRequireExistingDescriptor(self): self.sess.add(Qualifier(1, 2, 1, 'q_name')) self.assertRaises(IntegrityError, self.sess.commit) # SUB def testRequireSub(self): self.assertNonNullValue(TypeError, 'sub') def testRequirePositiveSub(self): self.assertPositiveValue(AssertionError, 'sub') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # MAJOR def testMajorIsBool(self): self.sess.add(Qualifier(1, 1, 1, 'q_name', None)) self.assertRaises(IntegrityError, self.sess.commit) # METHODS def testToString(self): self.assertEqual('1\t1\t1\tT\tmajor\n', str(Qualifier(1, 1, 1, 'major', True))) self.assertEqual('1\t1\t1\tF\tminor\n', str(Qualifier(1, 1, 1, 'minor'))) def testToRepr(self): self.assertEqual('Qualifier<1:2:3>', repr(Qualifier(1, 2, 3, 'name'))) def testMedlineRelations(self): q = Qualifier(1, 1, 1, 'name') self.sess.add(q) self.sess.commit() self.assertListEqual([q], self.M.qualifiers) self.assertEqual(self.M, q.medline) self.assertEqual(self.D, q.descriptor) def testSelect(self): self.sess.add(Qualifier(1, 1, 1, 'q1')) self.sess.add(Qualifier(1, 1, 2, 'q2')) self.sess.add(Qualifier(1, 1, 3, 'q3')) self.sess.commit() for row in Qualifier.select((1, 1), ['sub', 'name']): if row['sub'] == 1: self.assertEqual(row['name'], 'q1') elif row[0] == 2: self.assertEqual(row[1], 'q2') elif row[0] == 3: self.assertEqual(row[1], 'q3') else: self.fail(str(row)) def testSelectAll(self): self.sess.add(Qualifier(1, 1, 1, 'q1')) self.sess.add(Qualifier(1, 1, 2, 'q2')) self.sess.add(Qualifier(1, 1, 3, 'q3')) self.sess.commit() for row in Qualifier.selectAll((1, 1)): if row['sub'] == 1: self.assertEqual(row['name'], 'q1') elif row['sub'] == 2: self.assertFalse(row[Qualifier.major.name]) elif row['sub'] == 3: self.assertEqual(row['name'], 'q3') else: self.fail(str(row))
class DescriptorTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Descriptor self.entity = namedtuple('Descriptor', 'pmid num name') self.defaults = self.entity(1, 1, 'name') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(name='other') self.assertDifference(num=2) self.assertNotEqual(Descriptor(1, 1, 'd_name', True), Descriptor(1, 1, 'd_name', False)) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') def testRequireExistingPmid(self): self.sess.add(Descriptor(2, 1, 'd_name')) self.assertRaises(IntegrityError, self.sess.commit) # NUM def testRequireNum(self): self.assertNonNullValue(TypeError, 'num') def testRequirePositiveNum(self): self.assertPositiveValue(AssertionError, 'num') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # MAJOR def testMajorIsBool(self): self.sess.add(Descriptor(1, 1, 'd_name', None)) self.assertRaises(IntegrityError, self.sess.commit) # METHODS def testToString(self): self.assertEqual('1\t1\tT\tmajor\n', str(Descriptor(1, 1, 'major', True))) self.assertEqual('1\t1\tF\tminor\n', str(Descriptor(1, 1, 'minor'))) def testToRepr(self): self.assertEqual('Descriptor<1:2>', repr(Descriptor(1, 2, 'name'))) def testMedlineRelations(self): d = Descriptor(1, 1, 'name') self.sess.add(d) self.sess.commit() self.assertListEqual([d], self.M.descriptors) self.assertEqual(self.M, d.medline) def testSelect(self): self.sess.add(Descriptor(1, 1, 'd1')) self.sess.add(Descriptor(1, 2, 'd2')) self.sess.add(Descriptor(1, 3, 'd3')) self.sess.commit() for row in Descriptor.select(1, ['num', 'name']): if row['num'] == 1: self.assertEqual(row['name'], 'd1') elif row[0] == 2: self.assertEqual(row[1], 'd2') elif row[0] == 3: self.assertEqual(row[1], 'd3') else: self.fail(str(row)) def testSelectAll(self): self.sess.add(Descriptor(1, 1, 'd1')) self.sess.add(Descriptor(1, 2, 'd2')) self.sess.add(Descriptor(1, 3, 'd3')) self.sess.commit() for row in Descriptor.selectAll(1): if row['num'] == 1: self.assertEqual(row['name'], 'd1') elif row['num'] == 2: # noinspection PyUnresolvedReferences self.assertFalse(row[Descriptor.major.name]) elif row['num'] == 3: self.assertEqual(row['name'], 'd3') else: self.fail(str(row))
class SectionTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Section self.entity = namedtuple('Section', 'pmid seq name content') self.defaults = self.entity(1, 1, 'Title', 'The Title') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(content='other') self.assertDifference(name='other') self.assertDifference(seq=2) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') def testRequireExistingPmid(self): self.sess.add(Section(2, 1, 'Title', 'The Title')) self.assertRaises(IntegrityError, self.sess.commit) # SEQ def testRequireSeq(self): self.assertNonNullValue(TypeError, 'seq') def testRequirePositiveSeq(self): self.assertPositiveValue(AssertionError, 'seq') # NAME def testRequireSectionName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptySectionName(self): self.assertNonEmptyValue(AssertionError, 'name') # CONTENT def testRequireContent(self): self.assertNonNullValue(AssertionError, 'content') def testRequireNonEmptyContent(self): self.assertNonEmptyValue(AssertionError, 'content') # LABEL def testNonEmptyLabel(self): self.assertBadExtraValue(AssertionError, 'label', '') # METHODS def testToString(self): self.assertEqual('1\t1\tTitle\tlabel\t"co\\n\\tent"\\\\\n', str(Section(1, 1, 'Title', "\"co\n\tent\"\\", 'label'))) def testToRepr(self): self.assertEqual('Section<1:1>', repr(Section(1, 1, 'Title', 'content', 'label'))) def testMedlineRelations(self): title = Section(1, 1, 'Title', 'The Title') abstract = Section(1, 2, 'Abstract', 'The Abstract.') self.sess.add(title) self.sess.add(abstract) self.sess.commit() self.assertListEqual([title, abstract], self.M.sections) self.assertEqual(self.M, title.medline) self.assertEqual(self.M, abstract.medline)
class IdentifierTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Identifier self.entity = namedtuple('Identifier', 'pmid namespace value') self.defaults = self.entity(1, 'ns', 'id') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(namespace='other') self.assertDifference(value='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # NAMESPACE def testRequireNamespace(self): self.assertNonNullValue(AssertionError, 'namespace') def testRequireNonEmptyNamespace(self): self.assertNonEmptyValue(AssertionError, 'namespace') # VALUE def testRequireIdentifierValue(self): self.assertNonNullValue(AssertionError, 'value') def testRequireNonEmptyIdentifierValue(self): self.assertNonEmptyValue(AssertionError, 'value') # METHODS def testToString(self): self.assertEqual('1\tns\tid\n', str(Identifier(1, 'ns', 'id'))) def testToRepr(self): self.assertEqual('Identifier<1:ns>', repr(Identifier(1, 'ns', 'id'))) def testRelations(self): i = Identifier(1, 'ns', 'id') self.sess.add(i) self.sess.commit() self.assertEqual({'ns': i}, self.M.identifiers) self.assertEqual(self.M, i.citation) def testPmid2Doi(self): self.sess.add(Identifier(1, 'doi', 'id')) self.sess.add(DefaultCitation(2)) self.sess.commit() self.assertEqual('id', Identifier.pmid2doi(1)) self.assertEqual(None, Identifier.pmid2doi(2)) def testDoi2Pmid(self): self.sess.add(Identifier(1, 'doi', 'id')) self.sess.add(DefaultCitation(2)) self.sess.commit() self.assertEqual(1, Identifier.doi2pmid('id')) self.assertEqual(None, Identifier.doi2pmid('other')) def testMapPmids2Dois(self): self.sess.add(Identifier(1, 'doi', 'id1')) self.sess.add(DefaultCitation(2)) self.sess.add(Identifier(2, 'doi', 'id2')) self.sess.commit() self.assertDictEqual({ 1: 'id1', 2: 'id2' }, Identifier.mapPmids2Dois([1, 2, 3])) self.assertDictEqual({}, Identifier.mapPmids2Dois([3, 4])) def testMapDois2Pmids(self): self.sess.add(Identifier(1, 'doi', 'id1')) self.sess.add(DefaultCitation(2)) self.sess.add(Identifier(2, 'doi', 'id2')) self.sess.commit() self.assertDictEqual({ 'id1': 1, 'id2': 2 }, Identifier.mapDois2Pmids(['id1', 'id2', 'id3'])) self.assertDictEqual({}, Identifier.mapDois2Pmids(['id3', 'id4']))
class DescriptorTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Descriptor self.entity = namedtuple('Descriptor', 'pmid num name') self.defaults = self.entity(1, 1, 'name') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(name='other') self.assertDifference(num=2) self.assertNotEqual(Descriptor(1, 1, 'd_name', True), Descriptor(1, 1, 'd_name', False)) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') def testRequireExistingPmid(self): self.sess.add(Descriptor(2, 1, 'd_name')) self.assertRaises(IntegrityError, self.sess.commit) # NUM def testRequireNum(self): self.assertNonNullValue(TypeError, 'num') def testRequirePositiveNum(self): self.assertPositiveValue(AssertionError, 'num') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # MAJOR def testMajorIsBool(self): self.sess.add(Descriptor(1, 1, 'd_name', None)) self.assertRaises(IntegrityError, self.sess.commit) # METHODS def testToString(self): self.assertEqual('1\t1\tT\tmajor\n', str(Descriptor(1, 1, 'major', True))) self.assertEqual('1\t1\tF\tminor\n', str(Descriptor(1, 1, 'minor'))) def testToRepr(self): self.assertEqual('Descriptor<1:2>', repr(Descriptor(1, 2, 'name'))) def testRelations(self): d = Descriptor(1, 1, 'name') self.sess.add(d) self.sess.commit() self.assertListEqual([d], self.M.descriptors) self.assertEqual(self.M, d.citation) def testSelect(self): self.sess.add(Descriptor(1, 1, 'd1')) self.sess.add(Descriptor(1, 2, 'd2')) self.sess.add(Descriptor(1, 3, 'd3')) self.sess.commit() for row in Descriptor.select(1, ['num', 'name']): if row['num'] == 1: self.assertEqual(row['name'], 'd1') elif row[0] == 2: self.assertEqual(row[1], 'd2') elif row[0] == 3: self.assertEqual(row[1], 'd3') else: self.fail(str(row)) def testSelectAll(self): self.sess.add(Descriptor(1, 1, 'd1')) self.sess.add(Descriptor(1, 2, 'd2')) self.sess.add(Descriptor(1, 3, 'd3')) self.sess.commit() for row in Descriptor.selectAll(1): if row['num'] == 1: self.assertEqual(row['name'], 'd1') elif row['num'] == 2: # noinspection PyUnresolvedReferences self.assertFalse(row[Descriptor.major.name]) elif row['num'] == 3: self.assertEqual(row['name'], 'd3') else: self.fail(str(row))
class IdentifierTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = Medline(1, 'MEDLINE', 'Journal', 'PubDate', date.today()) self.sess.add(self.M) self.klass = Identifier self.entity = namedtuple('Identifier', 'pmid namespace value') self.defaults = self.entity(1, 'ns', 'id') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(namespace='other') self.assertDifference(value='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # NAMESPACE def testRequireNamespace(self): self.assertNonNullValue(AssertionError, 'namespace') def testRequireNonEmptyNamespace(self): self.assertNonEmptyValue(AssertionError, 'namespace') # VALUE def testRequireIdentifierValue(self): self.assertNonNullValue(AssertionError, 'value') def testRequireNonEmptyIdentifierValue(self): self.assertNonEmptyValue(AssertionError, 'value') # METHODS def testToString(self): self.assertEqual('1\tns\tid\n', str(Identifier(1, 'ns', 'id'))) def testToRepr(self): self.assertEqual('Identifier<1:ns>', repr(Identifier(1, 'ns', 'id'))) def testMedlineRelations(self): i = Identifier(1, 'ns', 'id') self.sess.add(i) self.sess.commit() self.assertEqual({'ns': i}, self.M.identifiers) self.assertEqual(self.M, i.medline) def testPmid2Doi(self): self.sess.add(Identifier(1, 'doi', 'id')) self.sess.add(Medline(2, 'MEDLINE', 'Journal', 'PubDate', date.today())) self.sess.commit() self.assertEqual('id', Identifier.pmid2doi(1)) self.assertEqual(None, Identifier.pmid2doi(2)) def testDoi2Pmid(self): self.sess.add(Identifier(1, 'doi', 'id')) self.sess.add(Medline(2, 'MEDLINE', 'Journal', 'PubDate', date.today())) self.sess.commit() self.assertEqual(1, Identifier.doi2pmid('id')) self.assertEqual(None, Identifier.doi2pmid('other')) def testMapPmids2Dois(self): self.sess.add(Identifier(1, 'doi', 'id1')) self.sess.add(Medline(2, 'MEDLINE', 'Journal', 'PubDate', date.today())) self.sess.add(Identifier(2, 'doi', 'id2')) self.sess.commit() self.assertDictEqual({1: 'id1', 2: 'id2'}, Identifier.mapPmids2Dois([1, 2, 3])) self.assertDictEqual({}, Identifier.mapPmids2Dois([3, 4])) def testMapDois2Pmids(self): self.sess.add(Identifier(1, 'doi', 'id1')) self.sess.add(Medline(2, 'MEDLINE', 'Journal', 'PubDate', date.today())) self.sess.add(Identifier(2, 'doi', 'id2')) self.sess.commit() self.assertDictEqual({'id1': 1, 'id2': 2}, Identifier.mapDois2Pmids(['id1', 'id2', 'id3'])) self.assertDictEqual({}, Identifier.mapDois2Pmids(['id3', 'id4']))
def testUsingURL(self): InitDb(URL('sqlite'), module=dbapi2) self.assertEqual('sqlite', Session().connection().dialect.name)
class AuthorTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Author self.entity = namedtuple('Author', 'pmid pos name') self.defaults = self.entity(1, 1, 'last') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(pos=2) self.assertDifference(name='other') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # POS def testRequirePos(self): self.assertNonNullValue(TypeError, 'pos') def testRequirePositivePos(self): self.assertPositiveValue(AssertionError, 'pos') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # INITIALS def testAssignInitials(self): self.sess.add(Author(1, 1, 'last', initials='test')) self.assertEqual('test', self.sess.query(Author).first().initials) # FORENAME def testAssignFirstName(self): self.sess.add(Author(1, 1, 'last', forename='test')) self.assertEqual('test', self.sess.query(Author).first().forename) # SUFFIX def testAssignSuffix(self): self.sess.add(Author(1, 1, 'last', suffix='test')) self.assertEqual('test', self.sess.query(Author).first().suffix) # METHODS def testFullNameDefault(self): a = Author(1, 1, 'last', initials='init', forename='first', suffix='suffix') self.assertEqual('first last suffix', a.fullName()) def testFullNameNoFirst(self): a = Author(1, 1, 'last', initials='init', forename='', suffix='suffix') self.assertEqual('init last suffix', a.fullName()) def testFullNameNoFirstOrInitials(self): a = Author(1, 1, 'last', initials='', forename='', suffix='suffix') self.assertEqual('last suffix', a.fullName()) def testFullNameNoSuffix(self): a = Author(1, 1, 'last', initials='init', forename='first', suffix='') self.assertEqual('first last', a.fullName()) def testShortNameDefault(self): a = Author(1, 1, 'last', initials='init', forename='first', suffix='suffix') self.assertEqual('init last', a.shortName()) def testShortNameNoInitials(self): a = Author(1, 1, 'last', initials='', forename='first second', suffix='suffix') self.assertEqual('fs last', a.shortName()) def testShortNameNoFirstOrInitials(self): a = Author(1, 1, 'last', initials='', forename='', suffix='suffix') self.assertEqual('last', a.shortName()) def testToString(self): self.assertEqual( '1\t1\tlast\t\\N\tfirst\t\n', str(Author(1, 1, 'last', forename='first', suffix=''))) def testToRepr(self): self.assertEqual('Author<1:1>', repr(Author(1, 1, 'name'))) def testRelations(self): a = Author(1, 1, 'last') self.sess.add(a) self.sess.commit() self.assertListEqual([a], self.M.authors) self.assertEqual(self.M, a.citation)
class SectionTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.sess.add(Abstract(1, 'NLM')) self.klass = Section self.entity = namedtuple('Section', 'pmid source seq name content') self.defaults = self.entity(1, 'NLM', 1, 'Title', 'The Title') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(content='other') self.assertDifference(name='other') self.assertDifference(seq=2) self.assertDifference(source='Publisher') # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') def testRequireExistingPmid(self): self.sess.add(Section(2, 'NLM', 1, 'Title', 'The Title')) self.assertRaises(IntegrityError, self.sess.commit) # SEQ def testRequireSeq(self): self.assertNonNullValue(TypeError, 'seq') def testRequirePositiveSeq(self): self.assertPositiveValue(AssertionError, 'seq') # NAME def testRequireSectionName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptySectionName(self): self.assertNonEmptyValue(AssertionError, 'name') # CONTENT def testRequireContent(self): self.assertNonNullValue(AssertionError, 'content') def testRequireNonEmptyContent(self): self.assertNonEmptyValue(AssertionError, 'content') # LABEL def testNonEmptyLabel(self): self.assertBadExtraValue(AssertionError, 'label', '') # METHODS def testToString(self): self.assertEqual('1\tNLM\t1\tTitle\tlabel\t"co\\n\\tent"\\\\\n', str(Section(1, 'NLM', 1, 'Title', "\"co\n\tent\"\\", 'label'))) def testToRepr(self): self.assertEqual('Section<1:NLM:1>', repr(Section(1, 'NLM', 1, 'Title', 'content', 'label'))) def testCitation(self): section = Section(1, 'NLM', 1, 'Abstract', 'The Abstract.') self.sess.add(section) self.sess.commit() self.assertListEqual([section], self.M.sections) self.assertEqual(self.M, section.citation)
class KeywordTest(TestCase, TestMixin): def setUp(self): InitDb(URI, module=dbapi2) self.sess = Session() self.M = DefaultCitation() self.sess.add(self.M) self.klass = Keyword self.entity = namedtuple('Keyword', 'pmid owner cnt name') self.defaults = self.entity(1, 'NASA', 1, 'keyword') def testCreate(self): self.assertCreate() def testEquals(self): self.assertSame() self.assertDifference(cnt=2) self.assertDifference(owner='NLM') self.assertDifference(name='other') self.assertNotEqual(Keyword(1, 'NASA', 1, 'name', True), Keyword(1, 'NASA', 1, 'name', False)) # PMID def testRequirePmid(self): self.assertNonNullValue(TypeError, 'pmid') # OWNER def testRequireOwner(self): self.assertNonNullValue(AssertionError, 'owner') def testRequireValidOwner(self): self.assertBadValue('WRONG', AssertionError, 'owner') # CNT def testRequireCnt(self): self.assertNonNullValue(TypeError, 'cnt') def testRequirePositiveCnt(self): self.assertPositiveValue(AssertionError, 'cnt') # NAME def testRequireName(self): self.assertNonNullValue(AssertionError, 'name') def testRequireNonEmptyName(self): self.assertNonEmptyValue(AssertionError, 'name') # MAJOR def testMajorIsBool(self): self.sess.add(Keyword(1, 'NLM', 1, 'name', None)) self.assertRaises(IntegrityError, self.sess.commit) # METHODS def testToString(self): self.assertEqual('1\tNASA\t1\tF\tname\n', str(Keyword(1, 'NASA', 1, 'name'))) self.assertEqual('1\tNASA\t1\tT\tname\n', str(Keyword(1, 'NASA', 1, 'name', True))) def testToRepr(self): self.assertEqual('Keyword<1:NASA:1>', repr(Keyword(1, 'NASA', 1, 'name'))) def testRelations(self): i = Keyword(1, 'NASA', 1, 'name') self.sess.add(i) self.sess.commit() self.assertEqual([i], self.M.keywords) self.assertEqual(self.M, i.citation)