async def _(root_api: Api, mounted_api: Api) -> None:
assert use_component(RootComponent, api=root_api)
with raises(KeyError):
use_component(RootComponent, api=mounted_api)
assert use_component(MountedComponent, api=mounted_api)
with raises(KeyError):
use_component(MountedComponent, api=root_api)
async def _():
user = User(
id=10,
email="*****@*****.**",
date_joined=datetime.now(timezone.utc),
password="******",
is_active=True,
jwt_auth_id=1,
)
with time_machine.travel("2021-10-10 15:00:00Z", tick=False):
token = jwt.encode(
{
"user_id": 10,
"exp": datetime.now(timezone.utc) + timedelta(minutes=30),
"iat": datetime.now(timezone.utc),
"iss": "users",
"aud": "users/not-reset-password",
},
str(SECRET_KEY),
)
with raises(ResetPasswordTokenInvalidError):
await reset_password(
ResetPasswordInput(token=token, new_password="******"),
repository=FakeUsersRepository([user]),
)
async def _():
user = PastaportoUserInfo(id=1, email="*****@*****.**", is_staff=False)
fake_repository = FakeAssociationMembershipRepository([], [])
with raises(CustomerNotAvailable):
await manage_user_association_subscription(
user, association_repository=fake_repository)
async def _():
user = User(
id=10,
email="*****@*****.**",
date_joined=datetime.now(timezone.utc),
password="******",
is_active=False,
jwt_auth_id=1,
name="Old name",
fullname="Old fullname",
gender="f",
open_to_recruiting=True,
open_to_newsletter=True,
date_birth=date(1900, 1, 1),
country="US",
)
with raises(UserIsNotActiveError):
await update_profile(
user.id,
UpdateProfileInput(
name="New name",
full_name="Full name",
gender="m",
open_to_recruiting=False,
open_to_newsletter=False,
date_birth=date(2020, 10, 1),
country="IT",
),
users_repository=FakeUsersRepository([user]),
)
async def _():
user = User(
id=1,
username="******",
password="******",
email="*****@*****.**",
fullname="Marco Acierno",
name="Marco",
gender="",
date_birth=None,
open_to_newsletter=False,
open_to_recruiting=False,
country="",
date_joined=datetime(2020, 1, 1),
is_staff=False,
is_superuser=False,
is_active=False,
)
repository = FakeUsersRepository(users=[user])
with raises(UserIsNotActiveError):
await login(
LoginInputModel(email="*****@*****.**", password="******"),
users_repository=repository,
)
def _(mock=mock):
mock(2)
mock(1)
e = expect(mock)
with raises(ExpectationFailed):
e.called_with(2)
expect(e.history[0].success).equals(False)
async def _():
user = PastaportoUserInfo(id=1, email="*****@*****.**", is_staff=False)
subscription = Subscription(id=1,
user_id=user.id,
status=SubscriptionStatus.ACTIVE)
payment = Payment(
id=1,
total=1000,
subscription=subscription,
idempotency_key="iv_abcabc",
status=PaymentStatus.PAID,
payment_date=datetime.now(timezone.utc),
period_start=datetime.now(timezone.utc) + timedelta(days=0),
period_end=datetime.now(timezone.utc) + timedelta(days=30),
)
StripeSubscriptionPayment(
id=1,
payment=payment,
stripe_subscription_id="sub_abcabc",
stripe_invoice_id="iv_abcabc",
invoice_pdf="https://stripe.com/pdf/xxx",
)
with raises(AlreadySubscribed):
await subscribe_user_to_association(
user,
association_repository=FakeAssociationMembershipRepository(
[subscription]),
)
async def _(api: Api) -> None:
component = use_component(RootComponent, api=api)
assert component.baz("foo", "bar")
another = use_component(RootAnotherComponent, api=api)
assert await another.foobar()
with raises(LookupError):
use_component(MountedComponent)
async def _():
user = PastaportoUserInfo(id=1, email="*****@*****.**", is_staff=False)
subscription = Subscription(id=1,
user_id=user.id,
status=SubscriptionStatus.CANCELED)
payment = Payment(
id=1,
total=1000,
idempotency_key="iv_abcabc",
subscription=subscription,
status=PaymentStatus.PAID,
payment_date=datetime.now(timezone.utc),
period_start=datetime.now(timezone.utc) + timedelta(days=0),
period_end=datetime.now(timezone.utc) + timedelta(days=30),
)
StripeSubscriptionPayment(
id=1,
payment=payment,
stripe_subscription_id="sub_abcabc",
stripe_invoice_id="iv_abcabc",
invoice_pdf="https://stripe.com/pdf/xxx",
)
stripe_customer = StripeCustomer(id=1,
user_id=user.id,
stripe_customer_id="cus_123")
fake_repository = FakeAssociationMembershipRepository([subscription],
[stripe_customer])
with raises(NoSubscriptionAvailable):
await manage_user_association_subscription(
user, association_repository=fake_repository)
async def _():
user = User(
id=1,
email="*****@*****.**",
name="Name",
is_staff=False,
is_active=True,
date_joined=datetime.utcnow(),
)
repository = FakeUsersRepository(users=[user])
with patch(
"users.auth.entities.get_jwt_metadata",
return_value={
"exp": datetime(1980, 1, 1),
"iat": datetime(1980, 1, 1)
},
):
jwt_token = user.generate_token()
request = MagicMock()
request.headers = {"Authorization": f"Bearer {jwt_token}"}
with raises(AuthenticationError):
await JWTAuthBackend(repository).authenticate(request)
def _(
arg=each("invalid-scope", 123),
expected_cause_ex_type=each(KeyError, AttributeError),
):
with raises(FixtureError) as fixture_error:
Scope.from_str(arg)
assert type(fixture_error.raised.__cause__) is expected_cause_ex_type
async def _():
user = PastaportoUserInfo(id=1, email="*****@*****.**", is_staff=False)
subscription = Subscription(id=1,
user_id=user.id,
status=SubscriptionStatus.ACTIVE)
payment = Payment(
id=1,
total=1000,
idempotency_key="iv_abcabc",
subscription=subscription,
status=PaymentStatus.PAID,
payment_date=datetime.now(timezone.utc),
period_start=datetime.now(timezone.utc) + timedelta(days=0),
period_end=datetime.now(timezone.utc) + timedelta(days=30),
)
PretixPayment(
id=1,
payment=payment,
order_code="ABC",
event_organizer="local-test",
event_id="pycon-demo",
)
fake_repository = FakeAssociationMembershipRepository([subscription], [])
with raises(NotSubscribedViaStripe):
await manage_user_association_subscription(
user, association_repository=fake_repository)
def _(mock=mock):
print(mock.call_args_list)
mock(1, 2)
mock(key="value")
e = expect(mock)
with raises(ExpectationFailed):
e.has_calls([call(key="value"), call(1, 2)])
def _(isclose=isclose):
this, that = 1.0, 1.2
abs_tol = 0.01
with raises(ExpectationFailed):
expect(this).not_approx(that, abs_tol=abs_tol)
expect(isclose).called_once_with(this, that, abs_tol=abs_tol, rel_tol=1e-9)
def _():
def invalid_test(a=each(1, 2), b=each(3, 4, 5)):
pass
t = Test(fn=invalid_test, module_name=mod)
with raises(ParameterisationError):
t.get_parameterised_instances()
async def _(
api: Api,
after: type[RequestHandlerProtocol],
before: type[RequestHandlerProtocol],
index: type[RequestHandlerProtocol],
):
with raises(KeyError):
# not cached means not called.
api._view_cache[before]
with raises(KeyError):
api._view_cache[after]
async with api.client() as client:
path = api.url_for(index)
response = await client.get(path)
assert response.status_code == HTTPStatus.OK
after_instance = api._view_cache[after]
after_instance.mock.assert_called_once()
async def _():
repository = FakeUsersRepository(users=[])
with raises(WrongEmailOrPasswordError):
await login(
LoginInputModel(email="*****@*****.**", password="******"),
users_repository=repository,
)
def _(mock=mock):
print(mock.call_args_list)
mock(1, 2)
e = expect(mock)
with raises(ExpectationFailed):
e.has_calls([call(1, 2), call(key="value")])
expect(e.history[0].success).equals(False)
def _(exit_code=each(0, 1)):
@fixture
def exits():
sys.exit(exit_code)
t = Test(fn=lambda exits=exits: None, module_name="foo")
with raises(FixtureError):
t.resolver.resolve_args(FixtureCache())
async def _():
repository = FakeUsersRepository(
users=[User(email="*****@*****.**", date_joined=datetime.utcnow())])
with raises(EmailAlreadyUsedError):
await register(
RegisterInputModel(email="*****@*****.**", password="******"),
users_repository=repository,
)
async def _(
api: Api,
bp: Blueprint,
view: type[RequestHandlerProtocol],
params: dict,
):
api.add_blueprint("", bp)
path = api.url_for(view, params)
async with api.client() as client:
with raises(NotFoundError):
await client.get(path)
async def _(email=each("", "invalid")):
with raises(ValidationError) as exc:
SocialLoginInput(email=email, social_account=SocialAccount(social_id="10"))
errors = exc.raised.errors()
assert len(errors) == 1
assert {
"loc": ("email",),
"msg": "value is not a valid email address",
"type": "value_error.email",
} in errors
async def _():
with raises(pydantic.ValidationError) as exc:
LoginInputModel(email="", password="******")
errors = exc.raised.errors()
assert len(errors) == 1
assert {
"loc": ("email", ),
"msg": "value is not a valid email address",
"type": "value_error.email",
} in errors
async def _(db=db, user_factory=user_factory):
await user_factory(email="*****@*****.**")
await user_factory(email="*****@*****.**")
await user_factory(email="*****@*****.**")
paginable = Paginable(db, User)
with raises(ValueError) as exc:
await paginable.page(0, -100)
assert str(exc.raised) == "to cannot be negative"
async def _():
with raises(pydantic.ValidationError) as exc:
LoginInputModel(email="*****@*****.**", password="")
errors = exc.raised.errors()
assert len(errors) == 1
assert {
"loc": ("password",),
"msg": "ensure this value has at least 1 characters",
"type": "value_error.any_str.min_length",
"ctx": {"limit_value": 1},
} in errors
async def _():
with raises(pydantic.ValidationError) as exc:
RegisterInputModel(email="*****@*****.**", password="******")
errors = exc.raised.errors()
assert len(errors) == 1
assert {
"loc": ("password", ),
"msg": "ensure this value has at least 8 characters",
"type": "value_error.any_str.min_length",
"ctx": {
"limit_value": 8
},
} in errors
async def _():
user = User(
id=10,
email="*****@*****.**",
date_joined=datetime.now(timezone.utc),
is_active=False,
)
with raises(UserIsNotActiveError):
await reset_password(
ResetPasswordInput(token=user.create_reset_password_token(),
new_password="******"),
repository=FakeUsersRepository([user]),
)
async def _():
with raises(ValidationError) as exc:
SocialLoginInput(
email="*****@*****.**", social_account=SocialAccount(social_id="")
)
errors = exc.raised.errors()
assert len(errors) == 1
assert {
"loc": ("social_id",),
"msg": "ensure this value has at least 1 characters",
"type": "value_error.any_str.min_length",
"ctx": {"limit_value": 1},
} in errors
def _(mock=mock):
e = expect(mock)
with raises(ExpectationFailed):
e.called()
hist = [
Expected(mock,
op="called",
that=None,
op_args=(),
op_kwargs={},
success=False)
]
expect(e.history).equals(hist)
async def _(
api: Api,
handler: ErrorHandler,
errors: dict[str, tuple[type[Exception], int]],
view: type[RequestHandlerProtocol],
):
api.add_error_handler(handler)
async with api.client() as client:
for k, v in errors.items():
response = await client.get(f"/{k}")
assert response.text == k
assert response.status_code == v[1]
with raises(KeyError):
response = await client.get("/NotHandled")
