diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index b6509b3e485ae8ebf9299e99c49cdb7ffb135767..fb87697f671f4a57be8c33bded1d536272f35077 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -7,8 +7,7 @@ test:
tags:
- private
script:
- - make test
- - cat target/site/jacoco/index.html
+ - make ci_test
cleanup:
stage: cleanup
@@ -16,5 +15,4 @@ cleanup:
tags:
- private
script:
- - sudo /bin/chown -R gitlab-runner target
- - make clean_test
\ No newline at end of file
+ - make ci_clean_test
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index e72d32499bb1e9ff23ecffafac5ba9ffbc665fb6..2b68048c39ea82191298ea974b5c8b9ca313287a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -9,5 +9,7 @@ RUN sass --version
COPY wait-for-it.sh /
COPY wad.sh /
+COPY . /app
+
RUN chmod 777 /wad.sh
RUN chmod 777 /wait-for-it.sh
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 15e5d779070b7286ce17437e921e102985df49b1..c77377b4f27c8e9d274604b1f0e03b56be79e7d0 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,20 @@
all: run
+_run_mvn_tests:
+ @mvn clean test -B -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn
+
+_cat_jacoco_:
+ @cat /app/target/site/jacoco/index.html
+
+_ci_test: _run_mvn_tests _cat_jacoco_
+
+ci_test:
+ @docker-compose -f docker-compose.test.yml build
+ @docker-compose -f docker-compose.test.yml run ci_test_builder make _ci_test
+
+ci_clean_test:
+ @docker-compose -f docker-compose.test.yml down
+
run:
@docker-compose -f docker-compose.yml up -d
diff --git a/docker-compose.test.yml b/docker-compose.test.yml
index 9b67254a36d0a04504b54141f62f5109282518ab..398f1633077b69fdad5eda27883d2524ea31c141 100644
--- a/docker-compose.test.yml
+++ b/docker-compose.test.yml
@@ -5,7 +5,8 @@ networks:
name: 'tcn2'
services:
- test_builder:
+
+ ci_test_builder: &app
build: .
restart: always
container_name: 'test_corporate_builder2'
@@ -13,11 +14,14 @@ services:
- test_db
- test_mbroker
working_dir: '/app'
- volumes:
- - .:/app
networks:
- test_corporate_network
+ test_builder:
+ <<: *app
+ volumes:
+ - .:/app
+
test_db:
image: 'postgres:10-alpine'
container_name: 'test_corporate_db2'
diff --git a/pom.xml b/pom.xml
index 02841372dcc2e8b2e44720c7289a1826089d74f9..889e40ea4b08d480b43a9cc14bd4037184c0e272 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,26 +105,6 @@
<excludeDevtools>false</excludeDevtools>
</configuration>
</plugin>
- <plugin>
- <groupId>org.jacoco</groupId>
- <artifactId>jacoco-maven-plugin</artifactId>
- <version>0.8.3</version>
- <executions>
- <execution>
- <id>pre-unit-test</id>
- <goals>
- <goal>prepare-agent</goal>
- </goals>
- </execution>
- <execution>
- <id>post-unit-test</id>
- <phase>test</phase>
- <goals>
- <goal>report</goal>
- </goals>
- </execution>
- </executions>
- </plugin>
<plugin>
<artifactId>exec-maven-plugin</artifactId>
<groupId>org.codehaus.mojo</groupId>
@@ -160,6 +140,25 @@
</dependency>
</dependencies>
</plugin>
+ <plugin>
+ <groupId>org.jacoco</groupId>
+ <artifactId>jacoco-maven-plugin</artifactId>
+ <version>0.8.5</version>
+ <executions>
+ <execution>
+ <goals>
+ <goal>prepare-agent</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>report</id>
+ <phase>test</phase>
+ <goals>
+ <goal>report</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
</plugins>
</build>
diff --git a/src/main/kotlin/com/s3ai/corporate_app2/controllers/CinemasController.kt b/src/main/kotlin/com/s3ai/corporate_app2/controllers/CinemasController.kt
index e40ad46da0a945f79eb4850bd19f225df1f7f8aa..0d17a4b4fcb76b8f76335734efdb00b570e3db8e 100644
--- a/src/main/kotlin/com/s3ai/corporate_app2/controllers/CinemasController.kt
+++ b/src/main/kotlin/com/s3ai/corporate_app2/controllers/CinemasController.kt
@@ -4,10 +4,15 @@ import com.s3ai.corporate_app2.Cinema
import com.s3ai.corporate_app2.CinemaService
import com.s3ai.corporate_app2.jms.JMSPublisher
import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.http.HttpStatus
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.web.bind.annotation.*
+import org.springframework.web.client.HttpClientErrorException
+import org.springframework.web.server.ResponseStatusException
import org.springframework.web.servlet.view.RedirectView
+import java.lang.IllegalArgumentException
+import java.util.*
import java.util.UUID.fromString
@Controller
@@ -33,7 +38,14 @@ class CinemasController {
cinema = Cinema()
model.addAttribute("action", "Create")
} else {
- cinema = cinemaService.findById(fromString(id))
+ val idParsed: UUID
+ try {
+ idParsed = fromString(id)
+ }
+ catch (e: IllegalArgumentException){
+ throw ResponseStatusException(HttpStatus.BAD_REQUEST)
+ }
+ cinema = cinemaService.findById(idParsed)
model.addAttribute("action", "Edit")
}
model.addAttribute("cinema", cinema)
diff --git a/src/main/kotlin/com/s3ai/corporate_app2/controllers/TicketsController.kt b/src/main/kotlin/com/s3ai/corporate_app2/controllers/TicketsController.kt
index dbe5e808384f2b2210b04904302d31d98d35928c..878cce6b4030d8f9a4ee6b1c50662c88ae215695 100644
--- a/src/main/kotlin/com/s3ai/corporate_app2/controllers/TicketsController.kt
+++ b/src/main/kotlin/com/s3ai/corporate_app2/controllers/TicketsController.kt
@@ -6,10 +6,13 @@ import com.s3ai.corporate_app2.TicketService
import com.s3ai.corporate_app2.UserService
import com.s3ai.corporate_app2.jms.JMSPublisher
import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.http.HttpStatus
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.web.bind.annotation.*
+import org.springframework.web.server.ResponseStatusException
import org.springframework.web.servlet.view.RedirectView
+import java.lang.IllegalArgumentException
import java.util.*
@Controller
@@ -38,7 +41,14 @@ class TicketsController {
ticket = Ticket()
model.addAttribute("action", "Create")
} else {
- ticket = ticketService.findById(UUID.fromString(id))
+ val idParsed: UUID
+ try {
+ idParsed = UUID.fromString(id)
+ }
+ catch (e: IllegalArgumentException){
+ throw ResponseStatusException(HttpStatus.BAD_REQUEST)
+ }
+ ticket = ticketService.findById(idParsed)
model.addAttribute("action", "Edit")
}
model.addAttribute("ticket", ticket)
diff --git a/src/main/kotlin/com/s3ai/corporate_app2/controllers/UsersController.kt b/src/main/kotlin/com/s3ai/corporate_app2/controllers/UsersController.kt
index 591e24dfecb8314424a5eb11a084fa29ca9a0e80..5ea71ad523abf891aaf7d031fd42f35c0c481130 100644
--- a/src/main/kotlin/com/s3ai/corporate_app2/controllers/UsersController.kt
+++ b/src/main/kotlin/com/s3ai/corporate_app2/controllers/UsersController.kt
@@ -4,10 +4,13 @@ import com.s3ai.corporate_app2.User
import com.s3ai.corporate_app2.UserService
import com.s3ai.corporate_app2.jms.JMSPublisher
import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.http.HttpStatus
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.web.bind.annotation.*
+import org.springframework.web.server.ResponseStatusException
import org.springframework.web.servlet.view.RedirectView
+import java.lang.IllegalArgumentException
import java.util.*
@Controller
@@ -33,7 +36,14 @@ class UsersController {
user = User()
model.addAttribute("action", "Create")
} else {
- user = userService.findById(UUID.fromString(id))
+ val idParsed: UUID
+ try {
+ idParsed = UUID.fromString(id)
+ }
+ catch (e: IllegalArgumentException){
+ throw ResponseStatusException(HttpStatus.BAD_REQUEST)
+ }
+ user = userService.findById(idParsed)
model.addAttribute("action", "Edit")
}
model.addAttribute("user", user)
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/CinemasApiTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/CinemasApiTest.kt
deleted file mode 100644
index 62638c0e392479447fc5b58bcfd215c8b9d24e5f..0000000000000000000000000000000000000000
--- a/src/test/kotlin/com/s3ai/corporate_app2/CinemasApiTest.kt
+++ /dev/null
@@ -1,108 +0,0 @@
-package com.s3ai.corporate_app2
-
-import com.s3ai.corporate_app2.controllers.CinemasController
-import com.s3ai.corporate_app2.controllers.rest.CinemaApiController
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.http.MediaType
-import org.springframework.test.context.jdbc.Sql
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
-import org.springframework.ui.ExtendedModelMap
-import java.util.*
-
-
-@SpringBootTest
-@AutoConfigureMockMvc
-class CinemasApiTest {
- @Autowired
- private lateinit var controller: CinemasController
-
- @Autowired
- private lateinit var mvc: MockMvc
-
- @Autowired
- private lateinit var apiController: CinemaApiController
-
- @Test
- @Throws(Exception::class)
- fun contextLoads() {
- assertThat(controller).isNotNull
- assertThat(apiController).isNotNull
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldUpdateCinema() {
- val cinema = Cinema()
- val id = UUID.randomUUID()
- cinema.id = id
- cinema.name = "test"
- controller.updateCinema(cinema)
- val cinemaFromBase = controller.cinemaService.findById(id)
- assertThat(cinemaFromBase?.equals(cinema))
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldRedirectToCreateCinemaIfIdNotExists() {
- val model = ExtendedModelMap()
- val redirect = controller.getCinemaEditPage(UUID.randomUUID().toString(), model)
- assertThat(redirect.equals("cinemas/edit"))
- assertThat(model.getValue("action") == "Create")
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldRedirectToEditCinemaIfIdExists() {
- val cinema = Cinema()
- val id = UUID.randomUUID()
- cinema.id = id
- cinema.name = "test"
- controller.updateCinema(cinema)
- val model = ExtendedModelMap()
- val redirect = controller.getCinemaEditPage(id.toString(), model)
- assertThat(redirect.equals("cinemas/edit"))
- assertThat(model.getValue("action") == "Edit")
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldReturnCinemasBrowsePage() {
- val cinema = Cinema()
- val id = UUID.randomUUID()
- cinema.id = id
- cinema.name = "test"
- controller.updateCinema(cinema)
- val model = ExtendedModelMap()
- val redirect = controller.getCinemasBrowsePage(model)
- assertThat(redirect.equals("cinemas/list"))
- assertThat(model.getValue("cinemas")).isNotNull
- }
-
- @Test
- @Sql("/cinemasFill.sql")
- fun mvcTest() {
- mvc.perform(get("/api/json/cinemas/all")
- .contentType(MediaType.APPLICATION_JSON))
- .andExpect(status().isOk)
- }
-
-// @Test
-// @Throws(Exception::class)
-// fun shouldDeleteCinema() {
-// val cinema = Cinema()
-// val id = UUID.randomUUID()
-// cinema.id = id
-// cinema.name = "test"
-// controller.updateCinema(cinema)
-// var responce = HttpResponseFactory
-// apiController.deleteCinema(id.toString(), Http)
-// val cinemaFromBase = controller.cinemaService.findById(id)
-// assertThat(cinemaFromBase?.equals(cinema))
-// }
-}
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/TestUtils.kt b/src/test/kotlin/com/s3ai/corporate_app2/TestUtils.kt
index ab3d40a1fe353957cd6572e1219fd29f7c3625c3..35ecbafd6d837aa4a297382b27b97436ee26f60c 100644
--- a/src/test/kotlin/com/s3ai/corporate_app2/TestUtils.kt
+++ b/src/test/kotlin/com/s3ai/corporate_app2/TestUtils.kt
@@ -1,3 +1,17 @@
package com.s3ai.corporate_app2
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.MapperFeature
+import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule
+import com.fasterxml.jackson.dataformat.xml.XmlMapper
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+
+internal val kotlinXmlMapper = XmlMapper(JacksonXmlModule().apply {
+ setDefaultUseWrapper(false)
+}).registerKotlinModule()
+ .configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true)
+ .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
+
+internal val kotlinJsonMapper = jacksonObjectMapper()
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/TicketsApiTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/TicketsApiTest.kt
deleted file mode 100644
index 1b91a80ea29649545401550f4d643d3edf59a5d1..0000000000000000000000000000000000000000
--- a/src/test/kotlin/com/s3ai/corporate_app2/TicketsApiTest.kt
+++ /dev/null
@@ -1,71 +0,0 @@
-package com.s3ai.corporate_app2
-
-import com.s3ai.corporate_app2.controllers.TicketsController
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.ui.ExtendedModelMap
-import java.util.*
-
-
-@SpringBootTest
-class TicketsApiTest {
- @Autowired
- private lateinit var controller: TicketsController
-
- @Test
- @Throws(Exception::class)
- fun contextLoads() {
- assertThat(controller).isNotNull
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldUpdateTicket() {
- val ticket = Ticket()
- val id = UUID.randomUUID()
- ticket.id = id
- ticket.movie = "test"
- controller.updateTicket(ticket)
- val ticketFromBase = controller.ticketService.findById(id)
- assertThat(ticketFromBase?.equals(ticket))
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldRedirectToCreateTicketIfIdNotExists() {
- val model = ExtendedModelMap()
- val redirect = controller.getTicketEditPage(UUID.randomUUID().toString(), model)
- assertThat(redirect.equals("tickets/edit"))
- assertThat(model.getValue("action") == "Create")
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldRedirectToEditCinemaIfIdExists() {
- val ticket = Ticket()
- val id = UUID.randomUUID()
- ticket.id = id
- ticket.movie = "test"
- controller.updateTicket(ticket)
- val model = ExtendedModelMap()
- val redirect = controller.getTicketEditPage(id.toString(), model)
- assertThat(redirect.equals("tickets/edit"))
- assertThat(model.getValue("action") == "Edit")
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldReturnTicketsBrowsePage() {
- val ticket = Ticket()
- val id = UUID.randomUUID()
- ticket.id = id
- ticket.movie = "test"
- controller.updateTicket(ticket)
- val model = ExtendedModelMap()
- val redirect = controller.getTicketsBrowsePage(model)
- assertThat(redirect.equals("tickets/list"))
- assertThat(model.getValue("tickets")).isNotNull
- }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/UsersApiTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/UsersApiTest.kt
deleted file mode 100644
index 8ff981ce7a1460d4f2aa70771a06a0845e497a6f..0000000000000000000000000000000000000000
--- a/src/test/kotlin/com/s3ai/corporate_app2/UsersApiTest.kt
+++ /dev/null
@@ -1,71 +0,0 @@
-package com.s3ai.corporate_app2
-
-import com.s3ai.corporate_app2.controllers.UsersController
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.ui.ExtendedModelMap
-import java.util.*
-
-
-@SpringBootTest
-class UsersApiTest {
- @Autowired
- private lateinit var controller: UsersController
-
- @Test
- @Throws(Exception::class)
- fun contextLoads() {
- assertThat(controller).isNotNull
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldUpdateCinema() {
- val user = User()
- val id = UUID.randomUUID()
- user.id = id
- user.name = "test"
- controller.updateUser(user)
- val userFromBase = controller.userService.findById(id)
- assertThat(userFromBase?.equals(user))
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldRedirectToCreateUserIfIdNotExists() {
- val model = ExtendedModelMap()
- val redirect = controller.getUserEditPage(UUID.randomUUID().toString(), model)
- assertThat(redirect.equals("users/edit"))
- assertThat(model.getValue("action") == "Create")
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldRedirectToEditCinemaIfIdExists() {
- val user = User()
- val id = UUID.randomUUID()
- user.id = id
- user.name = "test"
- controller.updateUser(user)
- val model = ExtendedModelMap()
- val redirect = controller.getUserEditPage(id.toString(), model)
- assertThat(redirect.equals("users/edit"))
- assertThat(model.getValue("action") == "Edit")
- }
-
- @Test
- @Throws(Exception::class)
- fun shouldReturnUsersBrowsePage() {
- val user = User()
- val id = UUID.randomUUID()
- user.id = id
- user.name = "test"
- controller.updateUser(user)
- val model = ExtendedModelMap()
- val redirect = controller.getUsersBrowsePage(model)
- assertThat(redirect.equals("users/list"))
- assertThat(model.getValue("users")).isNotNull
- }
-}
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/CinemasTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/CinemasTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a159c661f33daae4542306f98cb1d877a47d27c6
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/CinemasTest.kt
@@ -0,0 +1,104 @@
+package com.s3ai.corporate_app2.controllers
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.s3ai.corporate_app2.Cinema
+import com.s3ai.corporate_app2.CinemaService
+import org.assertj.core.api.Assertions.assertThat
+import org.hamcrest.Matchers
+import org.hamcrest.CoreMatchers
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.http.MediaType
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.*
+import java.lang.reflect.GenericArrayType
+import java.util.*
+
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class CinemasTest {
+ @Autowired
+ private lateinit var service: CinemaService
+
+ @Autowired
+ private lateinit var controller: CinemasController
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ assertThat(controller).isNotNull
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/cinemasFill.sql")
+ fun updateCinemaTest() {
+ val cinema = service.findAll().random()
+ print(cinema.id)
+
+ cinema.name = UUID.randomUUID().toString()
+
+ mvc.perform(MockMvcRequestBuilders.post("/cinemas/update")
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(ObjectMapper().writeValueAsString(cinema)))
+ .andExpect(status().isFound)
+ .andExpect(redirectedUrl("/cinemas/list"))
+
+ val updatedCinema = service.findById(cinema.id!!)
+ assertThat(cinema == updatedCinema)
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun editNonExistingIdRedirectToCreateTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/cinemas/edit"))
+ .andExpect(status().isOk)
+ .andExpect(model().attribute("action", Matchers.equalTo("Create")))
+ .andExpect(model().attribute("cinema", Matchers.notNullValue(Cinema::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/cinemasFill.sql")
+ fun editPageTest() {
+ val randomCinemaId = service.findAll().map { e -> e.id }.distinct().random()
+ mvc.perform(MockMvcRequestBuilders.get("/cinemas/edit?id=${randomCinemaId}"))
+ .andExpect(status().isOk)
+ .andExpect(model().attribute("action", Matchers.equalTo("Edit")))
+ .andExpect(model().attribute("cinema", Matchers.notNullValue(Cinema::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/cinemasFill.sql")
+ fun listPageTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/cinemas/list"))
+ .andExpect(status().isOk)
+ .andExpect(model().attribute("cinemas", Matchers.notNullValue(MutableCollection::class.java)))
+ .andExpect(model().attribute("cinemas", CoreMatchers.everyItem(Matchers.notNullValue(Cinema::class.java))))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun listEmptyPageTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/cinemas/list"))
+ .andExpect(status().isOk)
+ .andExpect(model().attribute("cinemas", Matchers.notNullValue(MutableCollection::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun editInvalidUUIDTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/cinemas/edit?id=totallyNotAnUUID"))
+ .andExpect(MockMvcResultMatchers.status().isBadRequest)
+ }
+}
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/TicketsTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/TicketsTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9a0b14735ca98106de3271b0e7487d3f2c86111f
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/TicketsTest.kt
@@ -0,0 +1,102 @@
+package com.s3ai.corporate_app2.controllers
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.s3ai.corporate_app2.Ticket
+import com.s3ai.corporate_app2.TicketService
+import com.s3ai.corporate_app2.User
+import org.assertj.core.api.Assertions.assertThat
+import org.hamcrest.CoreMatchers
+import org.hamcrest.Matchers
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.http.MediaType
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+import java.util.*
+
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class TicketsTest {
+ @Autowired
+ private lateinit var service: TicketService
+
+ @Autowired
+ private lateinit var controller: TicketsController
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ assertThat(controller).isNotNull
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun updateTicketTest() {
+ val ticket = service.findAll().random()
+ print(ticket.id)
+
+ ticket.movie = UUID.randomUUID().toString()
+
+ mvc.perform(MockMvcRequestBuilders.post("/tickets/update")
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(ObjectMapper().writeValueAsString(ticket)))
+ .andExpect(MockMvcResultMatchers.status().isFound)
+ .andExpect(MockMvcResultMatchers.redirectedUrl("/tickets/list"))
+
+ val updatedTicket = service.findById(ticket.id!!)
+ assertThat(ticket == updatedTicket)
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun editNonExistingIdRedirectToCreateTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/tickets/edit"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("action", Matchers.equalTo("Create")))
+ .andExpect(MockMvcResultMatchers.model().attribute("ticket", Matchers.notNullValue(Ticket::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun editPageTest() {
+ val randomTicketId = service.findAll().map { e -> e.id }.distinct().random()
+ mvc.perform(MockMvcRequestBuilders.get("/tickets/edit?id=${randomTicketId}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("action", Matchers.equalTo("Edit")))
+ .andExpect(MockMvcResultMatchers.model().attribute("ticket", Matchers.notNullValue(Ticket::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun listPageTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/tickets/list"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("tickets", CoreMatchers.everyItem(Matchers.notNullValue(Ticket::class.java))))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun listEmptyPageTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/tickets/list"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("tickets", Matchers.notNullValue(MutableCollection::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun editInvalidUUIDTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/tickets/edit?id=totallyNotAnUUID"))
+ .andExpect(MockMvcResultMatchers.status().isBadRequest)
+ }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/UsersTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/UsersTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f58ead09f91aa5476fe0c571e19e434f58402951
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/UsersTest.kt
@@ -0,0 +1,103 @@
+package com.s3ai.corporate_app2.controllers
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.s3ai.corporate_app2.Cinema
+import com.s3ai.corporate_app2.User
+import com.s3ai.corporate_app2.UserService
+import org.assertj.core.api.Assertions.assertThat
+import org.hamcrest.CoreMatchers
+import org.hamcrest.CoreMatchers.everyItem
+import org.hamcrest.Matchers
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.http.MediaType
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+import java.util.*
+
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class UsersTest {
+ @Autowired
+ private lateinit var service: UserService
+
+ @Autowired
+ private lateinit var controller: UsersController
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ assertThat(controller).isNotNull
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/usersFill.sql")
+ fun updateUserTest() {
+ val user = service.findAll().random()
+ print(user.id)
+
+ user.name = UUID.randomUUID().toString()
+
+ mvc.perform(MockMvcRequestBuilders.post("/users/update")
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(ObjectMapper().writeValueAsString(user)))
+ .andExpect(MockMvcResultMatchers.status().isFound)
+ .andExpect(MockMvcResultMatchers.redirectedUrl("/users/list"))
+
+ val updatedUser = service.findById(user.id!!)
+ assertThat(user == updatedUser)
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun editNonExistingIdRedirectToCreateTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/users/edit"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("action", Matchers.equalTo("Create")))
+ .andExpect(MockMvcResultMatchers.model().attribute("user", Matchers.notNullValue(User::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/usersFill.sql")
+ fun editPageTest() {
+ val randomUserId = service.findAll().map { e -> e.id }.distinct().random()
+ mvc.perform(MockMvcRequestBuilders.get("/users/edit?id=${randomUserId}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("action", Matchers.equalTo("Edit")))
+ .andExpect(MockMvcResultMatchers.model().attribute("user", Matchers.notNullValue(User::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ @Sql("/usersFill.sql")
+ fun listPageTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/users/list"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("users", everyItem(Matchers.notNullValue(User::class.java))))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun listEmptyPageTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/users/list"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andExpect(MockMvcResultMatchers.model().attribute("users", Matchers.notNullValue(MutableCollection::class.java)))
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun editInvalidUUIDTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/users/edit?id=totallyNotAnUUID"))
+ .andExpect(MockMvcResultMatchers.status().isBadRequest)
+ }
+}
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/CinemaApiTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/CinemaApiTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f2692518bd8857143bc1b807f8c49ae8bbac6f75
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/CinemaApiTest.kt
@@ -0,0 +1,78 @@
+package com.s3ai.corporate_app2.controllers.rest
+
+import com.s3ai.corporate_app2.CinemaService
+import com.s3ai.corporate_app2.TicketService
+import org.assertj.core.api.Assertions
+import org.hamcrest.MatcherAssert.assertThat
+import org.hamcrest.Matchers.equalTo
+import org.hamcrest.Matchers.hasItem
+import org.hamcrest.core.IsNot.not
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.MvcResult
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import java.util.*
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class CinemaApiTest {
+ @Autowired
+ private lateinit var service: CinemaService
+
+ @Autowired
+ private lateinit var ticketService: TicketService
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ Assertions.assertThat(mvc).isNotNull
+ Assertions.assertThat(service).isNotNull
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql")
+ fun fillTest() {
+ mvc.perform(get("/api/cinemas/fill"))
+ .andDo { e: MvcResult -> println(e.response) }
+ .andExpect(status().isOk)
+ assertThat(service.findAll().size, equalTo(401))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun deleteTest() {
+ val randomCinemaId = ticketService.findAll().map { e -> e.cinema?.id }.distinct().random()
+ print(randomCinemaId)
+ mvc.perform(delete("/api/cinemas/delete?id=${randomCinemaId}"))
+ .andExpect(status().isOk)
+ val tickets = ticketService.findAll().map { e -> e.cinema!!.id }.distinct()
+ assertThat(tickets, not(hasItem(randomCinemaId)))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun deleteNonExistingIdReturns404Test() {
+ val randomCinemaId = UUID.randomUUID()
+ print(randomCinemaId)
+ mvc.perform(delete("/api/cinemas/delete?id=${randomCinemaId}"))
+ .andExpect(status().isNotFound)
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun deleteInvalidUUIDTest() {
+ mvc.perform(delete("/api/cinemas/delete?id=totallyNotAnUUID"))
+ .andExpect(status().isBadRequest)
+ }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/TicketApiTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/TicketApiTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b493ac1a651e2107b84b98e66f3949e517039be7
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/TicketApiTest.kt
@@ -0,0 +1,70 @@
+package com.s3ai.corporate_app2.controllers.rest
+
+import com.s3ai.corporate_app2.TicketService
+import org.assertj.core.api.Assertions
+import org.hamcrest.MatcherAssert
+import org.hamcrest.Matchers
+import org.hamcrest.core.IsNot
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.MvcResult
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+import java.util.*
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class TicketApiTest {
+ @Autowired
+ private lateinit var service: TicketService
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ Assertions.assertThat(mvc).isNotNull
+ Assertions.assertThat(service).isNotNull
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun fillTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/api/tickets/fill"))
+ .andDo { e: MvcResult -> println(e.response) }
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ MatcherAssert.assertThat(service.findAll().size, Matchers.equalTo(401))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun deleteTest() {
+ val randomTicketId = service.findAll().map { e -> e.id }.distinct().random()
+ print(randomTicketId)
+ mvc.perform(MockMvcRequestBuilders.delete("/api/tickets/delete?id=${randomTicketId}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ val tickets = service.findAll().map { e -> e.id }.distinct()
+ MatcherAssert.assertThat(tickets, IsNot.not(Matchers.hasItem(randomTicketId)))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun deleteNonExistingIdReturns404Test() {
+ val randomTicketId = UUID.randomUUID()
+ print(randomTicketId)
+ mvc.perform(MockMvcRequestBuilders.delete("/api/tickets/delete?id=${randomTicketId}"))
+ .andExpect(MockMvcResultMatchers.status().isNotFound)
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun deleteInvalidUUIDTest() {
+ mvc.perform(MockMvcRequestBuilders.delete("/api/tickets/delete?id=totallyNotAnUUID"))
+ .andExpect(MockMvcResultMatchers.status().isBadRequest)
+ }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/UserApiTest.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/UserApiTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..55ee715ba587b189d34b3f930169adb6c6e7dbe4
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/UserApiTest.kt
@@ -0,0 +1,74 @@
+package com.s3ai.corporate_app2.controllers.rest
+
+import com.s3ai.corporate_app2.UserService
+import com.s3ai.corporate_app2.TicketService
+import org.assertj.core.api.Assertions
+import org.hamcrest.MatcherAssert
+import org.hamcrest.Matchers
+import org.hamcrest.core.IsNot
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.MvcResult
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+import java.util.*
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class UserApiTest {
+ @Autowired
+ private lateinit var service: UserService
+
+ @Autowired
+ private lateinit var ticketService: TicketService
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ Assertions.assertThat(mvc).isNotNull
+ Assertions.assertThat(service).isNotNull
+ }
+
+ @Test
+ @Sql("/usersFill.sql")
+ fun fillTest() {
+ mvc.perform(MockMvcRequestBuilders.get("/api/users/fill"))
+ .andDo { e: MvcResult -> println(e.response) }
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ MatcherAssert.assertThat(service.findAll().size, Matchers.equalTo(401))
+ }
+
+ @Test
+ @Sql("/usersFill.sql", "/cinemasFill.sql", "/ticketsFill.sql")
+ fun deleteTest() {
+ val randomUserId = ticketService.findAll().map { e -> e.user?.id }.distinct().random()
+ print(randomUserId)
+ mvc.perform(MockMvcRequestBuilders.delete("/api/users/delete?id=${randomUserId}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ val tickets = ticketService.findAll().map { e -> e.user!!.id }.distinct()
+ MatcherAssert.assertThat(tickets, IsNot.not(Matchers.hasItem(randomUserId)))
+ }
+
+ @Test
+ @Sql("/usersFill.sql", "/cinemasFill.sql", "/ticketsFill.sql")
+ fun deleteNonExistingIdReturns404Test() {
+ val randomUserId = UUID.randomUUID()
+ print(randomUserId)
+ mvc.perform(MockMvcRequestBuilders.delete("/api/users/delete?id=${randomUserId}"))
+ .andExpect(MockMvcResultMatchers.status().isNotFound)
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun deleteInvalidUUIDTest() {
+ mvc.perform(MockMvcRequestBuilders.delete("/api/users/delete?id=totallyNotAnUUID"))
+ .andExpect(MockMvcResultMatchers.status().isBadRequest)
+ }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/CinemasFormattingTests.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/CinemasFormattingTests.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5428d37656617d791a2a8d38f3fdf0aab91e7e73
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/CinemasFormattingTests.kt
@@ -0,0 +1,84 @@
+package com.s3ai.corporate_app2.controllers.rest.formats
+
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.MapperFeature
+import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule
+import com.fasterxml.jackson.dataformat.xml.XmlMapper
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import com.s3ai.corporate_app2.Cinema
+import com.s3ai.corporate_app2.CinemaService
+import com.s3ai.corporate_app2.kotlinJsonMapper
+import com.s3ai.corporate_app2.kotlinXmlMapper
+import org.assertj.core.api.Assertions
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class CinemasFormattingTests {
+ @Autowired
+ private lateinit var service: CinemaService
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ Assertions.assertThat(mvc).isNotNull
+ Assertions.assertThat(service).isNotNull
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql")
+ fun allJSONTest() {
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/json/cinemas/all"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val cinemas: List<Cinema> = kotlinJsonMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(cinemas.size, equalTo(100))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql")
+ fun itemJSONTest() {
+ val randomCinema = service.findAll().random()
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/json/cinemas/item/${randomCinema.id}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val parsedCinema: Cinema = kotlinJsonMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(parsedCinema.toString(), equalTo(randomCinema.toString()))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql")
+ fun allXMLTest() {
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/xml/cinemas/all"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val cinemas: List<Cinema> = kotlinXmlMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(cinemas.size, equalTo(100))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql")
+ fun itemXMLTest() {
+ val randomCinema = service.findAll().random()
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/xml/cinemas/item/${randomCinema.id}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val parsedCinema: Cinema = kotlinXmlMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(parsedCinema.toString(), equalTo(randomCinema.toString()))
+ }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/TicketsFormattingTests.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/TicketsFormattingTests.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2af121d0cada32827f2dc4632132b4022b384778
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/TicketsFormattingTests.kt
@@ -0,0 +1,78 @@
+package com.s3ai.corporate_app2.controllers.rest.formats
+
+import com.fasterxml.jackson.module.kotlin.readValue
+import com.s3ai.corporate_app2.Ticket
+import com.s3ai.corporate_app2.TicketService
+import com.s3ai.corporate_app2.kotlinJsonMapper
+import com.s3ai.corporate_app2.kotlinXmlMapper
+import org.assertj.core.api.Assertions
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class TicketsFormattingTests {
+ @Autowired
+ private lateinit var service: TicketService
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ Assertions.assertThat(mvc).isNotNull
+ Assertions.assertThat(service).isNotNull
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun allJSONTest() {
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/json/tickets/all"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val cinemas: List<Ticket> = kotlinJsonMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(cinemas.size, equalTo(100))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun itemJSONTest() {
+ val randomTicket = service.findAll().random()
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/json/tickets/item/${randomTicket.id}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val parsedTicket: Ticket = kotlinJsonMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(parsedTicket.toString(), equalTo(randomTicket.toString()))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun allXMLTest() {
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/xml/tickets/all"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val cinemas: List<Ticket> = kotlinXmlMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(cinemas.size, equalTo(100))
+ }
+
+ @Test
+ @Sql("/cinemasFill.sql", "/usersFill.sql", "/ticketsFill.sql")
+ fun itemXMLTest() {
+ val randomTicket = service.findAll().random()
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/xml/tickets/item/${randomTicket.id}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val parsedTicket: Ticket = kotlinXmlMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(parsedTicket.toString(), equalTo(randomTicket.toString()))
+ }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/UsersFormattingTests.kt b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/UsersFormattingTests.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a6cd837e536d68cd4acbdde5c6bdbb0c998d45cc
--- /dev/null
+++ b/src/test/kotlin/com/s3ai/corporate_app2/controllers/rest/formats/UsersFormattingTests.kt
@@ -0,0 +1,83 @@
+package com.s3ai.corporate_app2.controllers.rest.formats
+
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.MapperFeature
+import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule
+import com.fasterxml.jackson.dataformat.xml.XmlMapper
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import com.s3ai.corporate_app2.*
+import com.s3ai.corporate_app2.kotlinJsonMapper
+import com.s3ai.corporate_app2.kotlinXmlMapper
+import org.assertj.core.api.Assertions
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.jdbc.Sql
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
+
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class UsersFormattingTests {
+ @Autowired
+ private lateinit var service: UserService
+
+ @Autowired
+ private lateinit var mvc: MockMvc
+
+ @Test
+ @Throws(Exception::class)
+ fun contextLoads() {
+ Assertions.assertThat(mvc).isNotNull
+ Assertions.assertThat(service).isNotNull
+ }
+
+ @Test
+ @Sql("/usersFill.sql")
+ fun allJSONTest() {
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/json/users/all"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val cinemas: List<User> = kotlinJsonMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(cinemas.size, equalTo(100))
+ }
+
+ @Test
+ @Sql("/usersFill.sql")
+ fun itemJSONTest() {
+ val randomUser = service.findAll().random()
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/json/users/item/${randomUser.id}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val parsedUser: User = kotlinJsonMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(parsedUser.toString(), equalTo(randomUser.toString()))
+ }
+
+ @Test
+ @Sql("/usersFill.sql")
+ fun allXMLTest() {
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/xml/users/all"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val cinemas: List<User> = kotlinXmlMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(cinemas.size, equalTo(100))
+ }
+
+ @Test
+ @Sql("/usersFill.sql")
+ fun itemXMLTest() {
+ val randomUser = service.findAll().random()
+ val mvcResult = mvc.perform(MockMvcRequestBuilders.get("/api/xml/users/item/${randomUser.id}"))
+ .andExpect(MockMvcResultMatchers.status().isOk)
+ .andReturn()
+ val parsedUser: User = kotlinXmlMapper.readValue(mvcResult.response.contentAsString)
+ assertThat(parsedUser.toString(), equalTo(randomUser.toString()))
+ }
+}
\ No newline at end of file