2021-03-18 01:25:06 +00:00
|
|
|
package hmnurl
|
|
|
|
|
|
|
|
import (
|
2021-05-05 20:34:32 +00:00
|
|
|
"net/url"
|
|
|
|
"regexp"
|
2021-03-18 01:25:06 +00:00
|
|
|
"testing"
|
|
|
|
|
|
|
|
"git.handmade.network/hmn/hmn/src/config"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
)
|
|
|
|
|
|
|
|
func TestUrl(t *testing.T) {
|
2021-05-05 20:34:32 +00:00
|
|
|
defer func() {
|
|
|
|
SetGlobalBaseUrl(config.Config.BaseUrl)
|
|
|
|
}()
|
|
|
|
SetGlobalBaseUrl("http://handmade.test")
|
2021-05-25 13:48:57 +00:00
|
|
|
isTest = true
|
2021-03-18 01:25:06 +00:00
|
|
|
|
|
|
|
t.Run("no query", func(t *testing.T) {
|
|
|
|
result := Url("/test/foo", nil)
|
|
|
|
assert.Equal(t, "http://handmade.test/test/foo", result)
|
|
|
|
})
|
|
|
|
t.Run("yes query", func(t *testing.T) {
|
|
|
|
result := Url("/test/foo", []Q{{"bar", "baz"}, {"zig??", "zig & zag!!"}})
|
|
|
|
assert.Equal(t, "http://handmade.test/test/foo?bar=baz&zig%3F%3F=zig+%26+zag%21%21", result)
|
|
|
|
})
|
|
|
|
}
|
2021-05-05 20:34:32 +00:00
|
|
|
|
|
|
|
func TestHomepage(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildHomepage(), RegexHomepage, nil)
|
2021-05-11 22:53:23 +00:00
|
|
|
AssertRegexMatch(t, BuildProjectHomepage("hero"), RegexHomepage, nil)
|
|
|
|
AssertSubdomain(t, BuildProjectHomepage("hero"), "hero")
|
2021-05-05 20:34:32 +00:00
|
|
|
}
|
|
|
|
|
2021-05-16 19:22:45 +00:00
|
|
|
func TestShowcase(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildShowcase(), RegexShowcase, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestStreams(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildStreams(), RegexStreams, nil)
|
|
|
|
}
|
|
|
|
|
2021-08-17 19:48:44 +00:00
|
|
|
func TestWhenIsIt(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildWhenIsIt(), RegexWhenIsIt, nil)
|
|
|
|
}
|
|
|
|
|
2021-05-11 22:53:23 +00:00
|
|
|
func TestAtomFeed(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildAtomFeed(), RegexAtomFeed, nil)
|
2021-05-30 18:35:01 +00:00
|
|
|
AssertRegexMatch(t, BuildAtomFeedForProjects(), RegexAtomFeed, map[string]string{"feedtype": "projects"})
|
|
|
|
AssertRegexMatch(t, BuildAtomFeedForShowcase(), RegexAtomFeed, map[string]string{"feedtype": "showcase"})
|
2021-05-31 23:23:04 +00:00
|
|
|
|
|
|
|
// NOTE(asaf): The following tests are for backwards compatibity
|
|
|
|
AssertRegexMatch(t, "/atom/projects/new", RegexAtomFeed, map[string]string{"feedtype": "projects"})
|
|
|
|
AssertRegexMatch(t, "/atom/showcase/new", RegexAtomFeed, map[string]string{"feedtype": "showcase"})
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestLoginAction(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildLoginAction(""), RegexLoginAction, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestLoginPage(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildLoginPage(""), RegexLoginPage, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestLogoutAction(t *testing.T) {
|
2021-06-12 00:48:03 +00:00
|
|
|
AssertRegexMatch(t, BuildLogoutAction(""), RegexLogoutAction, nil)
|
2021-05-05 20:34:32 +00:00
|
|
|
}
|
|
|
|
|
2021-06-06 23:48:43 +00:00
|
|
|
func TestRegister(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildRegister(), RegexRegister, nil)
|
|
|
|
}
|
|
|
|
|
2021-08-08 20:05:52 +00:00
|
|
|
func TestRegistrationSuccess(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildRegistrationSuccess(), RegexRegistrationSuccess, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEmailConfirmation(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildEmailConfirmation("mruser", "test_token"), RegexEmailConfirmation, map[string]string{"username": "mruser", "token": "test_token"})
|
|
|
|
}
|
|
|
|
|
2021-08-17 05:18:04 +00:00
|
|
|
func TestPasswordReset(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildRequestPasswordReset(), RegexRequestPasswordReset, nil)
|
|
|
|
AssertRegexMatch(t, BuildPasswordResetSent(), RegexPasswordResetSent, nil)
|
|
|
|
AssertRegexMatch(t, BuildDoPasswordReset("user", "token"), RegexDoPasswordReset, map[string]string{"username": "user", "token": "token"})
|
|
|
|
}
|
|
|
|
|
2021-05-05 20:34:32 +00:00
|
|
|
func TestStaticPages(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildManifesto(), RegexManifesto, nil)
|
|
|
|
AssertRegexMatch(t, BuildAbout(), RegexAbout, nil)
|
|
|
|
AssertRegexMatch(t, BuildCodeOfConduct(), RegexCodeOfConduct, nil)
|
|
|
|
AssertRegexMatch(t, BuildCommunicationGuidelines(), RegexCommunicationGuidelines, nil)
|
|
|
|
AssertRegexMatch(t, BuildContactPage(), RegexContactPage, nil)
|
|
|
|
AssertRegexMatch(t, BuildMonthlyUpdatePolicy(), RegexMonthlyUpdatePolicy, nil)
|
|
|
|
AssertRegexMatch(t, BuildProjectSubmissionGuidelines(), RegexProjectSubmissionGuidelines, nil)
|
|
|
|
}
|
|
|
|
|
2021-06-22 09:50:40 +00:00
|
|
|
func TestUserProfile(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildUserProfile("test"), RegexUserProfile, map[string]string{"username": "test"})
|
|
|
|
}
|
|
|
|
|
2021-08-17 05:18:04 +00:00
|
|
|
func TestUserSettings(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildUserSettings("test"), RegexUserSettings, nil)
|
|
|
|
}
|
|
|
|
|
2021-09-24 00:12:46 +00:00
|
|
|
func TestAdmin(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildAdminAtomFeed(), RegexAdminAtomFeed, nil)
|
|
|
|
AssertRegexMatch(t, BuildAdminApprovalQueue(), RegexAdminApprovalQueue, nil)
|
2021-12-15 01:17:42 +00:00
|
|
|
AssertRegexMatch(t, BuildAdminSetUserStatus(), RegexAdminSetUserStatus, nil)
|
|
|
|
AssertRegexMatch(t, BuildAdminNukeUser(), RegexAdminNukeUser, nil)
|
2021-09-24 00:12:46 +00:00
|
|
|
}
|
|
|
|
|
2021-06-22 09:50:40 +00:00
|
|
|
func TestSnippet(t *testing.T) {
|
2021-07-23 03:09:46 +00:00
|
|
|
AssertRegexMatch(t, BuildSnippet(15), RegexSnippet, map[string]string{"snippetid": "15"})
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
2021-05-05 20:34:32 +00:00
|
|
|
func TestFeed(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildFeed(), RegexFeed, nil)
|
|
|
|
assert.Equal(t, BuildFeed(), BuildFeedWithPage(1))
|
|
|
|
AssertRegexMatch(t, BuildFeedWithPage(1), RegexFeed, nil)
|
|
|
|
AssertRegexMatch(t, "/feed/1", RegexFeed, nil) // NOTE(asaf): We should never build this URL, but we should still accept it.
|
|
|
|
AssertRegexMatch(t, BuildFeedWithPage(5), RegexFeed, map[string]string{"page": "5"})
|
|
|
|
assert.Panics(t, func() { BuildFeedWithPage(-1) })
|
|
|
|
assert.Panics(t, func() { BuildFeedWithPage(0) })
|
|
|
|
}
|
|
|
|
|
2021-06-06 23:48:43 +00:00
|
|
|
func TestProjectIndex(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildProjectIndex(1), RegexProjectIndex, nil)
|
|
|
|
AssertRegexMatch(t, BuildProjectIndex(2), RegexProjectIndex, map[string]string{"page": "2"})
|
|
|
|
assert.Panics(t, func() { BuildProjectIndex(0) })
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestProjectNew(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildProjectNew(), RegexProjectNew, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestProjectNotApproved(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildProjectNotApproved("test"), RegexProjectNotApproved, map[string]string{"slug": "test"})
|
2021-07-08 07:40:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestProjectEdit(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildProjectEdit("test", "foo"), RegexProjectEdit, map[string]string{"slug": "test"})
|
2021-06-06 23:48:43 +00:00
|
|
|
}
|
|
|
|
|
2021-05-16 19:22:45 +00:00
|
|
|
func TestPodcast(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildPodcast(), RegexPodcast, nil)
|
2021-05-16 19:22:45 +00:00
|
|
|
}
|
|
|
|
|
2021-07-23 03:09:46 +00:00
|
|
|
func TestPodcastEdit(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildPodcastEdit(), RegexPodcastEdit, nil)
|
2021-07-23 03:09:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestPodcastEpisode(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildPodcastEpisode("test"), RegexPodcastEpisode, map[string]string{"episodeid": "test"})
|
2021-07-23 03:09:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestPodcastEpisodeNew(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildPodcastEpisodeNew(), RegexPodcastEpisodeNew, nil)
|
2021-07-23 03:09:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestPodcastEpisodeEdit(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildPodcastEpisodeEdit("test"), RegexPodcastEpisodeEdit, map[string]string{"episodeid": "test"})
|
2021-07-23 03:09:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestPodcastRSS(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildPodcastRSS(), RegexPodcastRSS, nil)
|
2021-07-23 03:09:46 +00:00
|
|
|
}
|
|
|
|
|
2021-07-30 03:40:47 +00:00
|
|
|
func TestForum(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildForum("", nil, 1), RegexForum, nil)
|
|
|
|
AssertRegexMatch(t, BuildForum("", []string{"wip"}, 2), RegexForum, map[string]string{"subforums": "wip", "page": "2"})
|
|
|
|
AssertRegexMatch(t, BuildForum("", []string{"sub", "wip"}, 2), RegexForum, map[string]string{"subforums": "sub/wip", "page": "2"})
|
|
|
|
AssertSubdomain(t, BuildForum("hmn", nil, 1), "")
|
|
|
|
AssertSubdomain(t, BuildForum("", nil, 1), "")
|
|
|
|
AssertSubdomain(t, BuildForum("hero", nil, 1), "hero")
|
|
|
|
assert.Panics(t, func() { BuildForum("", nil, 0) })
|
|
|
|
assert.Panics(t, func() { BuildForum("", []string{"", "wip"}, 1) })
|
|
|
|
assert.Panics(t, func() { BuildForum("", []string{" ", "wip"}, 1) })
|
|
|
|
assert.Panics(t, func() { BuildForum("", []string{"wip/jobs"}, 1) })
|
2021-05-05 20:34:32 +00:00
|
|
|
}
|
|
|
|
|
2021-05-11 22:53:23 +00:00
|
|
|
func TestForumNewThread(t *testing.T) {
|
2021-07-30 03:40:47 +00:00
|
|
|
AssertRegexMatch(t, BuildForumNewThread("", []string{"sub", "wip"}, false), RegexForumNewThread, map[string]string{"subforums": "sub/wip"})
|
|
|
|
AssertRegexMatch(t, BuildForumNewThread("", []string{"sub", "wip"}, true), RegexForumNewThreadSubmit, map[string]string{"subforums": "sub/wip"})
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestForumThread(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildForumThread("", nil, 1, "", 1), RegexForumThread, map[string]string{"threadid": "1"})
|
|
|
|
AssertRegexMatch(t, BuildForumThread("", nil, 1, "thread/title/123http://", 2), RegexForumThread, map[string]string{"threadid": "1", "page": "2"})
|
|
|
|
AssertRegexMatch(t, BuildForumThreadWithPostHash("", nil, 1, "thread/title/123http://", 2, 123), RegexForumThread, map[string]string{"threadid": "1", "page": "2"})
|
|
|
|
AssertSubdomain(t, BuildForumThread("hero", nil, 1, "", 1), "hero")
|
|
|
|
assert.Panics(t, func() { BuildForumThread("", nil, -1, "", 1) })
|
|
|
|
assert.Panics(t, func() { BuildForumThread("", nil, 1, "", -1) })
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestForumPost(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildForumPost("", nil, 1, 2), RegexForumPost, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildForumPost("", nil, 1, 2), RegexForumThread)
|
|
|
|
AssertSubdomain(t, BuildForumPost("hero", nil, 1, 2), "hero")
|
|
|
|
assert.Panics(t, func() { BuildForumPost("", nil, 1, -1) })
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestForumPostDelete(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildForumPostDelete("", nil, 1, 2), RegexForumPostDelete, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildForumPostDelete("", nil, 1, 2), RegexForumPost)
|
|
|
|
AssertSubdomain(t, BuildForumPostDelete("hero", nil, 1, 2), "hero")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestForumPostEdit(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildForumPostEdit("", nil, 1, 2), RegexForumPostEdit, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildForumPostEdit("", nil, 1, 2), RegexForumPost)
|
|
|
|
AssertSubdomain(t, BuildForumPostEdit("hero", nil, 1, 2), "hero")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestForumPostReply(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildForumPostReply("", nil, 1, 2), RegexForumPostReply, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildForumPostReply("", nil, 1, 2), RegexForumPost)
|
|
|
|
AssertSubdomain(t, BuildForumPostReply("hero", nil, 1, 2), "hero")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestBlog(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildBlog("", 1), RegexBlog, nil)
|
|
|
|
AssertRegexMatch(t, BuildBlog("", 2), RegexBlog, map[string]string{"page": "2"})
|
|
|
|
AssertSubdomain(t, BuildBlog("hero", 1), "hero")
|
|
|
|
}
|
|
|
|
|
2021-09-27 03:35:42 +00:00
|
|
|
func TestBlogNewThread(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildBlogNewThread(""), RegexBlogNewThread, nil)
|
|
|
|
AssertSubdomain(t, BuildBlogNewThread(""), "")
|
|
|
|
AssertRegexMatch(t, BuildBlogNewThread("hero"), RegexBlogNewThread, nil)
|
|
|
|
AssertSubdomain(t, BuildBlogNewThread("hero"), "hero")
|
|
|
|
}
|
|
|
|
|
2021-05-11 22:53:23 +00:00
|
|
|
func TestBlogThread(t *testing.T) {
|
2021-08-08 20:05:52 +00:00
|
|
|
AssertRegexMatch(t, BuildBlogThread("", 1, ""), RegexBlogThread, map[string]string{"threadid": "1"})
|
|
|
|
AssertRegexMatch(t, BuildBlogThread("", 1, ""), RegexBlogThread, map[string]string{"threadid": "1"})
|
|
|
|
AssertRegexMatch(t, BuildBlogThread("", 1, "title/bla/http://"), RegexBlogThread, map[string]string{"threadid": "1"})
|
|
|
|
AssertRegexMatch(t, BuildBlogThreadWithPostHash("", 1, "title/bla/http://", 123), RegexBlogThread, map[string]string{"threadid": "1"})
|
|
|
|
AssertRegexNoMatch(t, BuildBlogThread("", 1, ""), RegexBlog)
|
|
|
|
AssertSubdomain(t, BuildBlogThread("hero", 1, ""), "hero")
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestBlogPost(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildBlogPost("", 1, 2), RegexBlogPost, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildBlogPost("", 1, 2), RegexBlogThread)
|
|
|
|
AssertSubdomain(t, BuildBlogPost("hero", 1, 2), "hero")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestBlogPostDelete(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildBlogPostDelete("", 1, 2), RegexBlogPostDelete, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildBlogPostDelete("", 1, 2), RegexBlogPost)
|
|
|
|
AssertSubdomain(t, BuildBlogPostDelete("hero", 1, 2), "hero")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestBlogPostEdit(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildBlogPostEdit("", 1, 2), RegexBlogPostEdit, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildBlogPostEdit("", 1, 2), RegexBlogPost)
|
|
|
|
AssertSubdomain(t, BuildBlogPostEdit("hero", 1, 2), "hero")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestBlogPostReply(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildBlogPostReply("", 1, 2), RegexBlogPostReply, map[string]string{"threadid": "1", "postid": "2"})
|
|
|
|
AssertRegexNoMatch(t, BuildBlogPostReply("", 1, 2), RegexBlogPost)
|
|
|
|
AssertSubdomain(t, BuildBlogPostReply("hero", 1, 2), "hero")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestLibrary(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildLibrary(), RegexLibrary, nil)
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestLibraryAll(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildLibraryAll(), RegexLibraryAll, nil)
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestLibraryTopic(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildLibraryTopic(1), RegexLibraryTopic, map[string]string{"topicid": "1"})
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestLibraryResource(t *testing.T) {
|
2021-10-27 00:45:11 +00:00
|
|
|
AssertRegexMatch(t, BuildLibraryResource(1), RegexLibraryResource, map[string]string{"resourceid": "1"})
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
2021-08-28 10:40:13 +00:00
|
|
|
func TestEpisodeGuide(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildEpisodeList("hero", ""), RegexEpisodeList, map[string]string{"topic": ""})
|
|
|
|
AssertRegexMatch(t, BuildEpisodeList("hero", "code"), RegexEpisodeList, map[string]string{"topic": "code"})
|
|
|
|
AssertSubdomain(t, BuildEpisodeList("hero", "code"), "hero")
|
|
|
|
|
|
|
|
AssertRegexMatch(t, BuildEpisode("hero", "code", "day001"), RegexEpisode, map[string]string{"topic": "code", "episode": "day001"})
|
|
|
|
AssertSubdomain(t, BuildEpisode("hero", "code", "day001"), "hero")
|
|
|
|
|
|
|
|
AssertRegexMatch(t, BuildCineraIndex("hero", "code"), RegexCineraIndex, map[string]string{"topic": "code"})
|
|
|
|
AssertSubdomain(t, BuildCineraIndex("hero", "code"), "hero")
|
|
|
|
}
|
|
|
|
|
2021-09-21 23:13:11 +00:00
|
|
|
func TestAssetUpload(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildAssetUpload("hero"), RegexAssetUpload, nil)
|
|
|
|
AssertSubdomain(t, BuildAssetUpload("hero"), "hero")
|
|
|
|
}
|
|
|
|
|
2021-05-05 20:34:32 +00:00
|
|
|
func TestProjectCSS(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildProjectCSS("000000"), RegexProjectCSS, nil)
|
|
|
|
}
|
|
|
|
|
2021-12-07 05:20:12 +00:00
|
|
|
func TestMarkdownWorkerJS(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildMarkdownWorkerJS(), RegexMarkdownWorkerJS, nil)
|
2021-09-27 03:35:42 +00:00
|
|
|
}
|
|
|
|
|
2021-11-25 03:59:51 +00:00
|
|
|
func TestAPICheckUsername(t *testing.T) {
|
2021-12-07 05:20:12 +00:00
|
|
|
AssertRegexMatch(t, BuildAPICheckUsername(), RegexAPICheckUsername, nil)
|
2021-11-25 03:59:51 +00:00
|
|
|
}
|
|
|
|
|
2021-05-05 20:34:32 +00:00
|
|
|
func TestPublic(t *testing.T) {
|
2021-05-25 13:12:20 +00:00
|
|
|
AssertRegexMatch(t, BuildPublic("test", false), RegexPublic, nil)
|
|
|
|
AssertRegexMatch(t, BuildPublic("/test", true), RegexPublic, nil)
|
|
|
|
AssertRegexMatch(t, BuildPublic("/test/", false), RegexPublic, nil)
|
|
|
|
AssertRegexMatch(t, BuildPublic("/test/thing/image.png", true), RegexPublic, nil)
|
|
|
|
assert.Panics(t, func() { BuildPublic("", false) })
|
|
|
|
assert.Panics(t, func() { BuildPublic("/", false) })
|
|
|
|
assert.Panics(t, func() { BuildPublic("/thing//image.png", false) })
|
|
|
|
assert.Panics(t, func() { BuildPublic("/thing/ /image.png", false) })
|
|
|
|
assert.Panics(t, func() { BuildPublic("/thing/image.png?hello", false) })
|
|
|
|
|
|
|
|
AssertRegexMatch(t, BuildTheme("test.css", "light", true), RegexPublic, nil)
|
2021-05-31 23:23:04 +00:00
|
|
|
AssertRegexMatch(t, BuildUserFile("mylogo.png"), RegexPublic, nil)
|
2021-05-05 20:34:32 +00:00
|
|
|
}
|
|
|
|
|
2021-07-30 03:40:47 +00:00
|
|
|
func TestForumMarkRead(t *testing.T) {
|
2021-09-21 23:13:11 +00:00
|
|
|
AssertRegexMatch(t, BuildForumMarkRead("hero", 5), RegexForumMarkRead, map[string]string{"sfid": "5"})
|
|
|
|
AssertSubdomain(t, BuildForumMarkRead("hero", 5), "hero")
|
2021-05-11 22:53:23 +00:00
|
|
|
}
|
|
|
|
|
2021-09-22 19:18:39 +00:00
|
|
|
func TestS3Asset(t *testing.T) {
|
|
|
|
AssertRegexMatchFull(t, BuildS3Asset("hello"), RegexS3Asset, map[string]string{"key": "hello"})
|
|
|
|
}
|
|
|
|
|
2021-09-27 03:35:42 +00:00
|
|
|
func TestJamIndex(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildJamIndex(), RegexJamIndex, nil)
|
|
|
|
AssertSubdomain(t, BuildJamIndex(), "")
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDiscordOAuthCallback(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildDiscordOAuthCallback(), RegexDiscordOAuthCallback, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDiscordUnlink(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildDiscordUnlink(), RegexDiscordUnlink, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDiscordShowcaseBacklog(t *testing.T) {
|
|
|
|
AssertRegexMatch(t, BuildDiscordShowcaseBacklog(), RegexDiscordShowcaseBacklog, nil)
|
|
|
|
}
|
|
|
|
|
2021-05-05 20:34:32 +00:00
|
|
|
func AssertSubdomain(t *testing.T, fullUrl string, expectedSubdomain string) {
|
2021-05-16 19:22:45 +00:00
|
|
|
t.Helper()
|
|
|
|
|
2021-05-05 20:34:32 +00:00
|
|
|
parsed, err := url.Parse(fullUrl)
|
|
|
|
ok := assert.Nilf(t, err, "Full url could not be parsed: %s", fullUrl)
|
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
fullHost := parsed.Host
|
|
|
|
if len(expectedSubdomain) == 0 {
|
|
|
|
assert.Equal(t, baseUrlParsed.Host, fullHost, "Did not expect a subdomain")
|
|
|
|
} else {
|
|
|
|
assert.Equalf(t, expectedSubdomain+"."+baseUrlParsed.Host, fullHost, "Subdomain mismatch")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func AssertRegexMatch(t *testing.T, fullUrl string, regex *regexp.Regexp, paramsToVerify map[string]string) {
|
2021-05-16 19:22:45 +00:00
|
|
|
t.Helper()
|
|
|
|
|
2021-05-05 20:34:32 +00:00
|
|
|
parsed, err := url.Parse(fullUrl)
|
|
|
|
ok := assert.Nilf(t, err, "Full url could not be parsed: %s", fullUrl)
|
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
requestPath := parsed.Path
|
|
|
|
if len(requestPath) == 0 {
|
|
|
|
requestPath = "/"
|
|
|
|
}
|
2021-09-22 19:18:39 +00:00
|
|
|
|
|
|
|
AssertRegexMatchFull(t, requestPath, regex, paramsToVerify)
|
|
|
|
}
|
|
|
|
|
|
|
|
func AssertRegexMatchFull(t *testing.T, fullUrl string, regex *regexp.Regexp, paramsToVerify map[string]string) {
|
|
|
|
t.Helper()
|
|
|
|
|
|
|
|
match := regex.FindStringSubmatch(fullUrl)
|
|
|
|
assert.NotNilf(t, match, "Url did not match regex: [%s] vs [%s]", fullUrl, regex.String())
|
2021-05-05 20:34:32 +00:00
|
|
|
|
|
|
|
if paramsToVerify != nil {
|
|
|
|
subexpNames := regex.SubexpNames()
|
|
|
|
for i, matchedValue := range match {
|
|
|
|
paramName := subexpNames[i]
|
|
|
|
expectedValue, ok := paramsToVerify[paramName]
|
|
|
|
if ok {
|
|
|
|
assert.Equalf(t, expectedValue, matchedValue, "Param mismatch for [%s]", paramName)
|
|
|
|
delete(paramsToVerify, paramName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(paramsToVerify) > 0 {
|
|
|
|
unmatchedParams := make([]string, 0, len(paramsToVerify))
|
|
|
|
for paramName := range paramsToVerify {
|
|
|
|
unmatchedParams = append(unmatchedParams, paramName)
|
|
|
|
}
|
|
|
|
assert.Fail(t, "Expected match groups not found", unmatchedParams)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-05-11 22:53:23 +00:00
|
|
|
|
|
|
|
func AssertRegexNoMatch(t *testing.T, fullUrl string, regex *regexp.Regexp) {
|
2021-05-16 19:22:45 +00:00
|
|
|
t.Helper()
|
|
|
|
|
2021-05-11 22:53:23 +00:00
|
|
|
parsed, err := url.Parse(fullUrl)
|
|
|
|
ok := assert.Nilf(t, err, "Full url could not be parsed: %s", fullUrl)
|
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
requestPath := parsed.Path
|
|
|
|
if len(requestPath) == 0 {
|
|
|
|
requestPath = "/"
|
|
|
|
}
|
|
|
|
match := regex.FindStringSubmatch(requestPath)
|
|
|
|
assert.Nilf(t, match, "Url matched regex: [%s] vs [%s]", requestPath, regex.String())
|
|
|
|
}
|
2021-07-30 03:40:47 +00:00
|
|
|
|
|
|
|
func TestThingsThatDontNeedCoverage(t *testing.T) {
|
|
|
|
// look the other way ಠ_ಠ
|
2021-10-27 00:45:11 +00:00
|
|
|
BuildPodcastEpisodeFile("foo")
|
2021-07-30 03:40:47 +00:00
|
|
|
}
|