def test_dependency_type_creation(): with begin(): dependency_type = create(DependencyType, Name="Test Type") assert bool(dependency_type.ID) assert dependency_type.Name == "Test Type" with begin(): delete(dependency_type)
def pkgbase_unnotify_instance(request: Request, pkgbase: PackageBase) -> None: notif = pkgbase.notifications.filter( PackageNotification.UserID == request.user.ID ).first() has_cred = request.user.has_credential(creds.PKGBASE_NOTIFY) if has_cred and notif: with db.begin(): db.delete(notif)
def account_type() -> AccountType: with db.begin(): account_type_ = db.create(AccountType, AccountType="TestUser") yield account_type_ with db.begin(): db.delete(account_type_)
def test_request_type_null_name_returns_empty_string(): with db.begin(): request_type = db.create(RequestType) assert bool(request_type.ID) assert request_type.Name == str() with db.begin(): db.delete(request_type)
def test_request_type_creation(): with db.begin(): request_type = db.create(RequestType, Name="Test Request") assert bool(request_type.ID) assert request_type.Name == "Test Request" with db.begin(): db.delete(request_type)
def test_relation_type_creation(): with db.begin(): relation_type = db.create(RelationType, Name="test-relation") assert bool(relation_type.ID) assert relation_type.Name == "test-relation" with db.begin(): db.delete(relation_type)
def test_create_delete(): with db.begin(): account_type = db.create(AccountType, AccountType="test") record = db.query(AccountType, AccountType.AccountType == "test").first() assert record is not None with db.begin(): db.delete(account_type) record = db.query(AccountType, AccountType.AccountType == "test").first() assert record is None
def pkgbase_delete_instance(request: Request, pkgbase: PackageBase, comments: str = str()) \ -> List[notify.Notification]: notifs = handle_request(request, DELETION_ID, pkgbase) + [ notify.DeleteNotification(request.user.ID, pkgbase.ID) ] with db.begin(): update_closure_comment(pkgbase, DELETION_ID, comments) db.delete(pkgbase) return notifs
async def pkgbase_unvote(request: Request, name: str): pkgbase = get_pkg_or_base(name, PackageBase) vote = pkgbase.package_votes.filter( PackageVote.UsersID == request.user.ID).first() has_cred = request.user.has_credential(creds.PKGBASE_VOTE) if has_cred and vote: with db.begin(): db.delete(vote) # Update NumVotes/Popularity. popupdate.run_single(pkgbase) return RedirectResponse(f"/pkgbase/{name}", status_code=HTTPStatus.SEE_OTHER)
def test_user_account_type_relationship(account_type): with db.begin(): user = db.create(User, Username="******", Email="*****@*****.**", RealName="Test User", Passwd="testPassword", AccountType=account_type) assert user.AccountType == account_type # This must be db.deleted here to avoid foreign key issues when # deleting the temporary AccountType in the fixture. with db.begin(): db.delete(user)
def test_add_commit(): # Use db.add and db.commit to add a temporary record. account_type = AccountType(AccountType="test") with db.begin(): db.add(account_type) # Assert it got created in the DB. assert bool(account_type.ID) # Query the DB for it and compare the record with our object. record = db.query(AccountType, AccountType.AccountType == "test").first() assert record == account_type # Remove the record. with db.begin(): db.delete(account_type)
def remove_comaintainer(comaint: PackageComaintainer) \ -> notify.ComaintainerRemoveNotification: """ Remove a PackageComaintainer. This function does *not* begin any database transaction and must be used **within** a database transaction, e.g.: with db.begin(): remove_comaintainer(comaint) :param comaint: Target PackageComaintainer to be deleted :return: ComaintainerRemoveNotification """ pkgbase = comaint.PackageBase notif = notify.ComaintainerRemoveNotification(comaint.User.ID, pkgbase.ID) db.delete(comaint) rotate_comaintainers(pkgbase) return notif
def test_ratelimit_db(get: mock.MagicMock, getboolean: mock.MagicMock, getint: mock.MagicMock, pipeline: Pipeline): # We'll need a Request for everything here. request = Request() # Run check_ratelimit for our request_limit. These should succeed. for i in range(4): assert not check_ratelimit(request) # This check_ratelimit should fail, being the 4001th request. assert check_ratelimit(request) # Delete the ApiRateLimit record. with db.begin(): db.delete(db.query(ApiRateLimit).first()) # Should be good to go again! assert not check_ratelimit(request)
def pkgbase_merge_instance(request: Request, pkgbase: PackageBase, target: PackageBase, comments: str = str()) -> None: pkgbasename = str(pkgbase.Name) # Create notifications. notifs = handle_request(request, MERGE_ID, pkgbase, target) # Target votes and notifications sets of user IDs that are # looking to be migrated. target_votes = set(v.UsersID for v in target.package_votes) target_notifs = set(n.UserID for n in target.notifications) with db.begin(): # Merge pkgbase's comments. for comment in pkgbase.comments: comment.PackageBase = target # Merge notifications that don't yet exist in the target. for notif in pkgbase.notifications: if notif.UserID not in target_notifs: notif.PackageBase = target # Merge votes that don't yet exist in the target. for vote in pkgbase.package_votes: if vote.UsersID not in target_votes: vote.PackageBase = target # Run popupdate. popupdate.run_single(target) with db.begin(): # Delete pkgbase and its packages now that everything's merged. for pkg in pkgbase.packages: db.delete(pkg) db.delete(pkgbase) # Log this out for accountability purposes. logger.info(f"Trusted User '{request.user.Username}' merged " f"'{pkgbasename}' into '{target.Name}'.") # Send notifications. util.apply_all(notifs, lambda n: n.send())
def test_dependency_type_null_name_uses_default(): with begin(): dependency_type = create(DependencyType) assert dependency_type.Name == str() with begin(): delete(dependency_type)
def logout(self, request: Request): self.authenticated = False if self.session: with db.begin(): db.delete(self.session)
async def passreset_post(request: Request, user: str = Form(...), resetkey: str = Form(default=None), password: str = Form(default=None), confirm: str = Form(default=None)): context = await make_variable_context(request, "Password Reset") # The user parameter being required, we can match against criteria = or_(models.User.Username == user, models.User.Email == user) db_user = db.query(models.User, and_(criteria, models.User.Suspended == 0)).first() if db_user is None: context["errors"] = ["Invalid e-mail."] return render_template(request, "passreset.html", context, status_code=HTTPStatus.NOT_FOUND) db.refresh(db_user) if resetkey: context["resetkey"] = resetkey if not db_user.ResetKey or resetkey != db_user.ResetKey: context["errors"] = ["Invalid e-mail."] return render_template(request, "passreset.html", context, status_code=HTTPStatus.NOT_FOUND) if not user or not password: context["errors"] = ["Missing a required field."] return render_template(request, "passreset.html", context, status_code=HTTPStatus.BAD_REQUEST) if password != confirm: # If the provided password does not match the provided confirm. context["errors"] = ["Password fields do not match."] return render_template(request, "passreset.html", context, status_code=HTTPStatus.BAD_REQUEST) if len(password) < models.User.minimum_passwd_length(): # Translate the error here, which simplifies error output # in the jinja2 template. _ = get_translator_for_request(request) context["errors"] = [_( "Your password must be at least %s characters.") % ( str(models.User.minimum_passwd_length()))] return render_template(request, "passreset.html", context, status_code=HTTPStatus.BAD_REQUEST) # We got to this point; everything matched up. Update the password # and remove the ResetKey. with db.begin(): db_user.ResetKey = str() if db_user.session: db.delete(db_user.session) db_user.update_password(password) # Render ?step=complete. return RedirectResponse(url="/passreset?step=complete", status_code=HTTPStatus.SEE_OTHER) # If we got here, we continue with issuing a resetkey for the user. resetkey = generate_resetkey() with db.begin(): db_user.ResetKey = resetkey ResetKeyNotification(db_user.ID).send() # Render ?step=confirm. return RedirectResponse(url="/passreset?step=confirm", status_code=HTTPStatus.SEE_OTHER)