Тестирование (автоматическое) - Ntditl/kpfu_service

На backend части приложения были реализованы тесты для модуля services.

AuthServiceTest

🔍 Показать/скрыть код

package com.library.services

import com.library.models.LoginRequest
import com.library.models.RegisterRequest
import com.library.models.UserDTO
import com.library.repositories.UserRepository
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.mockito.kotlin.any
import org.mockito.kotlin.mock
import org.mockito.kotlin.never
import org.mockito.kotlin.verify
import org.mockito.kotlin.whenever

class AuthServiceTest {

    private lateinit var userRepository: UserRepository
    private lateinit var jwtService: JwtService
    private lateinit var authService: AuthService

    @BeforeEach
    fun setup() {
        userRepository = mock()
        jwtService = mock()
        authService = AuthService(userRepository, jwtService)
    }

    @Test
    fun `должен успешно зарегистрировать нового пользователя`() {
        // Подготовка данных для теста
        val request = RegisterRequest(
            email = "[email protected]",
            password = "password123",
            first_name = "Иван",
            last_name = "Петров",
            phone = "+79001234567"
        )

        val userId = 1
        val mockUser = UserDTO(
            user_id = userId,
            email = request.email,
            first_name = request.first_name,
            last_name = request.last_name,
            phone = request.phone,
            role_id = 1,
            is_active = true
        )

        val mockToken = "jwt.token.example"

        // Настройка поведения моков
        whenever(userRepository.findByEmail(request.email)).thenReturn(null)
        whenever(userRepository.create(any(), any())).thenReturn(userId)
        whenever(userRepository.findById(userId)).thenReturn(mockUser)
        whenever(jwtService.generateToken(mockUser)).thenReturn(mockToken)

        // Вызов тестируемого метода
        val response = authService.register(request)

        // Проверка результата
        assert(response.token == mockToken)
        assert(response.user == mockUser)

        // Проверка вызовов методов моков
        verify(userRepository).findByEmail(request.email)
        verify(userRepository).create(any(), any())
        verify(userRepository).findById(userId)
        verify(jwtService).generateToken(mockUser)
    }

    @Test
    fun `должен выбрасывать исключение при регистрации с существующим email`() {
        // Подготовка данных для теста
        val request = RegisterRequest(
            email = "[email protected]",
            password = "password123",
            first_name = "Иван",
            last_name = "Петров",
            phone = "+79001234567"
        )

        val existingUser = UserDTO(
            user_id = 1,
            email = request.email,
            first_name = "Существующий",
            last_name = "Пользователь",
            phone = "+79009876543",
            role_id = 1,
            is_active = true
        )

        // Настройка поведения моков
        whenever(userRepository.findByEmail(request.email)).thenReturn(existingUser)

        // Проверка выброса исключения
        val exception = assertThrows<IllegalArgumentException> {
            authService.register(request)
        }

        // Проверка сообщения об ошибке
        assert(exception.message == "Пользователь с таким email уже существует")

        // Проверка вызовов методов моков
        verify(userRepository).findByEmail(request.email)
        verify(userRepository, never()).create(any(), any())
    }
}

BookCopyServiceTest

🔍 Показать/скрыть код

package com.library.services

import com.library.models.*
import com.library.repositories.BookCopyRepository
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.mockito.kotlin.*

class BookCopyServiceTest {

    private lateinit var bookCopyRepository: BookCopyRepository
    private lateinit var bookCopyService: BookCopyService

    @BeforeEach
    fun setup() {
        bookCopyRepository = mock()
        bookCopyService = BookCopyService(bookCopyRepository)
    }

    @Test
    fun `должен получить список всех экземпляров книг`() {
        // Подготовка данных
        val bookCopies = listOf(
            BookCopyDTO(copy_id = 1, book_id = 1, is_in_here = true, is_in_reservation = false, borrowed_By_Other_User = false),
            BookCopyDTO(copy_id = 2, book_id = 1, is_in_here = true, is_in_reservation = true, borrowed_By_Other_User = false),
            BookCopyDTO(copy_id = 3, book_id = 2, is_in_here = false, is_in_reservation = false, borrowed_By_Other_User = true)
        )

        // Настройка поведения мока
        whenever(bookCopyRepository.getAll()).thenReturn(bookCopies)

        // Вызов тестируемого метода
        val result = bookCopyService.getAll()

        // Проверка результата
        assert(result.size == 3)
        assert(result[0].copy_id == 1)
        assert(result[0].book_id == 1)
        assert(result[0].is_in_here)
        assert(!result[0].is_in_reservation)

        // Проверка вызова мока
        verify(bookCopyRepository).getAll()
    }

