{
    "price": 10,
    "movie_id": 2,
    "date_time": "2025-02-12 16:58:54"
}
2025-02-12T20:32:07.631+05:00  INFO 17504 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2025-02-12T20:32:07.631+05:00  INFO 17504 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2025-02-12T20:32:07.631+05:00  INFO 17504 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 0 ms
HTTP/1.1 200 
Content-Type: application/json
Transfer-Encoding: chunked
Date: Wed, 12 Feb 2025 15:32:07 GMT
Keep-Alive: timeout=60
Connection: keep-alive

{
    "id": 2,
    "movie": {
        "id": 2,
        "name": "test name",
        "description": "test description"
    },
    "dateTime": "2025-02-12T16:58:54",
    "price": 10
}

org.opentest4j.AssertionFailedError: 
Expected :2025-02-12T16:58:54
Actual   :null
<Click to see difference>


	at org.junit.jupiter.api.AssertionFailureBuilder.build(AssertionFailureBuilder.java:151)
	at org.junit.jupiter.api.AssertionFailureBuilder.buildAndThrow(AssertionFailureBuilder.java:132)
	at org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197)
	at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:182)
	at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:177)
	at org.junit.jupiter.api.Assertions.assertEquals(Assertions.java:1145)
	at org.javaacademy.cinema.SessionControllerTest.createSuccess(SessionControllerTest.java:91)
	at java.base/java.lang.reflect.Method.invoke(Method.java:568)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)

все также ложится, вот еще раз тебе мои классы

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@AutoConfigureMockMvc
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
public class SessionControllerTest {
    private final Header header = new Header("user-token", "secretadmin123");
    private final RequestSpecification requestSpecification = new RequestSpecBuilder()
            .setBasePath("/session")
            .setContentType(ContentType.JSON)
            .log(LogDetail.ALL)
            .build();
    private final ResponseSpecification responseSpecification = new ResponseSpecBuilder()
            .log(LogDetail.ALL)
            .build();
    private static final String DELETE_TABLES = """
            delete from ticket;
            delete from place;
            delete from session;
            delete from movie;
            """;

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private SessionService sessionService;
    @Autowired
    private MovieService movieService;

    @BeforeEach
    public void cleanDatabase() {
        jdbcTemplate.execute(DELETE_TABLES);
    }

    @DisplayName("Успешное создание сеанса")
    @Test
    public void createSuccess() {
        CreateMovieDto movieDto = CreateMovieDto.builder()
                .name("test name")
                .description("test description")
                .build();
        int movieId = movieService.save(movieDto).getId();
        LocalDateTime date = LocalDateTime.of(
                2025,
                2,
                12,
                16,
                58,
                54);
        SessionDto sessionDto = SessionDto.builder()
                .dateTime(date)
                .movieId(movieId)
                .price(BigDecimal.TEN)
                .build();
        SessionDto result = given(requestSpecification)
                .header(header)
                .body(sessionDto)
                .post()
                .then()
                .spec(responseSpecification)
                .statusCode(200)
                .extract()
                .as(SessionDto.class);
        assertEquals(sessionDto.getPrice(), result.getPrice());
        assertEquals(sessionDto.getDateTime(), result.getDateTime());
        assertEquals(sessionDto.getMovieId(), result.getMovieId());
    }

create table movie(
		id serial primary key,
		"name" varchar(40),
		description varchar(200)
);

create table place(
		id serial primary key,
		number varchar(5) not null
);

create table session(
		id serial primary key,
		movie_id int not null references movie(id),
		time timestamp not null,
		price numeric(10,2) not null
);

create table ticket(
		id serial,
		place_id int not null references place(id),
		session_id int not null references session(id),
		is_bought boolean not null 
)

@Service
@RequiredArgsConstructor
public class SessionService {
    private final SessionRepository sessionRepository;
    private final SessionMapper mapper;
    private final PlaceRepository placeRepository;
    private final TicketRepository ticketRepository;

    public List<SessionDto> getAll() {
        return sessionRepository.selectAll().stream().map(mapper::convertToDto).toList();
    }

    public List<String> getFreePlace(Integer sessionId) {
        return ticketRepository.selectFreePlaces(sessionId);
    }

    public Session save(SessionDto sessionDto) {
        Session session = mapper.convertToEntity(sessionDto);
        List<Place> places = placeRepository.selectAll();
        places.stream()
                .map(place -> new Ticket(null, place, session, false))
                .forEach(ticketRepository::createTicket);
        return sessionRepository.createSession(session);
    }






@Repository
@RequiredArgsConstructor
public class SessionRepository {
    private final JdbcTemplate jdbcTemplate;
    private final MovieRepository movieRepository;

