jfmengels/elm-review
1
1
Fork 0
mirror of https://github.com/jfmengels/elm-review.git synced 2024-12-25 18:51:41 +03:00
Code Issues Packages Projects Releases Wiki Activity
8ab6272a39
elm-review/tests/Docs/ReviewLinksAndSectionsTest.elm
Jeroen Engels 34798e3f49 Backport elm-review-documentation
2021-10-02 10:32:41 +02:00

1134 lines
40 KiB
Elm
Raw Blame History

module Docs.ReviewLinksAndSectionsTest exposing (all)
import Docs.ReviewLinksAndSections exposing (rule)
import Elm.Project
import Json.Decode
import Review.Project as Project exposing (Project)
import Review.Test
import Test exposing (Test, describe, test)
-- TODO Report links to dependencies?
-- TODO Force links to dependencies to be for the minimal version?
-- TODO Report unmatched `[foo]`?
-- TODO Report unused `[foo]: #b` links? (only if there are no "unmatched errors")
all : Test
all =
describe "Docs.ReviewLinksAndSections"
[ localLinkTests
, linksToOtherFilesTest
, linksDependingOnExposition
, linksThroughPackageRegistryTest
, duplicateSectionsTests
, unnecessaryLinksTests
, externalResourcesTests
, linksWithAltTextTests
]
localLinkTests : Test
localLinkTests =
describe "Local links"
[ test "should not report link to an existing sibling section from declaration documentation" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| [link](#b)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should report a link to an unknown sibling section from declaration documentation" <|
\() ->
"""module A exposing (a)
{-| [link](#b)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#b"
}
]
, test "should not report link to an existing sibling section from module documentation" <|
\() ->
"""module A exposing (a, b)
{-| [link](#b)
-}
import B
b = 1
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should report a link to an unknown sibling section from module documentation" <|
\() ->
"""module A exposing (a)
{-| [link](#b)
-}
import B
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#b"
}
]
, test "should not report link to an existing sibling section from port documentation" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| [link](#b)
-}
port a : String -> Cmd msg
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should report a link to an unknown sibling section from port documentation" <|
\() ->
"""module A exposing (a)
{-| [link](#b)
-}
port a : String -> Cmd msg
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#b"
}
]
, test "should not report a link to a known sibling section from declaration documentation when everything is exposed" <|
\() ->
"""module A exposing (..)
b = 1
{-| [link](#b)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should report a link to an unknown sibling section from declaration documentation when everything is exposed" <|
\() ->
"""module A exposing (..)
{-| [link](#b)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#b"
}
]
, test "should not report link references that target existing sections" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| this is a [link] reference
[link]: #b
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should report link references that link to missing sections" <|
\() ->
"""module A exposing (..)
{-| this is a [link] reference
[link]: #b
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#b"
}
]
, test "should consider an exposed type alias to be an existing section" <|
\() ->
"""module A exposing (..)
type alias B = {}
{-| [link](#B)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should consider an exposed custom type to be an existing section" <|
\() ->
"""module A exposing (..)
type B = C
{-| [link](#B)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should consider an exposed port to be an existing section" <|
\() ->
"""module A exposing (..)
port b : Int -> Cmd msg
{-| [link](#b)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should consider an infix declaration to be an existing section (operator exists)" <|
\() ->
"""module A exposing (..)
infix right 5 (++) = append
{-| [link](#++)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should consider an infix declaration to be an existing section (operator doesn't exist)" <|
\() ->
"""module A exposing (..)
{-| [link](#++)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#++"
}
]
, test "should consider a header inside a function documentation comment to be an existing section (h1)" <|
\() ->
"""module A exposing (..)
{-|
# Section
-}
b = 1
{-| [link](#section)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should consider a header inside a function documentation comment to be an existing section (h2)" <|
\() ->
"""module A exposing (..)
{-|
## Section
-}
b = 1
{-| [link](#section)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should not consider a 'h7' header inside a function documentation comment to be an existing section" <|
\() ->
"""module A exposing (..)
{-|
####### Section
-}
b = 1
{-| [link](#section)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#section"
}
]
, test "should consider a header inside a module documentation comment to be an existing section" <|
\() ->
"""module A exposing (..)
{-|
# Section
-}
import B
b = 1
{-| [link](#section)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should slugify complex headings" <|
\() ->
"""module A exposing (..)
{-|
# Section *with* ~some~ _spaces_ and\\_ $thi.ngs . links
### `section`
### question?
-}
b = 1
{-|
[1](#section-_with_-some-_spaces_-and-_-thi-ngs-links)
[2](#-section-)
[3](#question-)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should report links to unknown modules" <|
\() ->
"""module A exposing (..)
{-| [link](B-C)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module B.C"
, details = [ "This is a dead link." ]
, under = "B-C"
}
]
, test "should report multiple links on the same line" <|
\() ->
"""module A exposing (a)
{-| [link](#b) [link](#c) [link](#d) [link](#e)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#b"
}
, Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#c"
}
, Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#d"
}
, Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#e"
}
]
]
linksToOtherFilesTest : Test
linksToOtherFilesTest =
describe "Links to other files"
[ test "should report links to sections in unknown modules" <|
\() ->
"""module A exposing (..)
{-| [link](B#b)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module B"
, details = [ "This is a dead link." ]
, under = "B#b"
}
]
, test "should not report links to existing sections in a different module" <|
\() ->
[ """module A exposing (..)
{-| [link](B#b)
-}
a = 2
""", """module B exposing (b)
b = 1
""" ]
|> Review.Test.runOnModules rule
|> Review.Test.expectNoErrors
, test "should report links to missing sections in a different module" <|
\() ->
[ """module A exposing (..)
{-| [link](B#b)
-}
a = 2
""", """module B exposing (c)
c = 1
""" ]
|> Review.Test.runOnModules rule
|> Review.Test.expectErrorsForModules
[ ( "A"
, [ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "B#b"
}
]
)
]
, test "should not report links to existing sections in a different module (using ./)" <|
\() ->
[ """module A exposing (..)
{-| [link](./B#b)
-}
a = 2
""", """module B exposing (b)
b = 1
""" ]
|> Review.Test.runOnModules rule
|> Review.Test.expectNoErrors
, test "should report links to missing sections in a different module (using ./)" <|
\() ->
[ """module A exposing (..)
{-| [link](./B#b)
-}
a = 2
""", """module B exposing (c)
c = 1
""" ]
|> Review.Test.runOnModules rule
|> Review.Test.expectErrorsForModules
[ ( "A"
, [ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "./B#b"
}
]
)
]
, test "should not report links to existing sections inside the README" <|
\() ->
"""module A exposing (a)
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "# A\n[link](#a)" } Project.new)
rule
|> Review.Test.expectNoErrors
, test "should report links to missing sections inside the README" <|
\() ->
"""module A exposing (a)
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "# A\n[link](#b)" } Project.new)
rule
|> Review.Test.expectErrorsForReadme
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "#b"
}
]
, test "should not report links to existing sections inside the README (using ./)" <|
\() ->
"""module A exposing (a)
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "# A\n[link](./#a)" } Project.new)
rule
|> Review.Test.expectNoErrors
, test "should report links to missing sections inside the README (using ./)" <|
\() ->
"""module A exposing (a)
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "# A\n[link](./#b)" } Project.new)
rule
|> Review.Test.expectErrorsForReadme
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "./#b"
}
]
, test "should not report links to existing sections from another module inside the README" <|
\() ->
"""module A exposing (a)
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "[link](./A#a)" } Project.new)
rule
|> Review.Test.expectNoErrors
, test "should report links to missing sections from another module inside the README" <|
\() ->
"""module A exposing (a)
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "[link](./A#b)" } Project.new)
rule
|> Review.Test.expectErrorsForReadme
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "./A#b"
}
]
, test "should report links to README when there is no README (without slug)" <|
\() ->
"""module A exposing (a)
{-| [link](./)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to missing README"
, details = [ "elm-review only looks for a 'README.md' located next to your 'elm.json'. Maybe it's positioned elsewhere or named differently?" ]
, under = "./"
}
]
, test "should report links to README when there is no README (with slug)" <|
\() ->
"""module A exposing (a)
{-| [link](./#b)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to missing README"
, details = [ "elm-review only looks for a 'README.md' located next to your 'elm.json'. Maybe it's positioned elsewhere or named differently?" ]
, under = "./#b"
}
]
]
linksThroughPackageRegistryTest : Test
linksThroughPackageRegistryTest =
describe "Links through the package registry"
[ test "should report links to unknown modules for the current version" <|
\() ->
[ """module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/author/package/1.0.0/Unknown)
-}
a = 2
""" ]
|> Review.Test.runOnModulesWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module Unknown"
, details = [ "This is a dead link." ]
, under = "https://package.elm-lang.org/packages/author/package/1.0.0/Unknown"
}
]
, test "should not report links to known modules for the current version" <|
\() ->
[ """module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/author/package/1.0.0/A)
-}
a = 2
""" ]
|> Review.Test.runOnModulesWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectNoErrors
, test "should not report links to known modules for the current version (with trailing slash)" <|
\() ->
[ """module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/author/package/1.0.0/A/)
-}
a = 2
""" ]
|> Review.Test.runOnModulesWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectNoErrors
, test "should report links to unknown modules for latest" <|
\() ->
"""module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/author/package/latest/Unknown)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module Unknown"
, details = [ "This is a dead link." ]
, under = "https://package.elm-lang.org/packages/author/package/latest/Unknown"
}
]
, test "should not report links for different version of the package" <|
\() ->
"""module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/author/package/2.3.4/Unknown)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectNoErrors
, test "should report links to unknown section of README" <|
\() ->
"""module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/author/package/1.0.0/#unknown)
-}
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "# A" } packageProjectWithoutFiles)
rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to a non-existing section or element"
, details = [ "This is a dead link." ]
, under = "https://package.elm-lang.org/packages/author/package/1.0.0/#unknown"
}
]
, test "should not report links to known sections of README" <|
\() ->
"""module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/author/package/2.3.4/#a)
-}
a = 2
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "# A" } packageProjectWithoutFiles)
rule
|> Review.Test.expectNoErrors
, test "should not report links for different packages" <|
\() ->
"""module A exposing (..)
{-| [link](https://package.elm-lang.org/packages/other-author/package/latest/Unknown/)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectNoErrors
]
linksDependingOnExposition : Test
linksDependingOnExposition =
describe "Links depending on exposition"
[ test "should not report links from non-exposed modules to non-exposed modules" <|
\() ->
[ """module NotExposed exposing (a)
{-| [link](./AlsoNotExposed)
-}
a = 2
""", """module AlsoNotExposed exposing (b)
b = 1
""" ]
|> Review.Test.runOnModulesWithProjectData packageProject rule
|> Review.Test.expectNoErrors
, test "should not report links from non-exposed modules to exposed modules" <|
\() ->
"""module NotExposed exposing (a)
{-| [link](./Exposed)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProject rule
|> Review.Test.expectNoErrors
, test "should not report links from exposed modules to exposed modules" <|
\() ->
"""module Exposed2 exposing (a)
{-| [link](./Exposed)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProject rule
|> Review.Test.expectNoErrors
, test "should report links from exposed modules to non-exposed modules" <|
\() ->
[ """module Exposed2 exposing (a)
{-| [link](./NotExposed)
-}
a = 2
""", """module NotExposed exposing (b)
b = 1
""" ]
|> Review.Test.runOnModulesWithProjectData packageProject rule
|> Review.Test.expectErrorsForModules
[ ( "Exposed2"
, [ Review.Test.error
{ message = "Link in public documentation points to non-exposed module"
, details = [ "Users will not be able to follow the link." ]
, under = "./NotExposed"
}
]
)
]
, test "should not report links from non-exposed sections to non-exposed sections" <|
\() ->
[ """module Exposed2 exposing (b)
b = a
{-| [link](./Exposed3#hidden)
-}
a = 1
""", """module Exposed3 exposing (exposed)
exposed = 2
{-|
# Hidden
-}
a = 3
""" ]
|> Review.Test.runOnModulesWithProjectData packageProject rule
|> Review.Test.expectNoErrors
, test "should not report links from non-exposed sections to exposed sections" <|
\() ->
[ """module Exposed2 exposing (b)
b = a
{-| [link](./Exposed3#exposed)
-}
a = 1
""", """module Exposed3 exposing (exposed)
exposed = 2
{-|
# Hidden
-}
a = 3
""" ]
|> Review.Test.runOnModulesWithProjectData packageProject rule
|> Review.Test.expectNoErrors
, test "should report links from exposed sections to non-exposed sections" <|
\() ->
[ """module Exposed2 exposing (b)
{-| [link](./Exposed3#hidden)
-}
b = 1
""", """module Exposed3 exposing (exposed)
exposed = 2
{-|
# Hidden
-}
a = 3
""" ]
|> Review.Test.runOnModulesWithProjectData packageProject rule
|> Review.Test.expectErrorsForModules
[ ( "Exposed2"
, [ Review.Test.error
{ message = "Link in public documentation points to non-exposed section"
, details = [ "Users will not be able to follow the link." ]
, under = "./Exposed3#hidden"
}
]
)
]
, test "should report links from README to non-exposed modules" <|
\() ->
"""module NotExposed exposing (a)
a = 1
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "[link](./NotExposed)" } packageProject)
rule
|> Review.Test.expectErrorsForReadme
[ Review.Test.error
{ message = "Link in public documentation points to non-exposed module"
, details = [ "Users will not be able to follow the link." ]
, under = "./NotExposed"
}
]
, test "should not report links from README to exposed modules" <|
\() ->
"""module NotExposed exposing (a)
a = 1
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "[link](./Exposed)" } packageProject)
rule
|> Review.Test.expectNoErrors
, test "should report links from README to non-exposed sections" <|
\() ->
"""module Exposed2 exposing (a)
a = 1
{-|
# Section
-}
b = 1
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "[link](./Exposed2#section)" } packageProject)
rule
|> Review.Test.expectErrorsForReadme
[ Review.Test.error
{ message = "Link in public documentation points to non-exposed section"
, details = [ "Users will not be able to follow the link." ]
, under = "./Exposed2#section"
}
]
, test "should not report links from README to non-exposed sections in non-package projects" <|
\() ->
"""module Exposed2 exposing (a)
a = 1
{-|
# Section
-}
b = 1
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = "[link](./Exposed2#section)" } Project.new)
rule
|> Review.Test.expectNoErrors
]
duplicateSectionsTests : Test
duplicateSectionsTests =
describe "Duplicate sections"
[ test "should report duplicate sections (declaration doc comment)" <|
\() ->
"""module Exposed2 exposing (error, exposed)
{-|
# Error
-}
exposed = 1
error = 1
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Duplicate section"
, details = [ "There are multiple sections that will result in the same id, meaning that links may point towards the wrong element." ]
, under = "# Error"
}
]
, test "should report duplicate sections (module doc comment)" <|
\() ->
"""module Exposed2 exposing (error)
{-|
# Error
-}
error = 1
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Duplicate section"
, details = [ "There are multiple sections that will result in the same id, meaning that links may point towards the wrong element." ]
, under = "# Error"
}
]
, test "should report duplicate sections (all in declaration doc comments)" <|
\() ->
"""module Exposed2 exposing (error)
{-|
# Some section
# Some Section
-}
error = 1
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Duplicate section"
, details = [ "There are multiple sections that will result in the same id, meaning that links may point towards the wrong element." ]
, under = "# Some Section"
}
]
, test "should report duplicate sections in README" <|
\() ->
"""module Exposed2 exposing (a)
a = 1
"""
|> Review.Test.runWithProjectData
(Project.addReadme { path = "README.md", content = """
# Some section
# Some Section
""" } packageProject)
rule
|> Review.Test.expectErrorsForReadme
[ Review.Test.error
{ message = "Duplicate section"
, details = [ "There are multiple sections that will result in the same id, meaning that links may point towards the wrong element." ]
, under = "# Some Section"
}
]
]
unnecessaryLinksTests : Test
unnecessaryLinksTests =
describe "Unnecessary links"
[ test "should report links to #" <|
\() ->
"""module A exposing (..)
{-|
[link](#)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link to empty section is unnecessary"
, details = [ "Links to # not followed by an id don't provide any value to the user. I suggest to either strip the # or remove the link." ]
, under = "#"
}
]
, test "should report links to a module with #" <|
\() ->
"""module A exposing (..)
{-|
[link](A#)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link to empty section is unnecessary"
, details = [ "Links to # not followed by an id don't provide any value to the user. I suggest to either strip the # or remove the link." ]
, under = "A#"
}
]
]
externalResourcesTests : Test
externalResourcesTests =
describe "External resources"
[ test "should not report links to external resources without a protocol when the project is not a package" <|
\() ->
"""module A exposing (..)
{-|
[link](www.google.com)
![](./image.png)
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should not report links to external resources with a protocol" <|
\() ->
"""module A exposing (..)
{-|
[link](https://foo.com)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectNoErrors
, test "should report links to an external resource without a protocol" <|
\() ->
"""module A exposing (..)
{-|
[link](foo.com)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link to unknown resource without a protocol"
, details =
[ "I have trouble figuring out what kind of resource is linked here."
, "If it should link to a module, then they should be in the form 'Some-Module-Name'."
, "If it's a link to an external resource, they should start with a protocol, like `https://www.fruits.com`, otherwise the link will point to an unknown resource on package.elm-lang.org."
]
, under = "foo.com"
}
]
, test "should not report links to images with a protocol" <|
\() ->
"""module A exposing (..)
{-|
[link](https://www.image.com/image.png)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectNoErrors
, test "should report links to images without a protocol" <|
\() ->
"""module A exposing (..)
{-|
[link](./image.png)
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link to unknown resource without a protocol"
, details =
[ "I have trouble figuring out what kind of resource is linked here."
, "If it should link to a module, then they should be in the form 'Some-Module-Name'."
, "If it's a link to an external resource, they should start with a protocol, like `https://www.fruits.com`, otherwise the link will point to an unknown resource on package.elm-lang.org."
]
, under = "./image.png"
}
]
]
linksWithAltTextTests : Test
linksWithAltTextTests =
describe "Alt text in links"
[ test "should report links to unknown modules in links with alt text after a slug" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| [link](Unknown#section "alt-text")
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module Unknown"
, details = [ "This is a dead link." ]
, under = "Unknown#section"
}
]
, test "should ignore alt text in links with a slug" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| [link](#b "alt-text")
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectNoErrors
, test "should report links to unknown modules in links with alt text without a slug" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| [link](Unknown "alt-text")
-}
a = 2
"""
|> Review.Test.run rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module Unknown"
, details = [ "This is a dead link." ]
, under = "Unknown"
}
]
, test "should report absolute links to unknown modules in links with alt text with a slug" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| [link](https://package.elm-lang.org/packages/author/package/1.0.0/Unknown "alt-text")
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module Unknown"
, details = [ "This is a dead link." ]
, under = "https://package.elm-lang.org/packages/author/package/1.0.0/Unknown"
}
]
, test "should report absolute links to unknown modules in links with alt text without a slug" <|
\() ->
"""module A exposing (a, b)
b = 1
{-| [link](https://package.elm-lang.org/packages/author/package/1.0.0/Unknown#section "alt-text")
-}
a = 2
"""
|> Review.Test.runWithProjectData packageProjectWithoutFiles rule
|> Review.Test.expectErrors
[ Review.Test.error
{ message = "Link points to non-existing module Unknown"
, details = [ "This is a dead link." ]
, under = "https://package.elm-lang.org/packages/author/package/1.0.0/Unknown#section"
}
]
]
packageProject : Project
packageProject =
Project.addModule
{ path = "src/Exposed", source = "module Exposed exposing (exposed)\nexposed = 1" }
packageProjectWithoutFiles
packageProjectWithoutFiles : Project
packageProjectWithoutFiles =
case Json.Decode.decodeString Elm.Project.decoder elmJson of
Ok project ->
Project.new
|> Project.addElmJson
{ path = "elm.json"
, raw = elmJson
, project = project
}
Err err ->
Debug.todo ("Invalid elm.json supplied to test: " ++ Debug.toString err)
elmJson : String
elmJson =
"""{
"type": "package",
"name": "author/package",
"summary": "Summary",
"license": "BSD-3-Clause",
"version": "1.0.0",
"exposed-modules": [
"Exposed",
"Exposed2",
"Exposed3"
],
"elm-version": "0.19.0 <= v < 0.20.0",
"dependencies": {
"elm/core": "1.0.0 <= v < 2.0.0"
},
"test-dependencies": {}
}"""
Reference in New Issue View Git Blame Copy Permalink