    @Test
    fun `должен получить экземпляр книги по ID`() {
        // Подготовка данных
        val copyId = 1
        val bookCopy = BookCopyDTO(
            copy_id = copyId,
            book_id = 1,
            is_in_here = true,
            is_in_reservation = false,
            borrowed_By_Other_User = false
        )

        // Настройка поведения мока
        whenever(bookCopyRepository.getById(copyId)).thenReturn(bookCopy)

        // Вызов тестируемого метода
        val result = bookCopyService.getById(copyId)

        // Проверка результата
        assert(result != null)
        assert(result?.copy_id == copyId)
        assert(result?.book_id == 1)
        assert(result?.is_in_here == true)

        // Проверка вызова мока
        verify(bookCopyRepository).getById(copyId)
    }

    @Test
    fun `должен выбросить исключение при поиске экземпляра книги с неположительным ID`() {
        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            bookCopyService.getById(0)
        }

        // Проверка что мок не вызывался
        verify(bookCopyRepository, never()).getById(any())
    }

    @Test
    fun `должен создать новый экземпляр книги`() {
        // Подготовка данных
        val bookCopyDTO = BookCopyDTO(
            book_id = 1,
            is_in_here = true,
            is_in_reservation = false,
            borrowed_By_Other_User = false
        )
        val createdCopyId = 1

        // Настройка поведения мока
        whenever(bookCopyRepository.create(bookCopyDTO)).thenReturn(createdCopyId)

        // Вызов тестируемого метода
        val result = bookCopyService.create(bookCopyDTO)

        // Проверка результата
        assert(result == createdCopyId)

        // Проверка вызова мока
        verify(bookCopyRepository).create(bookCopyDTO)
    }

    @Test
    fun `должен выбросить исключение при создании экземпляра книги с неположительным ID книги`() {
        // Подготовка данных
        val bookCopyDTO = BookCopyDTO(
            book_id = 0,  // Неположительный ID книги
            is_in_here = true,
            is_in_reservation = false,
            borrowed_By_Other_User = false
        )

        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            bookCopyService.create(bookCopyDTO)
        }

        // Проверка что мок не вызывался
        verify(bookCopyRepository, never()).create(any())
    }

    @Test
    fun `должен обновить существующий экземпляр книги`() {
        // Подготовка данных
        val copyId = 1
        val bookCopyDTO = BookCopyDTO(
            book_id = 1,
            is_in_here = false,
            is_in_reservation = true,
            borrowed_By_Other_User = true
        )

        // Настройка поведения мока
        whenever(bookCopyRepository.update(copyId, bookCopyDTO)).thenReturn(true)

        // Вызов тестируемого метода
        val result = bookCopyService.update(copyId, bookCopyDTO)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(bookCopyRepository).update(copyId, bookCopyDTO)
    }

    @Test
    fun `должен удалить экземпляр книги по ID`() {
        // Подготовка данных
        val copyId = 1

        // Настройка поведения мока
        whenever(bookCopyRepository.delete(copyId)).thenReturn(true)

        // Вызов тестируемого метода
        val result = bookCopyService.delete(copyId)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(bookCopyRepository).delete(copyId)
    }

    @Test
    fun `должен обновить статус бронирования экземпляра книги`() {
        // Подготовка данных
        val copyId = 1
        val updateDTO = UpdateBookCopyReservationDTO(is_in_reservation = true)

        // Настройка поведения мока
        whenever(bookCopyRepository.updateReservation(copyId, updateDTO.is_in_reservation)).thenReturn(true)

        // Вызов тестируемого метода
        val result = bookCopyService.updateReservation(copyId, updateDTO)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(bookCopyRepository).updateReservation(copyId, updateDTO.is_in_reservation)
    }

    @Test
    fun `должен обновить местоположение экземпляра книги`() {
        // Подготовка данных
        val copyId = 1
        val updateDTO = UpdateBookCopyLocationDTO(is_in_here = false)

        // Настройка поведения мока
        whenever(bookCopyRepository.updateLocation(copyId, updateDTO.is_in_here)).thenReturn(true)

        // Вызов тестируемого метода
        val result = bookCopyService.updateLocation(copyId, updateDTO)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(bookCopyRepository).updateLocation(copyId, updateDTO.is_in_here)
    }

    @Test
    fun `должен обновить статус выдачи экземпляра книги`() {
        // Подготовка данных
        val copyId = 1
        val updateDTO = UpdateBookCopyBorrowedStatusDTO(borrowed_By_Other_User = true)

        // Настройка поведения мока
        whenever(bookCopyRepository.updateBorrowedStatus(copyId, updateDTO.borrowed_By_Other_User)).thenReturn(true)

        // Вызов тестируемого метода
        val result = bookCopyService.updateBorrowedStatus(copyId, updateDTO)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(bookCopyRepository).updateBorrowedStatus(copyId, updateDTO.borrowed_By_Other_User)
    }
}

