def test_user_subscribed_is_run_when_user_tier_is_changed_to_paid( self, user_subscribed, session): free_user = UserFactory(tier="free") free_user.plan = Plan.paid() session.add(free_user) session.commit() user_subscribed.assert_called_with(free_user.id, Plan.paid().id)
def test_after_commit_hooks_are_specific_to_a_session( self, user_subscribed, session, app): # What does this test prove? Well - we start by showing # the thing works and by setting up a an "after_commit" hook # on the session. (There SHOULD BE one session per request.) # The next request should NOT fire the "after_commit" hook # because it has a new session. IE - we are not leaking # Model instances across requests, and not firing subscribe # events for instances we didn't change free_user = UserFactory(tier="free") free_user.plan = Plan.paid() session.add(free_user) session.commit() session.expire_all() user_subscribed.assert_called_with(free_user.id, Plan.paid().id) user_subscribed.reset_mock() sess = db.create_scoped_session() free_user2 = UserFactory(tier="free", email="*****@*****.**") session.expunge(free_user2.plan) sess.add(free_user2) sess.commit() user_subscribed.assert_not_called() sess.remove()
def test_user_unsubscribed_is_run_when_user_tier_is_changed_to_free( self, user_unsubscribed, session): user = UserFactory() user.plan = Plan.free() session.add(user) session.commit() user_unsubscribed.assert_called_with(user.id)
def test_factory(self, db): """Test user factory.""" user = UserFactory(password='******') db.session.commit() assert bool(user.username) assert bool(user.email) assert user.check_password('myprecious')
def test_model_add_duplicated_email(self): """ Add a duplicated email """ user = UserFactory() with self.assertRaises(sqlalchemy.exc.IntegrityError): repository.new( User(username=faker.user_name(), email=user.email, password=user.password, role=faker.job())) def test_model_user_schema_serialize(self): """ Test UserSchema Serialize """ user_schema = UserSchema() uf = UserFactory.build() user = User(username=uf.username, email=uf.email, role=uf.role, password=uf.password) data = user_schema.dump(user).data self.assertIsInstance(data, dict) self.assertEqual(data['username'], uf.username) self.assertEqual(data['email'], uf.email) self.assertEqual(data['role'], uf.role)
def create_factories(self): super().create_factories() self.hss = BuildingFactory(site__name="Hochschulstraße") UserFactory(login='******', name="Hans Sarpei", room__building=self.hss) UserFactory(login='******', name="Franz Wurst", room__building=self.hss) UserFactory(login='******') # not living in the HSS
def test_user_can_report_limts(self, session): user = UserFactory(email="*****@*****.**") session.add(user) session.flush() assert user.limits() == UserLimit( tunnel_count=5, bandwidth=100000, forwards=9999, reserved_subdomains=5 )
def test_sign_in_with_wrong_password(client): UserFactory.create_with_hashed_password(email='*****@*****.**', password='******') payload = {'email': '*****@*****.**', 'password': '******'} response = client.post('/api/sign-in', json=payload) assert response.status_code == 401 assert response.json['errors'] == 'Invalid Credentials'
def user(self): user = UserFactory.build() copy_user = UserFactory.build(email=user.email, password=user.password) user.encode_password() self.session.add(user) self.session.commit() return copy_user
def test_sign_in_with_user_not_activated(client): UserFactory.create_with_hashed_password(email='*****@*****.**', password='******', is_active=False) payload = {'email': '*****@*****.**', 'password': '******'} response = client.post('/api/sign-in', json=payload) assert response.status_code == 401 assert response.json['errors'] == 'Not activated'
def test_user_has_authorized_on_spotify(self): user = UserFactory() user.spotify_id = '54774645' db.session.add(user) db.session.commit() url = url_for('users.user', pk=user.id) response = self.client.get(url) assert response.status_code == 200 assert response.json['spotify_playlists'].startswith('http')
def test_add_some_tracks_into_queue(self): tracks = [TrackFactory(), TrackFactory(), TrackFactory()] users = [UserFactory(), UserFactory(), UserFactory()] db.session.add_all(tracks + users) db.session.commit() response = self.client.post(url_for('player.random'), data=json.dumps({'tracks': 2})) assert response.status_code == httplib.CREATED assert Queue.length() == 2
def test_view_get_all_users(self): """ Get all users """ user1 = UserFactory() user2 = UserFactory() with self.client: response = self.client.get('/users/') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 200) self.assertEqual(len(data), 2) self.assertEqual(user1.username, data[0]['username']) self.assertEqual(user2.role, data[1]['role'])
def test_sign_in_ok(client): UserFactory.create_with_hashed_password(email='*****@*****.**', password='******') payload = {'email': '*****@*****.**', 'password': '******'} response = client.post('/api/sign-in', json=payload) response_data = response.json['data'] assert response.status_code == 200 assert response_data['access_token'] assert response_data['refresh_token'] assert response_data['expires_in'] assert response_data['token_type']
def create_factories(self): super().create_factories() self.bank_account = BankAccountFactory.create( name="Hauptkonto", bank="Spaßkasse", account__name="Bankkonto 3120219540", account_number='3120219540', ) self.fee_account = AccountFactory.create(name="Membership Fees", type='REVENUE') self.user = UserFactory.create(name="Dummy User", account__name="Dummy User") self.author = UserFactory.create()
def test_notify_event_role(db): invite = RoleInviteSubFactory() role, _ = get_or_create(Role, name='owner', title_name='Owner') UsersEventsRoles(user=UserFactory(), event=invite.event, role=role) user = UserFactory() db.session.commit() notify_event_role_invitation(invite, user, invite.event.owner) notification = Notification.query.first() assert notification.user == user assert notification.content.type == NotificationType.EVENT_ROLE assert notification.content.target == invite assert notification.content.actors[0].actor == invite.event.owner
def test_profile_ok(client): user = UserFactory.create() session = Session( user=user, refresh_token='token_123' ) session.save(force_insert=True) token_data = TokenData( id=user.id, full_name=user.full_name, email=user.email, session_id=session.id ) token = Token.generate_token(token_data=token_data) headers = { 'Authorization': f'Bearer {token}' } response = client.get( '/api/profile', headers=headers ) response_data = response.json['data'] assert response.status_code == 200 assert response_data['id'] == str(user.id) assert response_data['full_name'] == user.full_name assert response_data['email'] == user.email
def test_send_monthly_invoice(self): """Method to test monthly invoices""" with self.app.test_request_context(): TicketFeesFactory(service_fee=10.23, maximum_fee=11) test_event = EventFactoryBasic(state='published') test_user = UserFactory() test_order = OrderFactory(status='completed') test_order.completed_at = datetime.datetime.now( ) - datetime.timedelta(days=30) test_order.amount = 100 test_order.event = test_event test_ticket_holder = AttendeeFactory() test_ticket_holder.event = test_event test_ticket_holder.order = test_order test_event.owner = test_user db.session.commit() send_monthly_event_invoice() event_invoice = EventInvoice.query.get(1) self.assertEqual(event_invoice.amount, 10.23)
def should_return_track_data(self): track = TrackFactory(duration=10000) user = UserFactory() db.session.add_all([track, user]) db.session.commit() now = datetime.datetime.utcnow() start = now - datetime.timedelta(seconds=5) start = start.replace(tzinfo=dateutil.tz.tzutc()) mock_redis_values = { 'fm:player:current': json.dumps({ 'uri': track.spotify_uri, 'user': user.id }), 'fm:player:start_time': start.isoformat() } self.redis.get.side_effect = lambda x: mock_redis_values.get(x) url = url_for('player.current') # We have to mock utcnow so we don't get drift in the test with mock.patch('fm.views.player.datetime') as _dt: _dt.utcnow.return_value = now response = self.client.get(url) assert response.status_code == 200, response.json assert response.json['track'] == TrackSerializer().serialize(track) assert response.json['user'] == UserSerializer().serialize(user) assert response.json['player']['elapsed_time'] == 5000 assert response.json['player']['elapsed_percentage'] == 50 assert response.json['player']['elapsed_seconds'] == 5
def should_return_zero_when_elapsed_time_cant_be_pulled(self): track = TrackFactory() user = UserFactory() db.session.add_all([track, user]) db.session.commit() mock_redis_values = { 'fm:player:current': json.dumps({ 'uri': track.spotify_uri, 'user': user.id }), 'fm:player:elapsed_time': None } self.redis.get.side_effect = lambda x: mock_redis_values.get(x) url = url_for('player.current') response = self.client.get(url) assert response.status_code == 200 assert response.json['track'] == TrackSerializer().serialize(track) assert response.json['user'] == UserSerializer().serialize(user) assert response.json['player']['elapsed_time'] == 0 assert response.json['player']['elapsed_percentage'] == 0 assert response.json['player']['elapsed_seconds'] == 0
def test_create_customer(self): """ Create a Stripe Customer for a User """ # NOTE This is recorded - if you re-record you'll have to modify the stripe_id user = UserFactory() assert UserStripe(user).create_customer() assert user.stripe_id == "cus_FPz8Z3uTNswpjq"
def setup(self): user = UserFactory() db.session.add(user) db.session.commit() self.user = User.query.one() patch = mock.patch('fm.logic.player.redis', mock_redis_client()) self.redis = patch.start() self.redis.publish = mock.MagicMock() self.addPatchCleanup(patch) patch = mock.patch('fm.tasks.queue.update_genres') self.update_genres = patch.start() self.update_genres.return_value = [] self.addPatchCleanup(patch) # Patch Requests to EchoNest self.requests = mock.MagicMock() self.requests.get.return_value = mock.MagicMock( status_code=httplib.OK, json=mock.MagicMock(return_value=ECHONEST_ARTIST_GENRES)) self.requests.ConnectionError = requests.ConnectionError patch = mock.patch( 'fm.thirdparty.echonest.requests', new_callable=mock.PropertyMock(return_value=self.requests)) patch.start() self.addPatchCleanup(patch)
def should_fire_stop_event(self): track = TrackFactory() user = UserFactory() db.session.add_all([track, user]) db.session.commit() self.redis.get.return_value = json.dumps({ 'uri': track.spotify_uri, 'user': user.id, }) url = url_for('player.current') response = self.client.delete(url) assert response.status_code == 200 self.redis.publish.assert_called_once_with( self.app.config.get('PLAYER_CHANNEL'), json.dumps({ 'event': 'stop', 'user': str(user.id), 'track': str(track.id), 'uri': str(track.spotify_uri), 'by': str(current_user.id), }))
def test_order_get(client, db, user, jwt): user1 = UserFactory(is_admin=False) order_id = create_order(db, user1) order = Order.query.get(order_id) attendee = AttendeeSubFactory(order=order, email=user.email) db.session.commit() response = client.get( f'/v1/orders/{order_id}?include=user', content_type='application/vnd.api+json', headers=jwt, ) assert response.status_code == 200 assert json.loads( response.data)['data']['relationships']['user']['data'] == None response = client.get( f'/v1/attendees/{attendee.id}?include=order.user', content_type='application/vnd.api+json', headers=jwt, ) assert response.status_code == 200 assert (json.loads( response.data)['included'][0]['relationships']['user']['data'] == None)
def target_comment(self, target_group, user): wrong_user = UserFactory() comment = CommentFactory(comment_group_id=target_group.id, user_id=wrong_user.id, user=wrong_user, status=CommentStatus.DELETED) return comment
def post_id(self, user): another_user = UserFactory() post = PostFactory() LikeFactory(post_id=post.id, user_id=another_user.id) return post.id
def test_auth_user_invalid_logout(self): """ Testing invalid user logout """ user = UserFactory.build() with self.client: initial_datetime = datetime.datetime(2017, 1, 1) other_datetime = datetime.datetime(2017, 1, 2) with freeze_time(initial_datetime) as frozen_datetime: helper = UserHelpers(self.client) helper.register(user) resp_login = helper.login(user) # Expire the token frozen_datetime.move_to(other_datetime) response = self.client.post( '/auth/logout', headers=dict( Authorization='Bearer ' + json.loads(resp_login.data.decode())['auth_token'])) data = json.loads(response.data.decode()) self.assertEqual(data['message'], 'Signature Expired, please login again') self.assertEqual(response.status_code, 401)
def authenticated(request, db, app): if not getattr(request.instance, 'unauthenticated', False): user = UserFactory() db.session.add(user) db.session.commit() g.user = user
def test_add_track_into_queue(self): track = TrackFactory() user = UserFactory() db.session.add_all([track, user]) db.session.commit() Queue.add(track.spotify_uri, user.id) assert Queue.length() == 1
def test_spotify_playlist_returns_204_for_unauthorized_on_spotify(self): user = UserFactory() db.session.add(user) db.session.commit() response = self.client.get( url_for('users.user_spotify_playlists', user_pk=user.id)) assert response.status_code == httplib.NO_CONTENT
def test_slug_field_should_automatically_slugify_title(self): user = UserFactory.create() article = Article( title='This is a title', author=user, content='Blah blah some content' ) article.save() article.slug | should | equal_to('this-is-a-title')
def setUp(self): super().setUp() property_group_data = { # name, granted, denied 'active': ({'login', 'mail'}, set()), 'mail_only': ({'mail'}, set()), 'violation': (set(), {'login'}), } self.groups = {} for name, (granted, denied) in property_group_data.items(): self.groups[name] = PropertyGroupFactory.create(name=name, granted=granted, denied=denied) self.users = dict(zip(['active', 'mail', 'violator', 'former'], UserFactory.create_batch(4))) memberships = [ # user, group, delta_days_start, delta_days_end ('active', 'active', -1, None), ('mail', 'mail_only', -1, +1), ('mail', 'active', +2, None), ('violator', 'active', -1, None), ('violator', 'violation', -1, None), ('former', 'active', -10, -1), ('former', 'violation', -9, -5), ] for username, groupname, delta_days_start, delta_days_end in memberships: start = (datetime.now() + timedelta(delta_days_start) if delta_days_start is not None else None) end = (datetime.now() + timedelta(delta_days_end) if delta_days_end is not None else None) MembershipFactory.create(user=self.users[username], group=self.groups[groupname], begins_at=start, ends_at=end) session.session.commit()
def step_impl(context): user = UserFactory(username='******', email='*****@*****.**') user.set_password('bar') user.save()