def test_to_get_number_of_coAuthors(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "dblp_curated_sample.xml")))
self.assertEqual(db.get_coauthor_count("Stefano Ceri"),
('CoAuthor Count', 230))
def test_get_andys_list_cross_check(self):
db = database.Database()
db.read(path.join(self.data_dir, "dblp_curated_sample.xml"))
lAuth = db.get_paper_last_authors()
fAuth = db.get_paper_first_authors()
flAuth = db.get_paper_first_last_authors()
fAuthCnt = len(fAuth)
lAuthCnt = len(lAuth)
#print fAuthCnt
#print lAuthCnt
flAuthCnt_f = 0
flAuthCnt_l = 0
for fl in flAuth:
if fl[1] > 0:
flAuthCnt_f += 1
if fl[2] > 0:
flAuthCnt_l += 1
self.assertEqual(fAuthCnt, flAuthCnt_f)
self.assertEqual(lAuthCnt, flAuthCnt_l)
def test_bong(self):
db = database.Database()
db.read(path.join(self.data_dir, "dblp_2000_2005_114_papers.xml"))
pubs = db.publications
#head, data = db.separation(db.get_author_index("Stefano Ceri"), db.get_author_index("Piero Fraternali"))
#print db.get_author_index("Robert Haines")
#print db.get_author_index("Yeliz Yesilada")
# for a in db.get_all_authors_sorted():
# if 3 != a[0]:
# print db.separation(3, a[0])[1]
#for p in pubs:
# print "{0}: {1}".format(pubs.index(p), map(str,p.authors ))
#print db.get_all_authors()
head, data = db.separation(10, 11)
for p in pubs:
if 3 in p.authors and 91 in p.authors:
print "jO"
print data
def test_degrees_of_separation(self):
db = database.Database()
self.assertTrue(db.read(path.join(self.data_dir, "sprint4_task1.xml")))
self.assertEquals(db.degrees_of_separation("C", "D"), 1)
self.assertEquals(db.degrees_of_separation("A", "B"), 0)
self.assertEquals(db.degrees_of_separation("E", "C"), 2)
self.assertEquals(db.degrees_of_separation("A", "F"), 'X')
def test_search_part_name(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "dblp_curated_sample.xml")))
#Test case1: Test for search_part_name
#self.assertEqual(db.calculate_searchPartName("sam"),['Pedro R. Falcone Sampaio', 'Sandra de F. Mendes Sampaio', 'Fredrik Samson', 'Pierangela Samarati', 'Samuel Madden', 'Sam Guinea', 'Sandra Sampaio'])
self.assertTrue(db.read(path.join(self.data_dir, "sprint3_task3.xml")))
#self.assertEquals(db.calculate_searchPartName("sam"),['Alice Sam','Brian Sam','Alice Sammer','Brian Sammer','Alice Samming','Brian Samming',
# 'Brian Sam Alice','Sam Alice','Samuel Alice','Alice Sam Brian','Sam Brian','Samuel Brian',
# 'Alice Esam','Brian Esam'])
#self.assertEquals(db.calculate_searchPartName("sam"),['Alice Sam','Brian Sam','Alice Sammer','Brian Sammer','Alice Samming','Brian Samming',
# 'Sam Alice','Sam Brian','Samuel Alice','Samuel Brian'])
#self.assertEquals(db.calculate_searchPartName("sam"),['Alice Sam','Brian Sam','Alice Sammer','Brian Sammer','Alice Samming','Brian Samming',
# 'Sam Alice','Sam Brian','Samuel Alice','Samuel Brian','Brian Sam Alice','Alice Sam Brian'])
self.assertEquals(db.calculate_searchPartName("sam"), [
'Alice Sam', 'Brian Sam', 'Alice Sammer', 'Brian Sammer',
'Alice Samming', 'Brian Samming', 'Sam Alice', 'Sam Brian',
'Samuel Alice', 'Samuel Brian', 'Brian Sam Alice',
'Alice Sam Brian', 'Alice Esam', 'Brian Esam'
])
self.assertTrue(db.read(path.join(self.data_dir, "sprint3_final.xml")))
self.assertEquals(db.calculate_searchPartName("sam"), [
'Alice Sam', 'Brian Sam', 'Alice Sammer', 'Brian Sammer',
'Alice Samming', 'Brian Samming', 'Sam Alice', 'Sam Brian',
'Samuel Alice', 'Samuel Brian', 'Brian Sam Alice',
'Alice Sam Brian', 'Alice Esam', 'Brian Esam', 'Esam Alice',
'Esam Brian', 'Brian Esam Alice', 'Alice Esam Brian'
])
def test_searchAuthor(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "dblp_curated_sample.xml")))
self.assertEqual(db.calculate_searchAuthors("testName"),
(0, 0, 0, 0, 0, 0, 0, 0))
#Test case1: Number of publications
#self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),(10,0,0,0,0,0))
#Test case2: Number of conference papers
#self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),(10,6,0,0,0,0))
#Test case3: Number of journals
#self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),(10,6,3,0,0,0))
#Test case4: Number of book chapters
#self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),(10,6,3,0,0,0))
#Test case5: Number of books
#self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),(10,6,3,0,1,0,0,0))
#Test case6: Number of co-Authors
#self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),(10,6,3,0,1,15,0,0))
#Test case7: Number of first
#self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),(10,6,3,0,1,15,3,0))
#Test case8: Number of last
self.assertEqual(db.calculate_searchAuthors("Carlo Batini"),
(10, 6, 3, 0, 1, 15, 3, 5))
#Test case8: Test final
self.assertEqual(db.calculate_searchAuthors("Stefano Ceri"),
(218, 100, 94, 18, 6, 230, 78, 25))
def test_get_author_times3(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "sprint-2-acceptance-2.xml")))
header, data = db.get_author_times()
self.assertEqual(data, [[u'AUTHOR1', 2, 0, 1], [u'AUTHOR3', 0, 0, 0],
[u'AUTHOR4', 0, 2, 0], [u'AUTHOR2', 0, 0, 1]])
def test_get_author_search(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "dblp_curated_sample.xml")))
data = db.get_author_search('stefano ceri')
self.assertEqual(
data,
(('Details', 'overall', 'journal articles', 'conference papers',
'books', 'book chapters'),
[['Number of publications', 218, 94, 100, 6, 18],
['Number of times first author', 78, 43, 28, 3, 4],
['Number of times last author', 25, 10, 10, 0, 5],
['Number of times sole author', 8, 0, 7, 0, 1],
['Number of co-authors', 230], ['author name', 'Stefano Ceri']]))
#when an author is not found, a proper message should be returned
data = db.get_author_search('zxzxzxzxzx')
self.assertEqual(data, ("Author not found !", []))
#when the search functions return more than one matches, a list of names ONLY should be returned
data = db.get_author_search('sat')
self.assertEqual(
data,
("", [[u'Fabio Casati'], [u'Ulrike Sattler'], [u'Uli Sattler'],
[u'Satya Sanket Sahoo'], [u'Chisato Yamasaki']]))
def test_degrees_separation_graph(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "test_double_link.xml")))
data = db.get_degrees_graph('authorc', 'authord')
self.assertEqual(data, [['authorc', 'authorb', 'authord'],
['authorc', 'authorg', 'authord']])
def test_get_author_network(self):
db = database.Database()
self.assertTrue(db.read(path.join(self.data_dir, "simple.xml")))
self.assertEqual(
db.get_author_network('author1'), {
'directed':
False,
'graph': {},
'nodes': [{
'id': 0,
'colour': 0,
'name': 'author1',
'coauthors': 5.0
}, {
'id': 1,
'colour': 1,
'name': u'AUTHOR2',
'coauthors': 5.0
}],
'links': [{
'source': 0,
'target': 1
}],
'multigraph':
False
})
def test_summary(self):
db = database.Database()
self.assertTrue(db.read(path.join(self.data_dir, "simple.xml")))
self.assertEqual(
"OK", showPublicationSummary("publication_summary", "Y", db),
"FAILED")
self.assertEqual("OK",
showPublicationSummary("publication_author", "Y", db),
"FAILED")
self.assertEqual("OK",
showPublicationSummary("publication_year", "Y", db),
"FAILED")
self.assertEqual("OK", showPublicationSummary("author_year", "Y", db),
"FAILED")
self.assertEqual("OK", showPublicationSummary("author_number", "Y",
db), "FAILED")
self.assertEqual(
"OK", showPublicationSummary("author_number_journal", "Y", db),
"FAILED")
self.assertEqual(
"OK", showPublicationSummary("author_number_conference", "Y", db),
"FAILED")
self.assertEqual("OK",
showPublicationSummary("author_number_book", "Y", db),
"FAILED")
self.assertEqual(
"OK", showPublicationSummary("author_number_chapter", "Y", db),
"FAILED")
def test_get_none_first_last_sole(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "publications_small_sample.xml")))
data = db.get_none_first_last_sole()
self.assertEqual(data,
('Please choose a publication type !', []))
def test_get_average_authors_per_publication_by_year2(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "publications_small_sample.xml")))
_, data = db.get_average_authors_per_publication_by_year(
database.Stat.MEAN)
self.assertEqual(data[1][1], 0)
def test_calculate_first_last(self):
db = database.Database()
#testcase1 database = sprint-2-acceptance-1.xml
self.assertTrue(
db.read(path.join(self.data_dir, "sprint-2-acceptance-1.xml")))
self.assertEqual(
db.calculate_first_last_sole(),
(('Author', 'First Author', 'Last Author', 'Sole Author'),
[[u'AUTHOR1', 1, 1, 0], [u'AUTHOR2', 0, 1, 0],
[u'AUTHOR3', 0, 1, 0], [u'AUTHOR4', 2, 0, 0]]))
#testcase2 database = sprint-2-acceptance-2.xml
self.assertTrue(
db.read(path.join(self.data_dir, "sprint-2-acceptance-2.xml")))
self.assertEqual(
db.calculate_first_last_sole(),
(('Author', 'First Author', 'Last Author', 'Sole Author'),
[[u'AUTHOR1', 2, 0, 1], [u'AUTHOR3', 0, 0, 0],
[u'AUTHOR4', 0, 2, 0], [u'AUTHOR2', 0, 0, 1]]))
#testcase3 database = sprint-2-acceptance-3.xml
self.assertTrue(
db.read(path.join(self.data_dir, "sprint-2-acceptance-3.xml")))
self.assertEqual(
db.calculate_first_last_sole(),
(('Author', 'First Author', 'Last Author', 'Sole Author'),
[[u'AUTHOR', 0, 0, 9], [u'AUTHOR1', 0, 0, 1]]))
def test_sorting(self):
db = database.Database()
self.assertTrue(db.read(path.join(self.data_dir, "dblp_curated_sample.xml")))
#Test cases fo publications summary
data = db.get_publication_summary()
#Test case1: Test sorting of column Details
self.assertNotEquals(data,views.sorting(data, 1)) #case: sorted
self.assertEquals(data,views.sorting(data, 1)) #case: unSorted
#Test case2: Test sorting of column conf_papers
self.assertNotEquals(data,views.sorting(data, 2))
self.assertEquals(data,views.sorting(data, 2))
#Test case3: Test sorting of column journal
self.assertNotEquals(data,views.sorting(data, 3))
self.assertEquals(data,views.sorting(data, 3))
#Test case4: Test sorting of column book
self.assertNotEquals(data,views.sorting(data, 4))
self.assertEquals(data,views.sorting(data, 4))
#Test case5: Test sorting of column book_chapter
self.assertNotEquals(data,views.sorting(data, 5))
self.assertEquals(data,views.sorting(data, 5))
def test_get_author_separation_degree(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "separation degree tests.xml")))
found, degree = db.get_author_separation_degree(
'Stefano Ceri', 'Valeria De Antonellis', 0)
self.assertEqual(found, True, "Found output should be true")
self.assertEqual(degree, 1, "Incorrect separation degree calculated")
# print 'In test_get_author_separation_degree:: found boolean and separation degree are: '
# print found
# print degree
# one = 1
# self.assertEqual(one,2, "dumbass")
found, degree = db.get_author_separation_degree(
'Stefano Ceri', 'Krishna G. Kulkarni', 0)
self.assertEqual(found, True, "Found output should be true")
self.assertEqual(degree, 0, "Incorrect separation degree calculated")
found, degree = db.get_author_separation_degree(
'Stefano Ceri', 'abc', 0)
self.assertEqual(found, False, "Found output should be false")
self.assertEqual(degree, -1, "separation degree should be 0")
self.assertTrue(
db.read(path.join(self.data_dir, "publications_small_sample.xml")))
found, degree = db.get_author_separation_degree(
'Raghu Ramakrishnan', 'Simon Harper', 0)
print 'In test_get_author_separation_degree:: found boolean and separation degree are: '
print found
print degree
self.assertEqual(found, True, "Found output should be true")
self.assertEqual(degree, 0, "Incorrect separation degree calculated")
def test_get_col_order(self):
db = database.Database()
self.assertTrue(
db.read(
path.join(self.data_dir,
"three-authors-and-three-publications.xml")))
details = db.get_publications_by_author()
col = "Total"
order = "ascend"
one = 1
header, data = db.get_col_order(col, order, details)
self.assertEqual(data, [[u'Valeria De Antonellis', 1, 0, 0, 0, 1],
[u'Krishna G. Kulkarni', 1, 0, 0, 0, 1],
[u'Stefano Ceri', 2, 0, 0, 0, 2]])
self.assertNotEqual(data, [[u'Stefano Ceri', 2, 0, 0, 0, 2],
[u'Valeria De Antonellis', 1, 0, 0, 0, 1],
[u'Krishna G. Kulkarni', 1, 0, 0, 0, 1]])
order = "descend"
header, data = db.get_col_order(col, order, details)
self.assertEqual(data, [[u'Stefano Ceri', 2, 0, 0, 0, 2],
[u'Valeria De Antonellis', 1, 0, 0, 0, 1],
[u'Krishna G. Kulkarni', 1, 0, 0, 0, 1]])
self.assertNotEqual(data, [[u'Stefano Ceri', 2, 0, 0, 0, 2],
[u'Krishna G. Kulkarni', 1, 0, 0, 0, 1],
[u'Valeria De Antonellis', 1, 0, 0, 0, 1]])
col = "Number of conference papers"
header, data = db.get_col_order(col, order, details)
self.assertEqual(data, [[u'Stefano Ceri', 2, 0, 0, 0, 2],
[u'Valeria De Antonellis', 1, 0, 0, 0, 1],
[u'Krishna G. Kulkarni', 1, 0, 0, 0, 1]])
self.assertNotEqual(data, [[u'Krishna G. Kulkarni', 1, 0, 0, 0, 1],
[u'Valeria De Antonellis', 1, 0, 0, 0, 1],
[u'Stefano Ceri', 2, 0, 0, 0, 2]])
def test_get_information_by_author_2(self):
db = database.Database()
self.assertTrue(
db.read(
path.join(self.data_dir,
"three-authors-and-three-publications.xml")))
header, data = db.get_information_by_author('author3')
self.assertEqual(data, [['author3', 1, 1, 0, 0, 0, 0, 0, 0, 1]])
def test_get_publications_by_year(self):
db = database.Database()
self.assertTrue(db.read(path.join(self.data_dir, "simple.xml")))
header, data = db.get_publications_by_year()
self.assertEqual(len(header), len(data[0]),
"header and data column size doesn't match")
self.assertEqual(len(data), 1, "incorrect number of rows")
self.assertEqual(data[0][0], 9999, "incorrect year in result")
def test_get_publications_by_author(self):
db = database.Database()
self.assertTrue(db.read(path.join(self.data_dir, "simple.xml")))
header, data = db.get_publications_by_author()
self.assertEqual(len(header), len(data[0]),
"header and data column size doesn't match")
self.assertEqual(len(data), 2, "incorrect number of authors")
self.assertEqual(data[0][-1], 1, "incorrect total")
def test_get_author_search(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "publications_small_sample.xml")))
header, data = db.get_author_search('Carole A. Goble')
self.assertEqual(data, [u'Carole A. Goble'])
data = db.get_author_search('zzzzzzz')
self.assertEqual(data, ['Result not found'])
def test_get_all_authors(self):
db = database.Database()
self.assertTrue(
db.read(
path.join(self.data_dir,
"three-authors-and-three-publications.xml")))
data = db.get_all_authors()
self.assertEqual(data, ['author1', 'author2', 'author3'])
def test_get_degree_of_separation(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "sprint-2-acceptance-1.xml")))
self.assertEqual(db.get_degree_of_separation('AUTHOR1', 'AUTHOR2'),
(0))
self.assertEqual(db.get_degree_of_separation('AUTHOR3', 'AUTHOR4'),
(1))
def test_get_publication_summary_average2(self):
db = database.Database()
self.assertTrue(
db.read(
path.join(self.data_dir,
"three-authors-and-three-publications.xml")))
_, data = db.get_publication_summary_average(database.Stat.MEDIAN)
self.assertEqual(data[0][3], 0)
def test_to_get_number_of_authors_appear_last(self):
db = database.Database()
self.assertTrue(
db.read(path.join(self.data_dir, "dblp_curated_sample.xml")))
self.assertEqual(
db.get_count_author_appears_last_overall("Stefano Ceri"),
('Overall Count of last appearence', 33))
def test_get_publication_summary(self): db = database.Database() self.assertTrue(db.read(path.join(self.data_dir,"dblp_curated_sample.xml"))) header, data = db.get_publication_summary() self.assertEqual(len(header),len(data[0]), "header and data column size doesn't match") self.assertEqual(len(data[0]),6, "incorrect number of column in data")
def test_get_coauthor_details(self):
db = database.Database()
self.assertTrue(
db.read(
path.join(self.data_dir,
"three-authors-and-three-publications.xml")))
header, data = db.get_coauthor_details('author1')
self.assertEqual(data, (u'author2', 1))
def test_get_author_totals_by_appearingtimes(self):
db = database.Database()
self.assertTrue(db.read(path.join(self.data_dir,"dblp_curated_sample.xml")))
header, data = db.get_author_totals_by_appearingtimes()
self.assertEqual(len(header),len(data[0]),
"header and data column size doesn't match")
self.assertEqual(data[0][1], 86,
"incorrect number of authors in result")
def test_get_author_times_type2(self):
db = database.Database()
self.assertTrue(
db.read(
path.join(self.data_dir,
"three-authors-and-three-publications.xml")))
header, data = db.get_author_times_type('author1')
self.assertEqual(data, [[u'author1', 0, 0, 0], [u'author2', 0, 0, 0],
[u'author3', 0, 0, 0]])
def test_get_coauthor_details(self):
db = database.Database()
self.assertTrue(
db.read(
path.join(self.data_dir,
"three-authors-and-three-publications.xml")))
data = db.get_all_authors()
result = db.get_coauthor_details(data[1])
self.assertEqual(result, [('author1', 1), ('author2', 1)])