BookServiceTest

🔍 Показать/скрыть код

package com.library.services

import com.library.models.BookDTO
import com.library.repositories.BookRepository
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.mockito.kotlin.*

class BookServiceTest {

    private lateinit var bookRepository: BookRepository
    private lateinit var bookService: BookService

    @BeforeEach
    fun setup() {
        bookRepository = mock()
        bookService = BookService(bookRepository)
    }

    @Test
    fun `должен получить список всех книг`() {
        // Подготовка данных
        val books = listOf(
            BookDTO(bookId = 1, title = "Война и мир", author = "Лев Толстой", isbn = "123456789",
                publicationYear = 1869, publisher = "Русский вестник", genre = "Роман",
                description = "Описание книги", keywords = "война, мир", coverUrl = "url1"),
            BookDTO(bookId = 2, title = "Мастер и Маргарита", author = "Михаил Булгаков", isbn = "987654321",
                publicationYear = 1967, publisher = "Москва", genre = "Роман",
                description = "Описание книги", keywords = "москва, дьявол", coverUrl = "url2")
        )

        // Настройка поведения мока
        whenever(bookRepository.getAll()).thenReturn(books)

        // Вызов тестируемого метода
        val result = bookService.getAll()

        // Проверка результата
        assert(result.size == 2)
        assert(result[0].title == "Война и мир")
        assert(result[1].title == "Мастер и Маргарита")

        // Проверка вызова мока
        verify(bookRepository).getAll()
    }

    @Test
    fun `должен получить книгу по ID`() {
        // Подготовка данных
        val bookId = 1
        val book = BookDTO(
            bookId = bookId,
            title = "Война и мир",
            author = "Лев Толстой",
            isbn = "123456789",
            publicationYear = 1869,
            publisher = "Русский вестник",
            genre = "Роман",
            description = "Описание книги",
            keywords = "война, мир",
            coverUrl = "url1"
        )

        // Настройка поведения мока
        whenever(bookRepository.getById(bookId)).thenReturn(book)

        // Вызов тестируемого метода
        val result = bookService.getById(bookId)

        // Проверка результата
        assert(result != null)
        assert(result?.bookId == bookId)
        assert(result?.title == "Война и мир")

        // Проверка вызова мока
        verify(bookRepository).getById(bookId)
    }

    @Test
    fun `должен выбросить исключение при поиске книги с неположительным ID`() {
        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            bookService.getById(0)
        }

        // Проверка что мок не вызывался
        verify(bookRepository, never()).getById(any())
    }

    @Test
    fun `должен создать новую книгу`() {
        // Подготовка данных
        val bookDTO = BookDTO(
            title = "Война и мир",
            author = "Лев Толстой",
            isbn = "123456789",
            publicationYear = 1869,
            publisher = "Русский вестник",
            genre = "Роман",
            description = "Описание книги",
            keywords = "война, мир",
            coverUrl = "url1"
        )
        val createdBookId = 1

        // Настройка поведения мока
        whenever(bookRepository.create(bookDTO)).thenReturn(createdBookId)

        // Вызов тестируемого метода
        val result = bookService.create(bookDTO)

        // Проверка результата
        assert(result == createdBookId)

        // Проверка вызова мока
        verify(bookRepository).create(bookDTO)
    }

    @Test
    fun `должен выбросить исключение при создании книги с пустым заголовком`() {
        // Подготовка данных
        val bookDTO = BookDTO(
            title = "",  // Пустой заголовок
            author = "Автор",
            isbn = null,
            publicationYear = null,
            publisher = null,
            genre = null,
            description = null,
            keywords = null,
            coverUrl = null
        )

        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            bookService.create(bookDTO)
        }

        // Проверка что мок не вызывался
        verify(bookRepository, never()).create(any())
    }

    @Test
    fun `должен обновить существующую книгу`() {
        // Подготовка данных
        val bookId = 1
        val bookDTO = BookDTO(
            title = "Война и мир (обновлено)",
            author = "Лев Толстой",
            isbn = "123456789",
            publicationYear = 1869,
            publisher = "Русский вестник",
            genre = "Роман",
            description = "Обновленное описание",
            keywords = "война, мир, роман",
            coverUrl = "url1_updated"
        )

        // Настройка поведения мока
        whenever(bookRepository.update(bookId, bookDTO)).thenReturn(true)

        // Вызов тестируемого метода
        val result = bookService.update(bookId, bookDTO)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(bookRepository).update(bookId, bookDTO)
    }

    @Test
    fun `должен удалить книгу по ID`() {
        // Подготовка данных
        val bookId = 1

        // Настройка поведения мока
        whenever(bookRepository.delete(bookId)).thenReturn(true)

        // Вызов тестируемого метода
        val result = bookService.delete(bookId)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(bookRepository).delete(bookId)
    }

    @Test
    fun `должен выбросить исключение при удалении книги с неположительным ID`() {
        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            bookService.delete(0)
        }

        // Проверка что мок не вызывался
        verify(bookRepository, never()).delete(any())
    }
}

