forked from guardrail-dev/guardrail
/
Issue165.scala
89 lines (80 loc) · 2.93 KB
/
Issue165.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
package tests.core.issues
import com.twilio.guardrail.generators.Http4s
import com.twilio.guardrail.{ Context, Server, Servers }
import org.scalatest.{ FunSuite, Matchers }
import support.SwaggerSpecRunner
class Issue165 extends FunSuite with Matchers with SwaggerSpecRunner {
import scala.meta._
val swagger: String =
s"""
|swagger: '2.0'
|host: petstore.swagger.io
|paths:
| "/":
| get:
| x-scala-package: store
| operationId: getRoot
| responses:
| 200:
| description: description
| "/foo":
| get:
| x-scala-package: store
| operationId: getFoo
| responses:
| 200:
| description: description
| "/foo/":
| get:
| x-scala-package: store
| operationId: getFooDir
| responses:
| 200:
| description: description
|""".stripMargin
test("Ensure routes are generated") {
val (_, _, Servers(Server(_, _, genHandler, genResource :: _) :: Nil, Nil)) = runSwaggerSpec(swagger)(Context.empty, Http4s)
val handler = q"""
trait StoreHandler[F[_]] {
def getRoot(respond: GetRootResponse.type)(): F[GetRootResponse]
def getFoo(respond: GetFooResponse.type)(): F[GetFooResponse]
def getFooDir(respond: GetFooDirResponse.type)(): F[GetFooDirResponse]
}
"""
val resource = q"""
class StoreResource[F[_]](mapRoute: (String, Request[F], F[Response[F]]) => F[Response[F]] = (_: String, _: Request[F], r: F[Response[F]]) => r)(implicit F: Async[F]) extends Http4sDsl[F] {
def routes(handler: StoreHandler[F]): HttpRoutes[F] = HttpRoutes.of {
{
case req @ GET -> Root =>
val response0 = {
handler.getRoot(GetRootResponse)() flatMap {
case GetRootResponse.Ok =>
Ok()
}
}
mapRoute("getRoot", req, response0)
case req @ GET -> Root / "foo" =>
val response0 = {
handler.getFoo(GetFooResponse)() flatMap {
case GetFooResponse.Ok =>
Ok()
}
}
mapRoute("getFoo", req, response0)
case req @ GET -> Root / "foo" / "" =>
val response0 = {
handler.getFooDir(GetFooDirResponse)() flatMap {
case GetFooDirResponse.Ok =>
Ok()
}
}
mapRoute("getFooDir", req, response0)
}
}
}
"""
genHandler.structure shouldEqual handler.structure
// Cause structure is slightly different but source code is the same the value converted to string and then parsed
genResource.toString().parse[Stat].get.structure shouldEqual resource.structure
}
}