aboutsummaryrefslogtreecommitdiff
path: root/plugins/all-modules-page/src/test/kotlin/templates/ResolveLinkGfmCommandResolutionTest.kt
blob: b17d67655fea7c1d8d9cfb85322cc5514f0bea99 (plain)
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
/*
 * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
 */

package org.jetbrains.dokka.allModulesPage.templates

import org.jetbrains.dokka.DokkaModuleDescriptionImpl
import org.jetbrains.dokka.allModulesPage.MultiModuleAbstractTest
import org.jetbrains.dokka.base.resolvers.shared.RecognizedLinkFormat
import org.jetbrains.dokka.gfm.GfmCommand.Companion.templateCommand
import org.jetbrains.dokka.gfm.GfmPlugin
import org.jetbrains.dokka.gfm.ResolveLinkGfmCommand
import org.jetbrains.dokka.gfm.templateProcessing.GfmTemplateProcessingPlugin
import org.jetbrains.dokka.links.DRI
import org.junit.jupiter.api.io.TempDir
import java.io.File
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue

class ResolveLinkGfmCommandResolutionTest : MultiModuleAbstractTest() {

    @Test
    fun `should resolve link to another module`(@TempDir outputDirectory: File) {
        val configuration = dokkaConfiguration {
            modules = listOf(
                DokkaModuleDescriptionImpl(
                    name = "module1",
                    relativePathToOutputDirectory = outputDirectory.resolve("module1"),
                    includes = emptySet(),
                    sourceOutputDirectory = outputDirectory.resolve("module1"),
                ),
                DokkaModuleDescriptionImpl(
                    name = "module2",
                    relativePathToOutputDirectory = outputDirectory.resolve("module2"),
                    includes = emptySet(),
                    sourceOutputDirectory = outputDirectory.resolve("module2"),
                )
            )
            outputDir = outputDirectory
        }

        val innerModule1 = outputDirectory.resolve("module1").also { assertTrue(it.mkdirs()) }
        val innerModule2 = outputDirectory.resolve("module2").also { assertTrue(it.mkdirs()) }

        val indexMd = innerModule1.resolve("index.md")
        val packageList = innerModule2.resolve("package-list")

        val indexMdContent = StringBuilder().apply {
            templateCommand(
                ResolveLinkGfmCommand(
                    dri = DRI(
                        packageName = "package2",
                        classNames = "Sample",
                    )
                )
            ) {
                append("Sample text inside")
            }
        }.toString()

        indexMd.writeText(indexMdContent)
        packageList.writeText(mockedPackageListForPackages(RecognizedLinkFormat.DokkaGFM, "package2"))

        testFromData(
            configuration,
            pluginOverrides = listOf(GfmTemplateProcessingPlugin(), GfmPlugin()),
            useOutputLocationFromConfig = true
        ) {
            finishProcessingSubmodules = {
                val expectedIndexMd = "[Sample text inside](../module2/package2/-sample/index.md)"
                assertEquals(expectedIndexMd, indexMd.readText().trim())
            }
        }
    }
}