def test_givers_and_is_answer_flag(self): deck = factories.CardFactory(type=Card.DECK, is_ask_mode_enabled=True) self.db.session.add(deck) self.db.session.commit() question_creator = User(username='******') self.db.session.add(question_creator) question = Card(type=Card.TEXT, parent_id=deck.id, position=0, is_answer=False, creator=question_creator) self.db.session.add(question) giver1 = User(username='******') self.db.session.add(giver1) answer = Card(type=Card.TEXT, parent_id=deck.id, creator=giver1, position=1, is_answer=True) self.db.session.add(answer) answer1 = Card(type=Card.TEXT, parent_id=deck.id, creator=giver1, position=2, is_answer=True) self.db.session.add(answer1) question1 = Card(type=Card.TEXT, parent_id=deck.id, position=3, is_answer=False, creator=question_creator) self.db.session.add(question1) self.db.session.commit() res = deck.to_dict() self.assertEqual(len(res['givers']), 1) self.assertEqual(res['givers'][0]['user_id'], giver1.id) #check if children elements has correct flag is_answer children = res['children'] self.assertEqual(len(children), 4) self.assertEqual(children[0]['id'], question.id) self.assertEqual(children[0]['is_answer'], False) self.assertEqual(children[1]['id'], answer.id) self.assertEqual(children[1]['is_answer'], True) self.assertEqual(children[2]['id'], answer1.id) self.assertEqual(children[2]['is_answer'], True) self.assertEqual(children[3]['id'], question1.id) self.assertEqual(children[3]['is_answer'], False)
def setUp(self): super(SetAskersTestCase, self).setUp() # input data self.owner = User(username='******') self.db.session.add(self.owner) self.deck = Card(type=Card.DECK, name='test_deck', creator=self.owner, is_ask_mode_enabled=True) self.db.session.add(self.deck) self.asker = User(username='******') self.db.session.add(self.asker) self.db.session.commit() self.asker_ids = None
def test_success(self): deck = Card(evaluation_period_status=card_module.EVALUATION_PERIOD_STATUS_DONE) self.db.session.add(deck) user = User() self.db.session.add(user) ucr = UserRoleCard(user=user, card=deck, role_id=card_role.CardRole.ASKED, total_likes=10, prize=100) self.db.session.add(ucr) self.db.session.commit() data = { 'deck_id': deck.id } response = self.client.get('/api/v1/deck/get_winners', query_string=data, content_type='application/json') self.assertEqual(response.status, '200 OK') res = flask.json.loads(response.data) total_likes = res['total_likes'] self.assertEqual(total_likes, 10) winners = res['winners'] self.assertEqual(len(winners), 1) it = winners[0] self.assertEqual(it['user_id'], user.id) self.assertEqual(it['likes'], 10) self.assertEqual(it['likes_relative'], 100) self.assertEqual(it['prize'], 100)
def test_for_specific_user_true(self): from lib.models import card as card_module self.creator = User(username='******') self.card = factories.CardFactory(type=Card.DECK, is_ask_mode_enabled=True, creator=self.creator) self.viewer = factories.UserFactory() self.card.views.append(self.viewer) self.card.comments.append(factories.Comment(user=self.viewer)) urc = factories.UserRoleCard(card=self.card, user=self.viewer, prize=56) self.db.session.add(self.card) self.db.session.commit() self.call_target(by_user=self.viewer) self.assertEqual(self.result['views_count'], 1) self.assertEqual(self.result['viewed_by_me'], True) self.assertEqual(self.result['commented_by_me'], True) self.assertEqual(self.result['won_by_me'], True)
def call_target(self): self.owner = User(username='******') self.db.session.add(self.owner) self.deck = Card(type=Card.DECK, name='test_deck', creator=self.owner, is_ask_mode_enabled=True, silver_points=self.deck_silver_points, prize_to_join=10) self.db.session.add(self.deck) self.db.session.commit() self.join_user = self.user ucr = UserRoleCard(user_id=self.join_user.id, role_id=CardRole.JOINED, card_id=self.deck.id) self.db.session.add(ucr) self.db.session.commit() data = {'deck_id': self.deck.id} response = self.client.post('/api/v1/deck/unjoin_ask', data=json.dumps(data), content_type='application/json') self.response = response return response
def create_inactive_user(self, username, email): user = User(username=username, email=email, active=False, verification_code=generate_verification_code()) self.db.session.add(user) return user
def add(self, name): prevUser = User.query.order_by(User.id.desc()).first() id = prevUser.id + 1 if prevUser is not None else 1 user = User(id, name) db.session.add(user) db.session.commit()
def setUp(self): super(GetUserInfoTestCase, self).setUp() user = User(id='TestUser', username='******', email='*****@*****.**', password='******') self.db.session.add(user) self.db.session.commit() self.set_current_user(user) self.user = user self.data = {}
def test_simple_fields(self): from lib.models import card as card_module self.creator = User(username='******') self.card = factories.CardFactory(type=Card.DECK, is_ask_mode_enabled=True, creator=self.creator) eastern = timezone('US/Eastern') self.card.evaluation_period_status = card_module.EVALUATION_PERIOD_STATUS_OPEN self.card.distribution_rule = card_module.DISTRIBUTION_RULE_SPLIT_EVENLY self.card.distribution_for = 10 self.card.evaluation_start_dt = datetime(2016, 11, 28, 9, 51, 38, tzinfo=eastern) self.card.evaluation_end_dt = datetime(2016, 11, 29, 9, 51, 38, tzinfo=eastern) self.card.answer_visibility = card_module.ANSWER_VISIBILITY_ONLY_ASKERS self.card.scale = 3 self.card.original_prize_pool = 123 self.viewer = factories.UserFactory() self.card.views.append(self.viewer) self.db.session.add(self.card) self.db.session.commit() self.call_target() self.assert_result() self.joined_users = [self.creator] self.assertEqual(self.result['evaluation_period_status'], card_module.EVALUATION_PERIOD_STATUS_OPEN) self.assertEqual(self.result['distribution_rule'], card_module.DISTRIBUTION_RULE_SPLIT_EVENLY) self.assertEqual(self.result['distribution_for'], 10) self.assertEqual(self.result['evaluation_start_dt'], datetime(2016, 11, 28, 9, 51, 38, tzinfo=eastern)) self.assertEqual(self.result['evaluation_end_dt'], datetime(2016, 11, 29, 9, 51, 38, tzinfo=eastern)) self.assertEqual(self.result['answer_visibility'], card_module.ANSWER_VISIBILITY_ONLY_ASKERS) self.assertEqual(self.result['creator_info']['user_id'], self.creator.id) self.assertEqual(self.result['scale'], 3) self.assertEqual(self.result['original_prize_pool'], 123) self.assertEqual(self.result['views_count'], 1)
def get_user(uname: str) -> User: """Get one Tellonym user""" res = req.get(urls.USER_INFO.format(uname)) if res.status_code != 200: return None obj = json.loads(res.text) return User(obj['avatarFileName'], obj['followerCount'] + obj['anonymousFollowerCount'], obj['followingCount'], obj['id'], obj['displayName'], obj['username'], obj['aboutMe'], obj['likesCount'], obj['answerCount'], obj['tellCount'], obj['isVerified'])
def setUp(self): super(ApiBaseTestCase, self).setUp() # create current user self.user = User(id='DefaultCurrentUser', username='******', password='******', active=True) self.db.session.add(self.user) self.db.session.commit() self.set_current_user(self.user) # way around of flask_securirty.decorators.auth_token_required decarator self._check_token_patcher = mock.patch('flask_security.decorators._check_token', return_value=True) self._check_token_mock = self._check_token_patcher.start()
def test_constructorParsesDictionary(self): # Arrange userId = 'abc123' role = 'admin' dictionary = {'userId': userId, 'role': role} # Act user = User(dictionary) #Assert self.assertEqual(userId, user.userId) self.assertEqual(role, user.role)
def test_signin_success(self): self.user = User(username='******', email='*****@*****.**', password='******') self.db.session.add(self.user) self.db.session.commit() data = { 'email': '*****@*****.**' } response = self.client.post('/api/v1/auth/signin', data=json.dumps(data), content_type='application/json') self.assertEqual(response.status, '200 OK') data = json.loads(response.data) self.assertEqual(data['user']['id'], self.user.id) self.assertEqual(data['auth_token'], self.user.get_auth_token())
def setUp(self): super(GiveCardToDeckTestCase, self).setUp() self.deck_creator = User(username='******') self.deck = Card( type=Card.DECK, name='test_deck', is_ask_mode_enabled=True, evaluation_period_status=card_module.EVALUATION_PERIOD_STATUS_OPEN, creator=self.deck_creator) self.db.session.add(self.deck) self.question_creator = User(username='******') self.db.session.add(self.question_creator) self.question = Card(type=Card.TEXT, name='question', creator=self.question_creator) self.db.session.add(self.question) self.deck.cards.append(self.question) self.creator = User(username='******') self.answer = Card(type=Card.TEXT, name='answer', creator=self.creator) self.db.session.add(self.answer) self.db.session.commit()
def create_input_data(self): if self.owner is None: self.owner = User(username='******') self.db.session.add(self.owner) if self.card is None: self.card = Card(type=self.card_type, name=self.card_name, creator=self.owner) self.db.session.add(self.card) self.db.session.commit() if self.questions is not None: for idx, c in enumerate(self.questions): c.position = idx self.card.cards.append(c) self.db.session.commit() if self.asked_users is None: if self.asked_user1 is None: self.asked_user1 = User(username='******') self.db.session.add(self.asked_user1) self.db.session.commit() self.asked_users = [self.asked_user1]
def test_success(self): user = User(username='******', password='******', active=True) self.db.session.add(user) self.db.session.commit() data = {'search_key': 'user1'} response = self.client.post(self.url, data=json.dumps(data), content_type='application/json') self.assertEqual(response.status, '200 OK') usernames = json.loads(response.data)['users'] self.assertEqual(usernames, [{ 'user_id': user.id, 'username': '******' }])
def get_all_users(con: Optional[sqlite3.Connection] = None) -> List[User]: """ Gets all users stored in the sqlite db. Parameters ---------- con : Optional[sqlite3.Connection] Connection to the db. Returns ------- List[User] List containing all users or empty. """ users = fetchall('SELECT * FROM users', con=con) return [User(*u) for u in users]
def call_target(self, by_user=None): if self.card is None: self.card = factories.CardFactory(type=Card.DECK, is_ask_mode_enabled=True) if self.creator: if self.creator.id is None: self.db.session.add(self.creator) self.db.session.commit() self.card.creator = self.creator if self.evaluation_period_status is not None: self.card.evaluation_period_status = self.evaluation_period_status self.db.session.add(self.card) self.db.session.commit() if self.creator is not None: urc = UserRoleCard(user_id=self.creator.id, role_id=CardRole.JOINED, card_id=self.card.id) self.db.session.add(urc) self.db.session.commit() if self.joined_user1_name is not None: self.joined_user_id1 = User(username=self.joined_user1_name) self.db.session.add(self.joined_user_id1) self.db.session.commit() if self.joined_user_id1 is not None: if self.joined_user_id1.id is None: self.db.session.add(self.joined_user_id1) self.db.session.commit() urc = UserRoleCard(user_id=self.joined_user_id1.id, role_id=CardRole.JOINED, card_id=self.card.id) if self.joined_user_id1_contribution is not None: urc.contribution = self.joined_user_id1_contribution self.db.session.add(urc) self.db.session.commit() res = self.card.to_dict(user=by_user) self.result = res self.create_expected() return self.result
def handle_signup(self, request): username = request.get('username') password = request.get('password') if not username or not password: return construct_result(400, 'Bad request') with Transaction() as tr: no_users = False try: user = User.read_by_name(tr.cursor, username) except ItemNotFoundError: no_users = True if not no_users: return construct_result(400, 'User already exists') User(None, username, self.auth_handler.get_password_key(password)).create_me(tr.cursor) return construct_result()
def test_visible(self): from lib.models.user_permission import UserPermission user = User(username='******', password='******', active=True) role = Role(name='homes') user.roles.append(role) self.db.session.add(user) self.db.session.commit() deck_visible = Card(type=Card.DECK, name='1 visible_deck') self.db.session.add(deck_visible) deck_owned = Card(type=Card.DECK, name='2 owned_by_user', user_id=user.id) self.db.session.add(deck_owned) deck_invisible = Card(type=Card.DECK, name='3 invisible_deck') self.db.session.add(deck_invisible) deck_visible_by_role = Card(type=Card.DECK, name='4 visible_by_role') self.db.session.add(deck_visible_by_role) self.db.session.commit() up1 = UserPermission(card_id=deck_visible.id, permission_id='view', user_id=user.id) self.db.session.add(up1) up2 = UserPermission(card_id=deck_visible_by_role.id, permission_id='view', role_id=role.id) self.db.session.add(up2) self.db.session.commit() deck_repo = DeckRepo() decks = list(deck_repo.get_viewable_decks(user)) decks = sorted(decks, key=lambda d: d.name) self.assertEqual(len(decks), 3) self.assertEqual(decks[0].id, deck_visible.id) self.assertEqual(decks[1].id, deck_owned.id) self.assertEqual(decks[2].id, deck_visible_by_role.id)
def test_for_specific_user_false(self): from lib.models import card as card_module self.creator = User(username='******') self.card = factories.CardFactory(type=Card.DECK, is_ask_mode_enabled=True, creator=self.creator) self.viewer = factories.UserFactory() self.db.session.commit() self.call_target(by_user=self.viewer) self.assert_result() self.joined_users = [self.creator] self.assertEqual(self.result['views_count'], 0) self.assertEqual(self.result['viewed_by_me'], False) self.assertEqual(self.result['commented_by_me'], False) self.assertEqual(self.result['won_by_me'], False)
def get_user(uname: str, con: Optional[sqlite3.Connection] = None) -> Union[User, None]: """ Load a user from the sqlite database by its username. Parameters ---------- uname : str The user's username. con : Optional[sqlite3.Connection] Connection to the db. Returns ------- Union[User, None] The user or None if it wasn't found. """ u = fetchone('SELECT * FROM users WHERE uname = ?', uname) if not u: return None return User(*u)
def setUp(self): super(JoinAskTestCase, self).setUp() self.user = factories.UserFactory(silver_points=100) self.db.session.add(self.user) self.set_current_user(self.user) # input data self.owner = User(username='******') self.db.session.add(self.owner) self.deck = Card(type=Card.DECK, name='test_deck', creator=self.owner, is_ask_mode_enabled=True, silver_points=0, prize_to_join=10) self.db.session.add(self.deck) self.db.session.commit() self.asker_ids = None self.custom_join_prize = None self.response = None
def reg(cls, username, password, email): """ User registration with the specified data :param username: desired user name :param password: desired password :param email: desired e-mail :return: """ log = logger.get_logger(UserController.log_tag) user = User(username, password, email) users = UserStorage.get_all_users() have = False for i in users: if i[0] == user.username: have = True if not have: UserStorage.add_user_to_db(user) return user else: log.error("User with this name is already exist") raise UserAlreadyExist
def test_success(self): deck = Card(evaluation_period_status=card_module.EVALUATION_PERIOD_STATUS_DONE) self.db.session.add(deck) user = User() self.db.session.add(user) ucr = UserRoleCard(user=user, card=deck, role_id=card_role.CardRole.JOINED, total_likes=10, prize=100, contribution=10) self.db.session.add(ucr) self.db.session.commit() data = { 'deck_id': deck.id } response = self.client.get('/api/v1/deck/get_sponsors', data=flask.json.dumps(data), content_type='application/json') self.assertEqual(response.status, '200 OK') res = flask.json.loads(response.data) sponsors = res['sponsors'] self.assertEqual(len(sponsors), 1) it = sponsors[0] self.assertEqual(it['user_id'], user.id) self.assertEqual(it['contribution'], 10)
def test_signin_success(self): self.user = User(username='******', email='*****@*****.**', password='******', silver_points=41) self.db.session.add(self.user) self.db.session.commit() with mock.patch( 'app.managers.account_manager.get_google_verification_data' ) as m: m.return_value = {'verified': True, 'email': '*****@*****.**'} data = {'google_access_token': 'my_goolge_token'} response = self.client.post('/api/v1/auth/google_signin', data=json.dumps(data), content_type='application/json') self.assertEqual(response.status, '200 OK') data = json.loads(response.data) self.assertEqual(data['user']['id'], self.user.id) self.assertEqual(data['user']['total_silver_points'], 41) self.assertEqual(data['auth_token'], self.user.get_auth_token())
def __insert_initial_data(self): from lib.models.user import User u = User(id=User.ANYONE_ID, username='******') self.db.session.add(u) self.db.session.commit()
def test_joined_users_serialize_with_flag_if_creator(self): self.creator = User(username='******') self.call_target() self.joined_users = [self.creator] self.assert_result()
def test_joined_user_with_contribution(self): self.joined_user_id1 = User(username='******') self.joined_user_id1_contribution = 50 self.call_target() self.joined_users = [self.joined_user_id1] self.assert_result()
def mock_user(): return User(email="*****@*****.**", full_name="Test Sender", id=5678)