/
ProjectsRouteZSpec.scala
141 lines (126 loc) · 6.89 KB
/
ProjectsRouteZSpec.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
package org.knora.webapi.routing.admin
import zhttp.http._
import zio._
import zio.mock.Expectation
import zio.test.ZIOSpecDefault
import zio.test._
import java.net.URLEncoder
import org.knora.webapi.config.AppConfig
import org.knora.webapi.messages.admin.responder.projectsmessages.ProjectADM
import org.knora.webapi.messages.admin.responder.projectsmessages.ProjectGetRequestADM
import org.knora.webapi.messages.admin.responder.projectsmessages.ProjectGetResponseADM
import org.knora.webapi.messages.admin.responder.projectsmessages.ProjectIdentifierADM
import org.knora.webapi.messages.store.triplestoremessages.StringLiteralV2
import org.knora.webapi.responders.ActorToZioBridge
import org.knora.webapi.responders.ActorToZioBridgeMock
import org.knora.webapi.responders.admin.RestProjectsService
object ProjectRouteZSpec extends ZIOSpecDefault {
private val systemUnderTest: URIO[ProjectsRouteZ, HttpApp[Any, Nothing]] = ZIO.service[ProjectsRouteZ].map(_.route)
// Test data
private val projectIri: ProjectIdentifierADM.IriIdentifier =
ProjectIdentifierADM.IriIdentifier
.fromString("http://rdfh.ch/projects/0001")
.getOrElse(throw new IllegalArgumentException())
private val projectShortname: ProjectIdentifierADM.ShortnameIdentifier =
ProjectIdentifierADM.ShortnameIdentifier
.fromString("shortname")
.getOrElse(throw new IllegalArgumentException())
private val projectShortcode: ProjectIdentifierADM.ShortcodeIdentifier =
ProjectIdentifierADM.ShortcodeIdentifier
.fromString("AB12")
.getOrElse(throw new IllegalArgumentException())
private val basePathIri: Path = !! / "admin" / "projects" / "iri"
private val basePathShortname: Path = !! / "admin" / "projects" / "shortname"
private val basePathShortcode: Path = !! / "admin" / "projects" / "shortcode"
private val validIriUrlEncoded: String = URLEncoder.encode(projectIri.value.value, "utf-8")
private val validShortname: String = "shortname"
private val validShortcode: String = "AB12"
private val expectedRequestSuccessIri: ProjectGetRequestADM = ProjectGetRequestADM(projectIri)
private val expectedRequestSuccessShortname: ProjectGetRequestADM = ProjectGetRequestADM(projectShortname)
private val expectedRequestSuccessShortcode: ProjectGetRequestADM = ProjectGetRequestADM(projectShortcode)
private val expectedResponseSuccess: ProjectGetResponseADM =
ProjectGetResponseADM(
ProjectADM(
id = "id",
shortname = "shortname",
shortcode = "AB12",
longname = None,
description = List(StringLiteralV2("description")),
keywords = List.empty,
logo = None,
ontologies = List.empty,
status = false,
selfjoin = false
)
)
// Expectations and layers for ActorToZioBridge mock
private val commonLayers: URLayer[ActorToZioBridge, ProjectsRouteZ] =
ZLayer.makeSome[ActorToZioBridge, ProjectsRouteZ](AppConfig.test, ProjectsRouteZ.layer, RestProjectsService.layer)
private val expectMessageToProjectResponderIri: ULayer[ActorToZioBridge] =
ActorToZioBridgeMock.AskAppActor
.of[ProjectGetResponseADM]
.apply(Assertion.equalTo(expectedRequestSuccessIri), Expectation.value(expectedResponseSuccess))
.toLayer
private val expectMessageToProjectResponderShortname: ULayer[ActorToZioBridge] =
ActorToZioBridgeMock.AskAppActor
.of[ProjectGetResponseADM]
.apply(Assertion.equalTo(expectedRequestSuccessShortname), Expectation.value(expectedResponseSuccess))
.toLayer
private val expectMessageToProjectResponderShortcode: ULayer[ActorToZioBridge] =
ActorToZioBridgeMock.AskAppActor
.of[ProjectGetResponseADM]
.apply(Assertion.equalTo(expectedRequestSuccessShortcode), Expectation.value(expectedResponseSuccess))
.toLayer
private val expectNoInteractionWithProjectsResponderADM = ActorToZioBridgeMock.empty
val spec: Spec[Any, Serializable] =
suite("ProjectsRouteZSpec")(
suite("get project by IRI")(
test("given valid project iri should respond with success") {
val urlWithValidIri = URL.empty.setPath(basePathIri / validIriUrlEncoded)
for {
route <- systemUnderTest
actual <- route.apply(Request(url = urlWithValidIri)).flatMap(_.body.asString)
} yield assertTrue(actual == expectedResponseSuccess.toJsValue.toString())
}.provide(commonLayers, expectMessageToProjectResponderIri),
test("given invalid project iri should respond with bad request") {
val urlWithInvalidIri = URL.empty.setPath(basePathIri / "invalid")
for {
route <- systemUnderTest
actual <- route.apply(Request(url = urlWithInvalidIri)).map(_.status)
} yield assertTrue(actual == Status.BadRequest)
}.provide(commonLayers, expectNoInteractionWithProjectsResponderADM)
),
suite("get project by shortname")(
test("given valid project shortname should respond with success") {
val urlWithValidShortname = URL.empty.setPath(basePathShortname / validShortname)
for {
route <- systemUnderTest
actual <- route.apply(Request(url = urlWithValidShortname)).flatMap(_.body.asString)
} yield assertTrue(actual == expectedResponseSuccess.toJsValue.toString())
}.provide(commonLayers, expectMessageToProjectResponderShortname),
test("given invalid project shortname should respond with bad request") {
val urlWithInvalidShortname = URL.empty.setPath(basePathShortname / "123")
for {
route <- systemUnderTest
actual <- route.apply(Request(url = urlWithInvalidShortname)).map(_.status)
} yield assertTrue(actual == Status.BadRequest)
}.provide(commonLayers, expectNoInteractionWithProjectsResponderADM)
),
suite("get project by shortcode")(
test("given valid project shortcode should respond with success") {
val urlWithValidShortcode = URL.empty.setPath(basePathShortcode / validShortcode)
for {
route <- systemUnderTest
actual <- route.apply(Request(url = urlWithValidShortcode)).flatMap(_.body.asString)
} yield assertTrue(actual == expectedResponseSuccess.toJsValue.toString())
}.provide(commonLayers, expectMessageToProjectResponderShortcode),
test("given invalid project shortcode should respond with bad request") {
val urlWithInvalidShortcode = URL.empty.setPath(basePathShortcode / "invalid")
for {
route <- systemUnderTest
actual <- route.apply(Request(url = urlWithInvalidShortcode)).map(_.status)
} yield assertTrue(actual == Status.BadRequest)
}.provide(commonLayers, expectNoInteractionWithProjectsResponderADM)
)
)
}