    public Optional<Session> findById(Integer id) {
        String sql = "select * from session where id = ?";
        try {
            return Optional.ofNullable(jdbcTemplate.queryForObject(sql, this::mapToSession, id));
        } catch (EmptyResultDataAccessException e) {
            return Optional.empty();
        }
    }

    public List<Session> selectAll() {
        String sql = "select * from session";
        return jdbcTemplate.query(sql, this::mapToSession);
    }

    public Session createSession(Session session) {
        String sql = "insert into session (movie_id, time, price) values(?, ?, ?) returning id";

        Integer id = jdbcTemplate.queryForObject(sql, Integer.class,
                session.getMovie().getId(),
                session.getDateTime(),
                session.getPrice());
        session.setId(id);
        return session;
    }

    @SneakyThrows
    private Session mapToSession(ResultSet rs, int rowNum) {
        Session session = new Session();
        session.setId(rs.getInt("id"));
        session.setPrice(rs.getBigDecimal("price"));
        session.setDateTime(rs.getTimestamp("time").toLocalDateTime());
        if (rs.getString("movie_id") != null) {
            Integer movieId = Integer.valueOf(rs.getString("movie_id"));
            session.setMovie(movieRepository.findById(movieId).orElse(null));
        }
        return session;
    }
}

@Component
@RequiredArgsConstructor
public class SessionMapper {
        private final MovieRepository movieRepository;

        public Session convertToEntity(SessionDto sessionDto) {
            Movie movie = movieRepository.findById(sessionDto.getMovieId()).orElseThrow();
            return new Session(null, movie, sessionDto.getDateTime(), sessionDto.getPrice());
        }

        public SessionDto convertToDto(Session session) {
            Movie movie = movieRepository.findById(session.getMovie().getId()).orElseThrow();
            return new SessionDto(session.getId(), session.getDateTime(), session.getPrice());
        }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Session {
    private Integer id;
    private Movie movie;
    private LocalDateTime dateTime;
    private BigDecimal price;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Schema(description = "DTO для создания сеанса")
@JsonIgnoreProperties(ignoreUnknown = true)
public class SessionDto {

    @Schema(description = "id фильма")
    @JsonProperty("movie_id")
    private Integer movieId;

    @Schema(description = "Дата сеанса")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @JsonProperty("date_time")
    private LocalDateTime dateTime;

    @Schema(description = "Цена билета")
    private BigDecimal price;
}

@RestController
@RequiredArgsConstructor
@RequestMapping("/session")
@Tag(name = "Сеанс", description = "Контроллер для работы с сеансами")
public class SessionController {
    private final SessionService sessionService;
    private final AdminAuthService adminAuthService;

    @Operation(summary = "Список всех сеансов", description = "Возвращает список всех сеансов",
            responses = @ApiResponse(responseCode = "200", description = "Список сеансов",
                    content = @Content(array = @ArraySchema(schema = @Schema(implementation = SessionDto.class)))))
    @GetMapping
    public List<SessionDto> getAll() {
        return sessionService.getAll();
    }

    @Operation(summary = "Показ всех свободных мест на сеанс",
            description = "Возврощает список всех свободных мест на сеанс по id",
            responses = @ApiResponse(responseCode = "200", description = "Список свободных мест",
                    content = @Content(array = @ArraySchema(schema = @Schema(implementation = String.class)))))
    @GetMapping("/{sessionId}/free-place")
    public List<String> getFreePlace(@PathVariable Integer sessionId) {
        return sessionService.getFreePlace(sessionId);
    }

    @Operation(summary = "Создание и сохранение сеанса в БД",
            description = "Создание сеанса по id фильма, цене билета, дате и сохранение сеанса в БД",
            responses = {
                    @ApiResponse(responseCode = "201", description = "Сеанс сохранен",
                            content = @Content(schema = @Schema(implementation = SessionDto.class))),
                    @ApiResponse(responseCode = "403", description = "Нет доступа!")
            })
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public ResponseEntity<?> save(@RequestHeader(value = "user-token") String userToken,
                                  @RequestBody SessionDto sessionDto) {

        if (adminAuthService.isAdmin(userToken)) {
            return ResponseEntity.ok(sessionService.save(sessionDto));
        }
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("Нет доступа!");
    }
}