pyronaut create example.micronaut.micronautguide --features=data-jdbc,oracle,serialization-jackson,validation

from dataclasses import dataclass
from typing import Annotated

from jakarta.validation.constraints import NotBlank, PositiveOrZero
from micronaut.data.annotation import GeneratedValue, Id, MappedEntity, Reservable
from micronaut.serde.annotation import Serdeable


@Serdeable  (1)
@MappedEntity("ACCOUNT")  (2)
@dataclass
class Account:
    id: Annotated[int | None, Id, GeneratedValue]  (3)
    name: Annotated[str, NotBlank]  (4)
    balance: Annotated[int, Reservable, PositiveOrZero]  (5)

CREATE TABLE "ACCOUNT" (
    "ID" NUMBER(19) NOT NULL PRIMARY KEY,
    "NAME" VARCHAR(255) NOT NULL,
    "BALANCE" NUMBER(19) RESERVABLE CONSTRAINT "CK_ACCOUNT_BALANCE_GE_0" CHECK ("BALANCE" >= 0) NOT NULL
)

from typing import Annotated

from micronaut.data.annotation import Id
from micronaut.data.jdbc.annotation import JdbcRepository
from micronaut.data.model.query.builder.sql import Dialect
from micronaut.data.repository import CrudRepository

from .domain.account import Account


@JdbcRepository(dialect=Dialect.ORACLE)  (1)
class AccountRepository(CrudRepository[Account, int]):  (2)

    def reserveIncrementBalance(self, id: Annotated[int, Id], balance: int) -> int: ...  (3)

    def reserveDecrementBalance(self, id: Annotated[int, Id], balance: int) -> int: ...  (4)

UPDATE "ACCOUNT" SET "BALANCE"=("BALANCE" + ?) WHERE ("ID" = ?)
UPDATE "ACCOUNT" SET "BALANCE"=("BALANCE" - ?) WHERE ("ID" = ?)

from typing import Annotated

from micronaut.http import HttpResponse, HttpStatus
from micronaut.http.annotation import Body, Controller, Get, Post, QueryValue, Status
from micronaut.scheduling import TaskExecutors
from micronaut.scheduling.annotation import ExecuteOn

from .account_repository import AccountRepository
from .domain.account import Account


@ExecuteOn(TaskExecutors.BLOCKING)  (1)
@Controller("/accounts")  (2)
class AccountController:
    def __init__(self, repository: AccountRepository):  (3)
        self.repository = repository

    @Post
    @Status(HttpStatus.CREATED)
    def create(self, account: Annotated[Account, Body]) -> Account:
        return self.repository.save(account)

    @Get
    def find_all(self) -> list[Account]:
        return self.repository.findAll()

    @Post("/{id}/deposit")
    def deposit(self, id: int, amount: Annotated[int, QueryValue]) -> HttpResponse[Account]:
        if self.repository.reserveIncrementBalance(id, amount) == 0:  (4)
            return HttpResponse.notFound()
        return HttpResponse.ok(self.repository.findById(id).orElseThrow())  (5)

    @Post("/{id}/withdraw")
    def withdraw(self, id: int, amount: Annotated[int, QueryValue]) -> HttpResponse[Account]:
        if self.repository.reserveDecrementBalance(id, amount) == 0:
            return HttpResponse.notFound()
        return HttpResponse.ok(self.repository.findById(id).orElseThrow())

from jakarta.inject import Singleton
from micronaut.data.exceptions import DataIntegrityViolationException
from micronaut.http import HttpRequest, HttpResponse, HttpStatus
from micronaut.http.annotation import Produces
from micronaut.http.server.exceptions import ExceptionHandler
from micronaut.http.server.exceptions.response import ErrorContext, ErrorResponseProcessor


@Produces
@Singleton
class ReservationExceptionHandler(
        ExceptionHandler[DataIntegrityViolationException, HttpResponse]):  (1)

    def __init__(self, error_response_processor: ErrorResponseProcessor):
        self.error_response_processor = error_response_processor

    def handle(self, request: HttpRequest, exception: DataIntegrityViolationException) -> HttpResponse:
        error_context = (ErrorContext.builder(request)
                         .cause(exception)
                         .errorMessage("The operation violates an account constraint")  (2)
                         .build())
        return self.error_response_processor.processResponse(
            error_context, HttpResponse.status(HttpStatus.CONFLICT))  (3)

import pytest
import requests
from micronaut.data.exceptions import DataIntegrityViolationException
from pyronaut.test import MicronautTest, micronaut_test_fixture

from example.micronaut.account_repository import AccountRepository
from example.micronaut.domain.account import Account


@pytest.fixture
def my_context(request):
    fixture = micronaut_test_fixture(
        request,
        MicronautTest(transactional=False),  (1)
    )
    yield fixture
    fixture.stop()


@pytest.fixture
def repository(my_context):
    return my_context[AccountRepository]


@pytest.fixture
def client(my_context):
    return requests.with_context(my_context)


def test_deposit_increments_balance(repository):
    account = repository.save(Account(None, "Checking", 100))

    updated = repository.reserveIncrementBalance(account.id, 25)  (2)

    assert updated == 1
    found = repository.findById(account.id).orElseThrow()
    assert found.balance == 125


def test_withdrawal_beyond_balance_is_rejected(repository):
    account = repository.save(Account(None, "Checking", 100))

    with pytest.raises(BaseException) as error:
        repository.reserveDecrementBalance(account.id, 1000)  (3)
    assert isinstance(error.value, DataIntegrityViolationException)

    found = repository.findById(account.id).orElseThrow()
    assert found.balance == 100  (4)


def test_withdrawal_beyond_balance_responds_with_conflict(repository, client):
    account = repository.save(Account(None, "Checking", 100))

    response = client.post(f"/accounts/{account.id}/withdraw?amount=1000")

    assert response.status_code == 409  (5)
    assert "The operation violates an account constraint" in response.text  (6)


def test_account_is_created_deposited_and_withdrawn_over_http(client):
    created = client.post("/accounts", json={"name": "Savings", "balance": 100})  (7)
    assert created.status_code == 201
    account = created.json()

    deposited = client.post(f"/accounts/{account['id']}/deposit?amount=25").json()  (8)
    assert deposited["balance"] == 125

    withdrawn = client.post(f"/accounts/{account['id']}/withdraw?amount=50").json()
    assert withdrawn["balance"] == 75


def test_deposit_for_unknown_account_responds_with_not_found(client):
    response = client.post("/accounts/-1/deposit?amount=1")

    assert response.status_code == 404  (9)

pyronaut install
pyronaut validate-config
pyronaut test

SELECT column_name, data_type, reservable_column
FROM user_tab_cols
WHERE table_name = 'ACCOUNT'
ORDER BY column_id;

SELECT constraint_name, search_condition
FROM user_constraints
WHERE table_name = 'ACCOUNT'
  AND constraint_type = 'C'
  AND constraint_name LIKE 'CK_%';

curl -X POST http://localhost:8080/accounts \
     -H 'Content-Type: application/json' \
     -d '{"name":"Checking","balance":100}'

curl -X POST 'http://localhost:8080/accounts/1/deposit?amount=25'

curl -X POST 'http://localhost:8080/accounts/1/withdraw?amount=50'

curl -i -X POST 'http://localhost:8080/accounts/1/withdraw?amount=1000'