RoleServiceTest

🔍 Показать/скрыть код

package com.library.services

import com.library.models.RoleDTO
import com.library.repositories.RoleRepository
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.mockito.kotlin.*

class RoleServiceTest {

    private lateinit var roleRepository: RoleRepository
    private lateinit var roleService: RoleService

    @BeforeEach
    fun setup() {
        roleRepository = mock()
        roleService = RoleService(roleRepository)
    }

    @Test
    fun `должен получить список всех ролей`() {
        // Подготовка данных
        val roles = listOf(
            RoleDTO(role_id = 1, role_name = "Администратор"),
            RoleDTO(role_id = 2, role_name = "Библиотекарь"),
            RoleDTO(role_id = 3, role_name = "Читатель")
        )

        // Настройка поведения мока
        whenever(roleRepository.getAll()).thenReturn(roles)

        // Вызов тестируемого метода
        val result = roleService.getAll()

        // Проверка результата
        assert(result.size == 3)
        assert(result[0].role_name == "Администратор")
        assert(result[1].role_name == "Библиотекарь")
        assert(result[2].role_name == "Читатель")

        // Проверка вызова мока
        verify(roleRepository).getAll()
    }

    @Test
    fun `должен получить роль по ID`() {
        // Подготовка данных
        val roleId = 1
        val role = RoleDTO(role_id = roleId, role_name = "Администратор")

        // Настройка поведения мока
        whenever(roleRepository.getById(roleId)).thenReturn(role)

        // Вызов тестируемого метода
        val result = roleService.getById(roleId)

        // Проверка результата
        assert(result != null)
        assert(result?.role_id == roleId)
        assert(result?.role_name == "Администратор")

        // Проверка вызова мока
        verify(roleRepository).getById(roleId)
    }

    @Test
    fun `должен выбросить исключение при поиске роли с неположительным ID`() {
        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            roleService.getById(0)
        }

        // Проверка что мок не вызывался
        verify(roleRepository, never()).getById(any())
    }

    @Test
    fun `должен создать новую роль`() {
        // Подготовка данных
        val roleDTO = RoleDTO(role_name = "Новая роль")
        val createdRoleId = 4

        // Настройка поведения мока
        whenever(roleRepository.create(roleDTO)).thenReturn(createdRoleId)

        // Вызов тестируемого метода
        val result = roleService.create(roleDTO)

        // Проверка результата
        assert(result == createdRoleId)

        // Проверка вызова мока
        verify(roleRepository).create(roleDTO)
    }

    @Test
    fun `должен выбросить исключение при создании роли с пустым названием`() {
        // Подготовка данных
        val roleDTO = RoleDTO(role_name = "")  // Пустое название роли

        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            roleService.create(roleDTO)
        }

        // Проверка что мок не вызывался
        verify(roleRepository, never()).create(any())
    }

    @Test
    fun `должен обновить существующую роль`() {
        // Подготовка данных
        val roleId = 1
        val roleDTO = RoleDTO(role_name = "Администратор (обновлено)")

        // Настройка поведения мока
        whenever(roleRepository.update(roleId, roleDTO)).thenReturn(true)

        // Вызов тестируемого метода
        val result = roleService.update(roleId, roleDTO)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(roleRepository).update(roleId, roleDTO)
    }

    @Test
    fun `должен удалить роль по ID`() {
        // Подготовка данных
        val roleId = 3

        // Настройка поведения мока
        whenever(roleRepository.delete(roleId)).thenReturn(true)

        // Вызов тестируемого метода
        val result = roleService.delete(roleId)

        // Проверка результата
        assert(result)

        // Проверка вызова мока
        verify(roleRepository).delete(roleId)
    }

    @Test
    fun `должен выбросить исключение при удалении роли с неположительным ID`() {
        // Проверка выброса исключения
        assertThrows<IllegalArgumentException> {
            roleService.delete(0)
        }

        // Проверка что мок не вызывался
        verify(roleRepository, never()).delete(any())
    }
}

Тестирование (автоматическое) - Ntditl/kpfu_service_library GitHub Wiki

⚠️ GitHub.com Fallback ⚠️

Тестирование (автоматическое) - Ntditl/kpfu_service_library GitHub Wiki

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️