def main():
if len(sys.argv) < 4:
usage()
exit()
db = TahrirDatabase(sys.argv[1])
issuer_id = db.add_issuer(
"http://coderwall.com",
"coderwall",
"http://coderwall.com",
"*****@*****.**"
)
db.add_person(hash(sys.argv[3]), sys.argv[3])
cw = CoderWall(sys.argv[2])
for badge in cw.badges:
db.add_badge(
badge.name,
badge.image_uri,
badge.description,
"http://coderwall.com",
issuer_id)
db.add_assertion(
badge.name.lower(),
sys.argv[3],
None
)
print "Awarded {0} badges to {1}".format(len(cw.badges), sys.argv[3])
class TestRanking(object):
def setUp(self):
check_output(['touch', 'testdb.db'])
sqlalchemy_uri = "sqlite:///testdb.db"
engine = create_engine(sqlalchemy_uri)
DBSession.configure(bind=engine)
DeclarativeBase.metadata.create_all(engine)
self.api = TahrirDatabase(sqlalchemy_uri)
self._create_test_data()
def tearDown(self):
check_output(['rm', 'testdb.db'])
def _create_test_data(self):
issuer_id = self.api.add_issuer(
"TestOrigin",
"TestName",
"TestOrg",
"TestContact"
)
self.badge_id_1 = self.api.add_badge(
"TestBadge1",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
self.badge_id_2 = self.api.add_badge(
"TestBadge2",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
self.badge_id_3 = self.api.add_badge(
"TestBadge3",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
self.email_1 = "*****@*****.**"
person_id_1 = self.api.add_person(self.email_1)
self.email_2 = "*****@*****.**"
person_id_2 = self.api.add_person(self.email_2)
self.email_3 = "*****@*****.**"
person_id_3 = self.api.add_person(self.email_3)
self.email_4 = "*****@*****.**"
person_id_4 = self.api.add_person(self.email_4)
def test_ranking_simple(self):
self.api.add_assertion(self.badge_id_1, self.email_1, None)
self.api.add_assertion(self.badge_id_1, self.email_4, None)
self.api.add_assertion(self.badge_id_2, self.email_4, None)
self.api.add_assertion(self.badge_id_3, self.email_4, None)
person1 = self.api.get_person("*****@*****.**")
person4 = self.api.get_person("*****@*****.**")
eq_(person1.rank, 2)
eq_(person4.rank, 1)
def test_ranking_tie(self):
self.api.add_assertion(self.badge_id_1, self.email_1, None)
self.api.add_assertion(self.badge_id_1, self.email_2, None)
self.api.add_assertion(self.badge_id_2, self.email_2, None)
self.api.add_assertion(self.badge_id_1, self.email_3, None)
self.api.add_assertion(self.badge_id_2, self.email_3, None)
self.api.add_assertion(self.badge_id_1, self.email_4, None)
self.api.add_assertion(self.badge_id_2, self.email_4, None)
self.api.add_assertion(self.badge_id_3, self.email_4, None)
person1 = self.api.get_person("*****@*****.**")
person2 = self.api.get_person("*****@*****.**")
person3 = self.api.get_person("*****@*****.**")
person4 = self.api.get_person("*****@*****.**")
eq_(person1.rank, 4)
eq_(person2.rank, 2)
eq_(person3.rank, 2)
eq_(person4.rank, 1)
def test_ranking_preexisting(self):
""" Test that rank updating works for pre-existant users """
person1 = self.api.get_person("*****@*****.**")
new_assertion1 = Assertion(
badge_id=self.badge_id_1,
person_id=person1.id,
)
self.api.session.add(new_assertion1)
new_assertion2 = Assertion(
badge_id=self.badge_id_2,
person_id=person1.id,
)
self.api.session.add(new_assertion2)
self.api.session.flush()
# For persons who existed *before* we added cached ranks, they should
# have a null-rank.
eq_(person1.rank, None)
# But once *anyone* else gets a badge, old ranks should be updated too.
self.api.add_assertion(self.badge_id_1, self.email_2, None)
eq_(person1.rank, 1)
person2 = self.api.get_person("*****@*****.**")
eq_(person2.rank, 2)
# but people with no badges should still be null ranked.
person3 = self.api.get_person("*****@*****.**")
eq_(person3.rank, None)
def test_ranking_with_time_limits(self):
self.api.add_assertion(self.badge_id_1, self.email_1, yesterday)
self.api.add_assertion(self.badge_id_1, self.email_4, yesterday)
self.api.add_assertion(self.badge_id_2, self.email_4, one_week_ago)
self.api.add_assertion(self.badge_id_3, self.email_4, one_month_ago)
person1 = self.api.get_person("*****@*****.**")
person4 = self.api.get_person("*****@*****.**")
epsilon = datetime.timedelta(hours=1)
results = self.api._make_leaderboard(yesterday - epsilon, now)
eq_(results[person1]['badges'], 1)
eq_(results[person4]['badges'], 1)
results = self.api._make_leaderboard(one_week_ago - epsilon, now)
eq_(results[person1]['badges'], 1)
eq_(results[person4]['badges'], 2)
results = self.api._make_leaderboard(one_month_ago - epsilon, now)
eq_(results[person1]['badges'], 1)
eq_(results[person4]['badges'], 3)
class FedoraBadgesConsumer(FedmsgConsumer):
"""
The Base class for creating fedmsg consumers that issue open badges
Provides a base that does all of the heavy lifting related to issuing badges.
All the subclass needs to do is have a topic, a name, and implement consume(self, msg)
:type hub: Moksha Hub
:param hub: the moksha hub we are getting our messages from
:type name: str
:param name: name of this consumer, used to get details from the config file
"""
def __init__(self, hub, name):
self.name = name
self.badges = {}
self.hub = hub
self.DBSession = None
ENABLED = "fedmsg.consumers.badges.{0}.enabled".format(self.name)
if not asbool(hub.config.get(ENABLED, False)):
log.info("fedmsg.consumers.badges.{0} disabled".format(self.name))
return
global_settings = hub.config.get("badges_global")
database_uri = global_settings.get("database_uri", "")
if database_uri == "":
raise Exception("Badges consumer requires a database uri")
return
self.tahrir = TahrirDatabase(database_uri)
self.DBSession = self.tahrir.session_maker
issuer = global_settings.get("badge_issuer")
self.issuer_id = self.tahrir.add_issuer(
issuer.get("issuer_origin"),
issuer.get("issuer_name"),
issuer.get("issuer_org"),
issuer.get("issuer_contact"),
)
badges_settings = hub.config.get("{0}_badges".format(self.name))
for badge in badges_settings:
self.tahrir.add_badge(
badge.get("badge_name"),
badge.get("badge_image"),
badge.get("badge_desc"),
badge.get("badge_criteria"),
self.issuer_id,
)
return super(FedoraBadgesConsumer, self).__init__(hub)
def award_badge(self, email, badge_id, issued_on=None):
"""
A high level way to issue a badge to a Person
It adds the person if they don't exist, and creates an assertion for them
:type email: str
:param email: This person's email addr
:type badge_id: str
:param badge_id: the id of the badge being awarded
:type issued_on: DateTime
:param issued_on: A datetime object with the time this badge was issued
"""
self.tahrir.add_person(email)
self.tahrir.add_assertion(badge_id, email, issued_on)
def consume(self, msg):
"""
Consume a single message, we pass here because every subclass is going
to want to parse this slightly differently
:type msg: dict
:param msg: The message to be parsed
"""
pass
class TestDBInit(object):
def setUp(self):
check_output(['touch', 'testdb.db'])
sqlalchemy_uri = "sqlite:///testdb.db"
engine = create_engine(sqlalchemy_uri)
DBSession.configure(bind=engine)
DeclarativeBase.metadata.create_all(engine)
self.callback_calls = []
self.api = TahrirDatabase(
sqlalchemy_uri,
notification_callback=self.callback)
def callback(self, *args, **kwargs):
self.callback_calls.append((args, kwargs))
def test_add_badges(self):
self.api.add_badge(
"TestBadge",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
1337
)
assert self.api.badge_exists("testbadge") is True
def test_add_team(self):
self.api.create_team("TestTeam")
assert self.api.team_exists("testteam") is True
def test_add_series(self):
team_id = self.api.create_team("TestTeam")
self.api.create_series("TestSeries",
"A test series",
team_id,
"test, series")
assert self.api.series_exists("testseries") is True
def test_add_milestone(self):
team_id = self.api.create_team("TestTeam")
series_id = self.api.create_series("TestSeries",
"A test series",
team_id,
"test, series")
badge_id_1 = self.api.add_badge(
"TestBadge-1",
"TestImage-2",
"A test badge for doing 10 unit tests",
"TestCriteria",
1337
)
badge_id_2 = self.api.add_badge(
"TestBadge-2",
"TestImage-2",
"A test badge for doing 100 unit tests",
"TestCriteria",
1337
)
milestone_id_1 = self.api.create_milestone(1,
badge_id_1,
series_id)
milestone_id_2 = self.api.create_milestone(2,
badge_id_2,
series_id)
assert self.api.milestone_exists(milestone_id_1) is True
assert self.api.milestone_exists(milestone_id_2) is True
def test_add_person(self):
self.api.add_person("*****@*****.**")
assert self.api.person_exists("*****@*****.**") is True
def test_add_issuer(self):
_id = self.api.add_issuer(
"TestOrigin",
"TestName",
"TestOrg",
"TestContact"
)
assert self.api.issuer_exists("TestOrigin", "TestName") is True
def test_add_invitation(self):
badge_id = self.api.add_badge(
"TestBadge",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
1337
)
_id = self.api.add_invitation(
badge_id,
)
assert self.api.invitation_exists(_id)
def test_last_login(self):
email = "*****@*****.**"
person_id = self.api.add_person(email)
person = self.api.get_person(person_id)
assert not person.last_login
self.api.note_login(nickname=person.nickname)
assert person.last_login
def test_add_assertion(self):
issuer_id = self.api.add_issuer(
"TestOrigin",
"TestName",
"TestOrg",
"TestContact"
)
badge_id = self.api.add_badge(
"TestBadge",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
email = "*****@*****.**"
person_id = self.api.add_person(email)
assertion_id = self.api.add_assertion(badge_id, email, None, 'link')
assert self.api.assertion_exists(badge_id, email)
badge = self.api.get_badge(badge_id)
assert badge.assertions[0].issued_for == 'link'
# Ensure that we would have published two fedmsg messages for that.
assert len(self.callback_calls) == 2
# Ensure that the first message had a 'badge_id' in the message.
assert 'badge_id' in self.callback_calls[0][1]['msg']['badge']
def test_get_badges_from_tags(self):
issuer_id = self.api.add_issuer(
"TestOrigin",
"TestName",
"TestOrg",
"TestContact"
)
# Badge tagged with "test"
self.api.add_badge(
"TestBadgeA",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="test"
)
# Badge tagged with "tester"
self.api.add_badge(
"TestBadgeB",
"TestImage",
"A second test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="tester"
)
# Badge tagged with both "test" and "tester"
self.api.add_badge(
"TestBadgeC",
"TestImage",
"A third test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="test, tester"
)
tags = ['test', 'tester']
badges_any = self.api.get_badges_from_tags(tags, match_all=False)
assert len(badges_any) == 3
badges_all = self.api.get_badges_from_tags(tags, match_all=True)
assert len(badges_all) == 1
def tearDown(self):
check_output(['rm', 'testdb.db'])
self.callback_calls = []
from tahrir_api.dbapi import TahrirDatabase
db = TahrirDatabase('backend://*****:*****@localhost/badges')
origin = 'http://foss.rit.edu/badges'
issuer_name = 'FOSS@RIT'
org = 'http://foss.rit.edu'
contact = '*****@*****.**'
issuer_id = db.add_issuer(origin, issuer_name, org, contact)
badge_name = 'fossbox'
image = 'http://foss.rit.edu/files/fossboxbadge.png'
desc = 'Welcome to the FOSSBox. A member is you!'
criteria = 'http://foss.rit.edu'
db.add_badge(badge_name, image, desc, criteria, issuer_id)
from tahrir_api.dbapi import TahrirDatabase
db = TahrirDatabase("backend://*****:*****@localhost/badges")
origin = "http://foss.rit.edu/badges"
issuer_name = "FOSS@RIT"
org = "http://foss.rit.edu"
contact = "*****@*****.**"
issuer_id = db.add_issuer(origin, issuer_name, org, contact)
badge_name = "fossbox"
image = "http://foss.rit.edu/files/fossboxbadge.png"
desc = "Welcome to the FOSSBox. A member is you!"
criteria = "http://foss.rit.edu"
db.add_badge(badge_name, image, desc, criteria, issuer_id)
class FedoraBadgesConsumer(FedmsgConsumer):
"""
The Base class for creating fedmsg consumers that issue open badges
Provides a base that does all of the heavy lifting related to issuing badges.
All the subclass needs to do is have a topic, a name, and implement consume(self, msg)
:type hub: Moksha Hub
:param hub: the moksha hub we are getting our messages from
:type name: str
:param name: name of this consumer, used to get details from the config file
"""
def __init__(self, hub, name):
self.name = name
self.badges = {}
self.hub = hub
self.DBSession = None
ENABLED = 'fedmsg.consumers.badges.{0}.enabled'.format(self.name)
if not asbool(hub.config.get(ENABLED, False)):
log.info('fedmsg.consumers.badges.{0} disabled'.format(self.name))
return
global_settings = hub.config.get("badges_global")
database_uri = global_settings.get('database_uri', '')
if database_uri == '':
raise Exception('Badges consumer requires a database uri')
return
self.tahrir = TahrirDatabase(database_uri)
self.DBSession = self.tahrir.session_maker
issuer = global_settings.get('badge_issuer')
self.issuer_id = self.tahrir.add_issuer(issuer.get('issuer_origin'),
issuer.get('issuer_name'),
issuer.get('issuer_org'),
issuer.get('issuer_contact'))
badges_settings = hub.config.get("{0}_badges".format(self.name))
for badge in badges_settings:
self.tahrir.add_badge(badge.get('badge_name'),
badge.get('badge_image'),
badge.get('badge_desc'),
badge.get('badge_criteria'), self.issuer_id)
return super(FedoraBadgesConsumer, self).__init__(hub)
def award_badge(self, email, badge_id, issued_on=None):
"""
A high level way to issue a badge to a Person
It adds the person if they don't exist, and creates an assertion for them
:type email: str
:param email: This person's email addr
:type badge_id: str
:param badge_id: the id of the badge being awarded
:type issued_on: DateTime
:param issued_on: A datetime object with the time this badge was issued
"""
self.tahrir.add_person(email)
self.tahrir.add_assertion(badge_id, email, issued_on)
def consume(self, msg):
"""
Consume a single message, we pass here because every subclass is going
to want to parse this slightly differently
:type msg: dict
:param msg: The message to be parsed
"""
pass
class TestDBInit(object):
def setUp(self):
check_output(['touch', 'testdb.db'])
sqlalchemy_uri = "sqlite:///testdb.db"
engine = create_engine(sqlalchemy_uri)
DBSession.configure(bind=engine)
DeclarativeBase.metadata.create_all(engine)
self.callback_calls = []
self.api = TahrirDatabase(sqlalchemy_uri,
notification_callback=self.callback)
def callback(self, *args, **kwargs):
self.callback_calls.append((args, kwargs))
def test_add_badges(self):
self.api.add_badge("TestBadge", "TestImage",
"A test badge for doing unit tests", "TestCriteria",
1337)
assert self.api.badge_exists("testbadge") is True
def test_add_team(self):
self.api.create_team("TestTeam")
assert self.api.team_exists("testteam") is True
def test_add_series(self):
team_id = self.api.create_team("TestTeam")
self.api.create_series("TestSeries", "A test series", team_id,
"test, series")
assert self.api.series_exists("testseries") is True
def test_add_milestone(self):
team_id = self.api.create_team("TestTeam")
series_id = self.api.create_series("TestSeries", "A test series",
team_id, "test, series")
badge_id_1 = self.api.add_badge(
"TestBadge-1", "TestImage-2",
"A test badge for doing 10 unit tests", "TestCriteria", 1337)
badge_id_2 = self.api.add_badge(
"TestBadge-2", "TestImage-2",
"A test badge for doing 100 unit tests", "TestCriteria", 1337)
milestone_id_1 = self.api.create_milestone(1, badge_id_1, series_id)
milestone_id_2 = self.api.create_milestone(2, badge_id_2, series_id)
assert self.api.milestone_exists(milestone_id_1) is True
assert self.api.milestone_exists(milestone_id_2) is True
def test_add_person(self):
self.api.add_person("*****@*****.**")
assert self.api.person_exists("*****@*****.**") is True
def test_add_issuer(self):
_id = self.api.add_issuer("TestOrigin", "TestName", "TestOrg",
"TestContact")
assert self.api.issuer_exists("TestOrigin", "TestName") is True
def test_add_invitation(self):
badge_id = self.api.add_badge("TestBadge", "TestImage",
"A test badge for doing unit tests",
"TestCriteria", 1337)
_id = self.api.add_invitation(badge_id, )
assert self.api.invitation_exists(_id)
def test_last_login(self):
email = "*****@*****.**"
person_id = self.api.add_person(email)
person = self.api.get_person(person_id)
assert not person.last_login
self.api.note_login(nickname=person.nickname)
assert person.last_login
def test_add_assertion(self):
issuer_id = self.api.add_issuer("TestOrigin", "TestName", "TestOrg",
"TestContact")
badge_id = self.api.add_badge(
"TestBadge",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
email = "*****@*****.**"
person_id = self.api.add_person(email)
assertion_id = self.api.add_assertion(badge_id, email, None, 'link')
assert self.api.assertion_exists(badge_id, email)
badge = self.api.get_badge(badge_id)
assert badge.assertions[0].issued_for == 'link'
# Ensure that we would have published two fedmsg messages for that.
assert len(self.callback_calls) == 2
# Ensure that the first message had a 'badge_id' in the message.
assert 'badge_id' in self.callback_calls[0][1]['msg']['badge']
def test_get_badges_from_tags(self):
issuer_id = self.api.add_issuer("TestOrigin", "TestName", "TestOrg",
"TestContact")
# Badge tagged with "test"
self.api.add_badge("TestBadgeA",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="test")
# Badge tagged with "tester"
self.api.add_badge("TestBadgeB",
"TestImage",
"A second test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="tester")
# Badge tagged with both "test" and "tester"
self.api.add_badge("TestBadgeC",
"TestImage",
"A third test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="test, tester")
tags = ['test', 'tester']
badges_any = self.api.get_badges_from_tags(tags, match_all=False)
assert len(badges_any) == 3
badges_all = self.api.get_badges_from_tags(tags, match_all=True)
assert len(badges_all) == 1
def tearDown(self):
check_output(['rm', 'testdb.db'])
self.callback_calls = []
class TestRanking(object):
def setUp(self):
check_output(['touch', 'testdb.db'])
sqlalchemy_uri = "sqlite:///testdb.db"
engine = create_engine(sqlalchemy_uri)
DBSession.configure(bind=engine)
DeclarativeBase.metadata.create_all(engine)
self.api = TahrirDatabase(sqlalchemy_uri)
self._create_test_data()
def tearDown(self):
check_output(['rm', 'testdb.db'])
def _create_test_data(self):
issuer_id = self.api.add_issuer("TestOrigin", "TestName", "TestOrg",
"TestContact")
self.badge_id_1 = self.api.add_badge(
"TestBadge1",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
self.badge_id_2 = self.api.add_badge(
"TestBadge2",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
self.badge_id_3 = self.api.add_badge(
"TestBadge3",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
self.email_1 = "*****@*****.**"
person_id_1 = self.api.add_person(self.email_1)
self.email_2 = "*****@*****.**"
person_id_2 = self.api.add_person(self.email_2)
self.email_3 = "*****@*****.**"
person_id_3 = self.api.add_person(self.email_3)
self.email_4 = "*****@*****.**"
person_id_4 = self.api.add_person(self.email_4)
def test_ranking_simple(self):
self.api.add_assertion(self.badge_id_1, self.email_1, None)
self.api.add_assertion(self.badge_id_1, self.email_4, None)
self.api.add_assertion(self.badge_id_2, self.email_4, None)
self.api.add_assertion(self.badge_id_3, self.email_4, None)
person1 = self.api.get_person("*****@*****.**")
person4 = self.api.get_person("*****@*****.**")
eq_(person1.rank, 2)
eq_(person4.rank, 1)
def test_ranking_tie(self):
self.api.add_assertion(self.badge_id_1, self.email_1, None)
self.api.add_assertion(self.badge_id_1, self.email_2, None)
self.api.add_assertion(self.badge_id_2, self.email_2, None)
self.api.add_assertion(self.badge_id_1, self.email_3, None)
self.api.add_assertion(self.badge_id_2, self.email_3, None)
self.api.add_assertion(self.badge_id_1, self.email_4, None)
self.api.add_assertion(self.badge_id_2, self.email_4, None)
self.api.add_assertion(self.badge_id_3, self.email_4, None)
person1 = self.api.get_person("*****@*****.**")
person2 = self.api.get_person("*****@*****.**")
person3 = self.api.get_person("*****@*****.**")
person4 = self.api.get_person("*****@*****.**")
eq_(person1.rank, 4)
eq_(person2.rank, 2)
eq_(person3.rank, 2)
eq_(person4.rank, 1)
def test_ranking_preexisting(self):
""" Test that rank updating works for pre-existant users """
person1 = self.api.get_person("*****@*****.**")
new_assertion1 = Assertion(
badge_id=self.badge_id_1,
person_id=person1.id,
)
self.api.session.add(new_assertion1)
new_assertion2 = Assertion(
badge_id=self.badge_id_2,
person_id=person1.id,
)
self.api.session.add(new_assertion2)
self.api.session.flush()
# For persons who existed *before* we added cached ranks, they should
# have a null-rank.
eq_(person1.rank, None)
# But once *anyone* else gets a badge, old ranks should be updated too.
self.api.add_assertion(self.badge_id_1, self.email_2, None)
eq_(person1.rank, 1)
person2 = self.api.get_person("*****@*****.**")
eq_(person2.rank, 2)
# but people with no badges should still be null ranked.
person3 = self.api.get_person("*****@*****.**")
eq_(person3.rank, None)
def test_ranking_with_time_limits(self):
self.api.add_assertion(self.badge_id_1, self.email_1, yesterday)
self.api.add_assertion(self.badge_id_1, self.email_4, yesterday)
self.api.add_assertion(self.badge_id_2, self.email_4, one_week_ago)
self.api.add_assertion(self.badge_id_3, self.email_4, one_month_ago)
person1 = self.api.get_person("*****@*****.**")
person4 = self.api.get_person("*****@*****.**")
epsilon = datetime.timedelta(hours=1)
results = self.api._make_leaderboard(yesterday - epsilon, now)
eq_(results[person1]['badges'], 1)
eq_(results[person4]['badges'], 1)
results = self.api._make_leaderboard(one_week_ago - epsilon, now)
eq_(results[person1]['badges'], 1)
eq_(results[person4]['badges'], 2)
results = self.api._make_leaderboard(one_month_ago - epsilon, now)
eq_(results[person1]['badges'], 1)
eq_(results[person4]['badges'], 3)
class TestDBInit(object):
def setUp(self):
check_output(['touch', 'testdb.db'])
sqlalchemy_uri = "sqlite:///testdb.db"
engine = create_engine(sqlalchemy_uri)
DBSession.configure(bind=engine)
DeclarativeBase.metadata.create_all(engine)
self.api = TahrirDatabase(sqlalchemy_uri)
def test_add_badges(self):
self.api.add_badge(
"TestBadge",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
1337
)
assert self.api.badge_exists("testbadge") is True
def test_add_person(self):
self.api.add_person("*****@*****.**")
assert self.api.person_exists("*****@*****.**") is True
def test_add_issuer(self):
_id = self.api.add_issuer(
"TestOrigin",
"TestName",
"TestOrg",
"TestContact"
)
assert self.api.issuer_exists("TestOrigin", "TestName") is True
def test_add_invitation(self):
badge_id = self.api.add_badge(
"TestBadge",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
1337
)
_id = self.api.add_invitation(
badge_id,
)
assert self.api.invitation_exists(_id)
def test_last_login(self):
email = "*****@*****.**"
person_id = self.api.add_person(email)
person = self.api.get_person(person_id)
assert not person.last_login
self.api.note_login(nickname=person.nickname)
assert person.last_login
def test_add_assertion(self):
issuer_id = self.api.add_issuer(
"TestOrigin",
"TestName",
"TestOrg",
"TestContact"
)
badge_id = self.api.add_badge(
"TestBadge",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
)
email = "*****@*****.**"
person_id = self.api.add_person(email)
assertion_id = self.api.add_assertion(badge_id, email, None)
assert self.api.assertion_exists(badge_id, email)
def test_get_badges_from_tags(self):
issuer_id = self.api.add_issuer(
"TestOrigin",
"TestName",
"TestOrg",
"TestContact"
)
# Badge tagged with "test"
self.api.add_badge(
"TestBadgeA",
"TestImage",
"A test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="test"
)
# Badge tagged with "tester"
self.api.add_badge(
"TestBadgeB",
"TestImage",
"A second test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="tester"
)
# Badge tagged with both "test" and "tester"
self.api.add_badge(
"TestBadgeC",
"TestImage",
"A third test badge for doing unit tests",
"TestCriteria",
issuer_id,
tags="test, tester"
)
tags = ['test', 'tester']
badges_any = self.api.get_badges_from_tags(tags, match_all=False)
assert len(badges_any) == 3
badges_all = self.api.get_badges_from_tags(tags, match_all=True)
assert len(badges_all) == 1
def tearDown(self):
check_output(['rm', 'testdb.db'])
