@@ -4,28 +4,23 @@ import com.beust.klaxon.JsonObject
4
4
import com.beust.klaxon.Parser
5
5
import org.gradle.internal.impldep.org.apache.commons.lang.RandomStringUtils
6
6
import org.gradle.testkit.runner.BuildResult
7
- import org.gradle.testkit.runner.BuildTask
8
7
import org.gradle.testkit.runner.GradleRunner
9
8
import org.gradle.testkit.runner.TaskOutcome
10
- import org.junit.Assert.assertEquals
11
- import org.junit.Assert.assertFalse
12
- import org.junit.Before
13
- import org.junit.Rule
14
- import org.junit.Test
15
- import org.junit.rules.TemporaryFolder
9
+ import org.junit.jupiter.api.Assertions.assertEquals
10
+ import org.junit.jupiter.api.Assertions.assertFalse
11
+ import org.junit.jupiter.api.BeforeEach
12
+ import org.junit.jupiter.api.Test
16
13
import java.io.File
17
14
import java.io.FileReader
15
+ import java.nio.file.Files
18
16
19
17
class OpenApiGradlePluginTest {
20
- @Rule
21
- @JvmField
22
- var testProjectDir: TemporaryFolder = TemporaryFolder ()
23
18
24
- private lateinit var projectTestDir: File
25
- private lateinit var buildFile: File
26
- private lateinit var projectBuildDir: File
19
+ private val projectTestDir = Files .createTempDirectory( " acceptance-project " ).toFile()
20
+ private val buildFile = File (projectTestDir, " build.gradle " )
21
+ private val projectBuildDir = File (projectTestDir, " build " )
27
22
28
- private var baseBuildGradle = """ plugins {
23
+ private val baseBuildGradle = """ plugins {
29
24
id 'org.springframework.boot' version '2.2.0.RELEASE'
30
25
id 'io.spring.dependency-management' version '1.0.9.RELEASE'
31
26
id 'java'
@@ -47,187 +42,128 @@ class OpenApiGradlePluginTest {
47
42
}
48
43
""" .trimIndent()
49
44
50
- @Before
51
- fun setup () {
52
- val acceptanceTestProject = File (this .javaClass.classLoader.getResource(" acceptance-project" )!! .path)
53
- projectTestDir = File (testProjectDir.newFolder(), " acceptence-project" )
54
-
55
- acceptanceTestProject.copyRecursively(projectTestDir)
56
- buildFile = File (projectTestDir, " build.gradle" )
57
-
58
- projectBuildDir = File (projectTestDir, " build" )
59
- println (" !!!!! $projectBuildDir !!!!!!!" )
45
+ @BeforeEach
46
+ fun createTemporaryAcceptanceProjectFromTemplate () {
47
+ File (javaClass.classLoader.getResource(" acceptance-project" )!! .path).copyRecursively(projectTestDir)
60
48
}
61
49
62
50
@Test
63
51
fun `default build no options` () {
64
52
buildFile.writeText(baseBuildGradle)
65
53
66
- val result = GradleRunner .create()
67
- .withProjectDir(projectTestDir)
68
- .withArguments(" clean" , " generateOpenApiDocs" )
69
- .withPluginClasspath()
70
- .build()
71
-
72
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
73
-
74
- val openApiJsonFile = File (projectBuildDir, DEFAULT_OPEN_API_FILE_NAME )
75
- assertOpenApiJsonFileIsAsExpected(openApiJsonFile, 1 )
54
+ assertEquals(TaskOutcome .SUCCESS , openApiDocsTask(runTheBuild()).outcome)
55
+ assertOpenApiJsonFile(1 )
76
56
}
77
57
78
58
@Test
79
59
fun `different output dir` () {
80
- var specialOutputDir = File (projectTestDir, " specialDir" )
60
+ val specialOutputDir = File (projectTestDir, " specialDir" )
81
61
specialOutputDir.mkdirs()
82
62
83
- buildFile.writeText(""" $baseBuildGradle
63
+ buildFile.writeText(
64
+ """ $baseBuildGradle
84
65
openApi{
85
66
outputDir = file("${specialOutputDir.toURI().path} ")
86
67
}
87
- """ .trimMargin())
68
+ """ .trimMargin()
69
+ )
88
70
89
- val result = GradleRunner .create()
90
- .withProjectDir(projectTestDir)
91
- .withArguments(" clean" , " generateOpenApiDocs" )
92
- .withPluginClasspath()
93
- .build()
94
-
95
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
96
-
97
- val openApiJsonFile = File (specialOutputDir, DEFAULT_OPEN_API_FILE_NAME )
98
- assertOpenApiJsonFileIsAsExpected(openApiJsonFile, 1 )
71
+ assertEquals(TaskOutcome .SUCCESS , openApiDocsTask(runTheBuild()).outcome)
72
+ assertOpenApiJsonFile(1 , buildDir = specialOutputDir)
99
73
}
100
74
101
75
@Test
102
76
fun `different output file name` () {
103
- var specialOutputJsonFileName = RandomStringUtils .randomAlphanumeric(15 )
77
+ val specialOutputJsonFileName = RandomStringUtils .randomAlphanumeric(15 )
104
78
105
- buildFile.writeText(""" $baseBuildGradle
79
+ buildFile.writeText(
80
+ """ $baseBuildGradle
106
81
openApi{
107
82
outputFileName = "$specialOutputJsonFileName "
108
83
}
109
- """ .trimMargin())
110
-
111
- val result = GradleRunner .create()
112
- .withProjectDir(projectTestDir)
113
- .withArguments(" clean" , " generateOpenApiDocs" )
114
- .withPluginClasspath()
115
- .build()
84
+ """ .trimMargin()
85
+ )
116
86
117
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
118
-
119
- val openApiJsonFile = File (projectBuildDir, specialOutputJsonFileName)
120
- assertOpenApiJsonFileIsAsExpected(openApiJsonFile, 1 )
87
+ assertEquals(TaskOutcome .SUCCESS , openApiDocsTask(runTheBuild()).outcome)
88
+ assertOpenApiJsonFile(1 , specialOutputJsonFileName)
121
89
}
122
90
123
91
@Test
124
92
fun `using forked properties` () {
125
- buildFile.writeText(""" $baseBuildGradle
93
+ buildFile.writeText(
94
+ """ $baseBuildGradle
126
95
openApi{
127
96
forkProperties = "-Dspring.profiles.active=multiple-endpoints -Dsome.second.property=someValue"
128
97
}
129
- """ .trimMargin())
130
-
131
- val result = GradleRunner .create()
132
- .withProjectDir(projectTestDir)
133
- .withArguments(" clean" , " generateOpenApiDocs" )
134
- .withPluginClasspath()
135
- .build()
136
-
137
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
98
+ """ .trimMargin()
99
+ )
138
100
139
- val openApiJsonFile = File (projectBuildDir, DEFAULT_OPEN_API_FILE_NAME )
140
- assertOpenApiJsonFileIsAsExpected(openApiJsonFile, 3 )
101
+ assertEquals( TaskOutcome . SUCCESS , openApiDocsTask(runTheBuild()).outcome )
102
+ assertOpenApiJsonFile( 3 )
141
103
}
142
104
143
105
@Test
144
106
fun `using forked properties via System properties` () {
145
- buildFile.writeText(""" $baseBuildGradle
107
+ buildFile.writeText(
108
+ """ $baseBuildGradle
146
109
openApi{
147
110
forkProperties = System.properties
148
111
}
149
- """ .trimMargin())
112
+ """ .trimMargin()
113
+ )
150
114
151
- val result = GradleRunner .create()
152
- .withProjectDir(projectTestDir)
153
- .withArguments(" clean" , " generateOpenApiDocs" , " -Dspring.profiles.active=multiple-endpoints" )
154
- .withPluginClasspath()
155
- .build()
156
-
157
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
158
-
159
- val openApiJsonFile = File (projectBuildDir, DEFAULT_OPEN_API_FILE_NAME )
160
- assertOpenApiJsonFileIsAsExpected(openApiJsonFile, 2 )
115
+ assertEquals(TaskOutcome .SUCCESS , openApiDocsTask(runTheBuild(" -Dspring.profiles.active=multiple-endpoints" )).outcome)
116
+ assertOpenApiJsonFile(2 )
161
117
}
162
118
163
119
@Test
164
120
fun `configurable wait time` () {
165
- buildFile.writeText(""" $baseBuildGradle
121
+ buildFile.writeText(
122
+ """ $baseBuildGradle
166
123
openApi{
167
124
forkProperties = "-Dspring.profiles.active=slower"
168
125
waitTimeInSeconds = 60
169
126
}
170
- """ .trimMargin())
171
-
172
- val result = GradleRunner .create()
173
- .withProjectDir(projectTestDir)
174
- .withArguments(" clean" , " generateOpenApiDocs" )
175
- .withPluginClasspath()
176
- .build()
127
+ """ .trimMargin()
128
+ )
177
129
178
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
179
-
180
- val openApiJsonFile = File (projectBuildDir, DEFAULT_OPEN_API_FILE_NAME )
181
- assertOpenApiJsonFileIsAsExpected(openApiJsonFile, 1 )
130
+ assertEquals(TaskOutcome .SUCCESS , openApiDocsTask(runTheBuild()).outcome)
131
+ assertOpenApiJsonFile(1 )
182
132
}
183
133
184
134
@Test
185
135
fun `using different api url` () {
186
- buildFile.writeText(""" $baseBuildGradle
136
+ buildFile.writeText(
137
+ """ $baseBuildGradle
187
138
openApi{
188
139
apiDocsUrl = "http://localhost:8080/secret-api-docs"
189
140
forkProperties = "-Dspring.profiles.active=different-url"
190
141
}
191
- """ .trimMargin())
192
-
193
- val result = GradleRunner .create()
194
- .withProjectDir(projectTestDir)
195
- .withArguments(" clean" , " generateOpenApiDocs" )
196
- .withPluginClasspath()
197
- .build()
198
-
199
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
142
+ """ .trimMargin()
143
+ )
200
144
201
- val openApiJsonFile = File (projectBuildDir, DEFAULT_OPEN_API_FILE_NAME )
202
- assertOpenApiJsonFileIsAsExpected(openApiJsonFile, 1 )
145
+ assertEquals( TaskOutcome . SUCCESS , openApiDocsTask(runTheBuild()).outcome )
146
+ assertOpenApiJsonFile( 1 )
203
147
}
204
148
205
149
@Test
206
150
fun `using multiple grouped apis` () {
207
151
val outputJsonFileNameGroupA = " openapi-groupA.json"
208
152
val outputJsonFileNameGroupB = " openapi-groupB.json"
209
153
210
- buildFile.writeText(""" $baseBuildGradle
154
+ buildFile.writeText(
155
+ """ $baseBuildGradle
211
156
openApi{
212
157
groupedApiMappings = ["http://localhost:8080/v3/api-docs/groupA": "$outputJsonFileNameGroupA ",
213
158
"http://localhost:8080/v3/api-docs/groupB": "$outputJsonFileNameGroupB "]
214
159
forkProperties = "-Dspring.profiles.active=multiple-grouped-apis"
215
160
}
216
- """ .trimMargin())
217
-
218
- val result = GradleRunner .create()
219
- .withProjectDir(projectTestDir)
220
- .withArguments(" clean" , " generateOpenApiDocs" )
221
- .withPluginClasspath()
222
- .build()
223
-
224
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
225
-
226
- val openApiJsonFileGroupA = File (projectBuildDir, outputJsonFileNameGroupA)
227
- assertOpenApiJsonFileIsAsExpected(openApiJsonFileGroupA, 1 )
161
+ """ .trimMargin()
162
+ )
228
163
229
- val openApiJsonFileGroupB = File (projectBuildDir, outputJsonFileNameGroupB)
230
- assertOpenApiJsonFileIsAsExpected(openApiJsonFileGroupB, 2 )
164
+ assertEquals(TaskOutcome .SUCCESS , openApiDocsTask(runTheBuild()).outcome)
165
+ assertOpenApiJsonFile(1 , outputJsonFileNameGroupA)
166
+ assertOpenApiJsonFile(2 , outputJsonFileNameGroupB)
231
167
}
232
168
233
169
@Test
@@ -236,45 +172,41 @@ class OpenApiGradlePluginTest {
236
172
val outputJsonFileNameGroupA = " openapi-groupA.json"
237
173
val outputJsonFileNameGroupB = " openapi-groupB.json"
238
174
239
- buildFile.writeText(""" $baseBuildGradle
175
+ buildFile.writeText(
176
+ """ $baseBuildGradle
240
177
openApi{
241
178
apiDocsUrl = "http://localhost:8080/v3/api-docs/groupA"
242
179
outputFileName = "$outputJsonFileNameSingleGroupA "
243
180
groupedApiMappings = ["http://localhost:8080/v3/api-docs/groupA": "$outputJsonFileNameGroupA ",
244
181
"http://localhost:8080/v3/api-docs/groupB": "$outputJsonFileNameGroupB "]
245
182
forkProperties = "-Dspring.profiles.active=multiple-grouped-apis"
246
183
}
247
- """ .trimMargin())
184
+ """ .trimMargin()
185
+ )
248
186
249
- val result = GradleRunner .create()
250
- .withProjectDir(projectTestDir)
251
- .withArguments(" clean" , " generateOpenApiDocs" )
252
- .withPluginClasspath()
253
- .build()
254
-
255
- assertEquals(TaskOutcome .SUCCESS , getTaskByName(result, " generateOpenApiDocs" )?.outcome)
256
-
257
- val openApiJsonFileSingleGroupA = File (projectBuildDir, outputJsonFileNameSingleGroupA)
258
- assertFalse(openApiJsonFileSingleGroupA.exists())
259
-
260
- val openApiJsonFileGroupA = File (projectBuildDir, outputJsonFileNameGroupA)
261
- assertOpenApiJsonFileIsAsExpected(openApiJsonFileGroupA, 1 )
262
-
263
- val openApiJsonFileGroupB = File (projectBuildDir, outputJsonFileNameGroupB)
264
- assertOpenApiJsonFileIsAsExpected(openApiJsonFileGroupB, 2 )
187
+ assertEquals(TaskOutcome .SUCCESS , openApiDocsTask(runTheBuild()).outcome)
188
+ assertFalse(File (projectBuildDir, outputJsonFileNameSingleGroupA).exists())
189
+ assertOpenApiJsonFile(1 , outputJsonFileNameGroupA)
190
+ assertOpenApiJsonFile(2 , outputJsonFileNameGroupB)
265
191
}
266
192
267
- private fun assertOpenApiJsonFileIsAsExpected (openApiJsonFile : File , expectedNumberOfPaths : Int ) {
268
- val openApiJson = getOpenApiJsonAtLocation(openApiJsonFile)
269
- assertEquals(" 3.0.1" , openApiJson!! .string(" openapi" ))
270
- assertEquals(expectedNumberOfPaths, openApiJson.obj(" paths" )!! .size)
193
+ private fun runTheBuild (vararg additionalArguments : String = emptyArray()) = GradleRunner .create()
194
+ .withProjectDir(projectTestDir)
195
+ .withArguments(" clean" , " generateOpenApiDocs" , * additionalArguments)
196
+ .withPluginClasspath()
197
+ .build()
198
+
199
+ private fun assertOpenApiJsonFile (
200
+ expectedPathCount : Int ,
201
+ outputJsonFileName : String = DEFAULT_OPEN_API_FILE_NAME ,
202
+ buildDir : File = projectBuildDir
203
+ ) {
204
+ val openApiJson = getOpenApiJsonAtLocation(File (buildDir, outputJsonFileName))
205
+ assertEquals(" 3.0.1" , openApiJson.string(" openapi" ))
206
+ assertEquals(expectedPathCount, openApiJson.obj(" paths" )!! .size)
271
207
}
272
208
273
- private fun getOpenApiJsonAtLocation (path : File ): JsonObject ? {
274
- return Parser .default().parse(FileReader (path)) as JsonObject
275
- }
209
+ private fun getOpenApiJsonAtLocation (path : File ) = Parser .default().parse(FileReader (path)) as JsonObject
276
210
277
- private fun getTaskByName (result : BuildResult , name : String ): BuildTask ? {
278
- return result.tasks.find { it.path.contains(name) }
279
- }
280
- }
211
+ private fun openApiDocsTask (result : BuildResult ) = result.tasks.find { it.path.contains(" generateOpenApiDocs" ) }!!
212
+ }
0 commit comments