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.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 TahrirRestApp(object): def __init__(self, dburi, salt): self.dburi = dburi self.salt = salt self.database = TahrirDatabase(self.dburi) self.app = Flask(__name__) self.routes = { "/badges/<uid>": (self.badges_uid, {'methods': ['GET', 'DELETE']}), "/badges/": (self.add_badge, {'methods': ['POST']}), "/people/<uid>": (self.people, {'methods': ['GET', 'DELETE']}), "/people/": (self.add_person, {'methods': ['POST']}), "/issuers/<uid>": (self.issuers, {'methods': ['GET', 'DELETE']}), "/issuers/": (self.add_issuer, {'methods': ['POST']}), "/assertions/<email>": (self.assertions, {'methods': ['GET']}), "/assertions/": (self.add_assertion, {'methods': ['POST']}), } map( lambda route: self.app.route(route, **self.routes[route][1])( self.routes[route][0] ), self.routes ) def people(self, uid): """ GET: /people/<uid> Delete: /people/<uid> Get info on a person, or delete them """ if request.method == 'DELETE': result = self.database.delete_person(uid) if result != False: log.info("DELETE Request for /people/{0} succeeded".format(uid)) return json.dumps({'success': True, 'id': result}) else: log.info("DELETE Request for /people/{0} failed",format(uid)) return json.dumps({'success': False, 'id': uid}) if request.method == 'GET': person = self.database.get_person(uid) if person == None: log.info("GET request for /people/{0} failed".format(uid)) return json.dumps({}) else: log.info("GET request for /people/{0} suceeded".format(uid)) return json.dumps(person.__json__()) def add_person(self): """ POST: /people/ Add a new Person """ try: data = json.loads(request.data) except: log.info("add_person Failed: could not parse request.data") abort(503) try: result = self.database.add_person( hash(data['email']), data['email'] ) log.info("Added Person: {0}".format(data['email'])) return json.dumps({'email': result}) except KeyError: log.info("add_person Failed: JSON doesn't include all required fields") abort(503) def badges_uid(self, uid): """ GET: /badges/<uid> DELETE: /badges/<uid> return s a JSON blob with all the badge attributes Deletes a badge with the given uid """ if request.method == 'DELETE': result = self.database.delete_badge(uid) if result != False: log.info("DELETE Request for /badges/{0} suceeded".format(uid)) return json.dumps({'success': True, 'id': result}) else: log.info("DELETE Request for /badges/{0} failed".format(uid)) return json.dumps({'success': False, 'id': uid}) if request.method == 'GET': badge = self.database.get_badge(uid) if badge == None: log.info("GET Request for /badges/{0} failed".format(uid)) return json.dumps({}) else: log.info("GET Request for /badges/{0} succeeded".format(uid)) return json.dumps(badge.__json__()) def add_badge(self): """ POST: /badges accepts a json blob with all the badge attributes """ try: data = json.loads(request.data) except: log.info("add_badge Failed: Could not parse request.data") abort(503) try: badge_id = self.database.add_badge( data['name'], data['image'], data['desc'], data['criteria'], data['issuer_id'] ) log.info("Added Badge: {0}".format(data['name'])) return json.dumps({'id': badge_id}) except KeyError: log.info("add_badge Failed: JSON does not have required fields") abort(503) def issuers(self, uid): """ GET /issuers/<id> DELETE /issuers/<id> Delete or Get an issuer """ if request.method == 'GET': issuer = self.database.get_issuer(uid) if issuer == None: log.info('GET Request for /issuers/{0} failed'.format(uid)) return json.dumps({}) else: log.info('Get Request for /issuers/{0} succeeded'.format(uid)) return json.dumps(issuer.__json__()) if request.method == 'DELETE': result = self.database.delete_issuer(uid) if result != False: log.info("DELETE Request for /issuers/{0} suceeded".format(uid)) return json.dumps({'success': True, 'id': uid}) else: log.info('DELETE Request for /issuers/{0} failed'.format(uid)) return json.dumps({'success': False, 'id': uid}) def add_issuer(self): """ POST /issuers/ Add a new issuer """ try: data = json.loads(request.data) except: log.info("add_issuer Failed: Could not parse request.data") abort(503) try: issuer_id = self.database.add_badge( data['origin'], data['name'], data['org'], data['contact'] ) log.info("Added issuer: {0}".format(data['name'])) return json.dumps({'id': issuer_id}) except KeyError: log.info("add_issuer Failed: JSON does not have required fields") abort(503) def assertions(self, email): """ GET /assertions/<email> Return a list of all assertions awarded to the given email """ results = self.database.get_assertions_by_email(email) if results == False: log.info("GET /assertions/{0} failed".format(email)) return json.dumps({"success": False, "email": email}) else: expanded_results = { 'success': True, 'assertions': [r.__json__() for r in results]} return json.dumps(expanded_results) def add_assertion(self): """ POST /assertions/ Add a new assertion """ try: data = json.loads(request.data) except: log.info("add_assertion Failed: Could not parse request.data") abort(503) try: person_email, badge_id = self.database.add_assertion( data['badge_id'], data['person_email'], data.get('issued_on', None) ) return json.dumps({ 'success': True, 'badge_id': badge_id, 'person_email': person_email }) except KeyError: log.info("add_assertion Failed: JSON does not have the required fields") abort(503)
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'])