mattermost/model/utils_test.go

// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.

package model

import (
	"net/http"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestNewId(t *testing.T) {
	for i := 0; i < 1000; i++ {
		id := NewId()
		if len(id) > 26 {
			t.Fatal("ids shouldn't be longer than 26 chars")
		}
	}
}

func TestRandomString(t *testing.T) {
	for i := 0; i < 1000; i++ {
		r := NewRandomString(32)
		if len(r) != 32 {
			t.Fatal("should be 32 chars")
		}
	}
}

func TestAppError(t *testing.T) {
	err := NewAppError("TestAppError", "message", nil, "", http.StatusInternalServerError)
	json := err.ToJson()
	rerr := AppErrorFromJson(strings.NewReader(json))
	if err.Message != rerr.Message {
		t.Fatal()
	}

	t.Log(err.Error())
}

func TestAppErrorJunk(t *testing.T) {
	rerr := AppErrorFromJson(strings.NewReader("<html><body>This is a broken test</body></html>"))
	if "body: <html><body>This is a broken test</body></html>" != rerr.DetailedError {
		t.Fatal()
	}
}

func TestCopyStringMap(t *testing.T) {
	itemKey := "item1"
	originalMap := make(map[string]string)
	originalMap[itemKey] = "val1"

	copyMap := CopyStringMap(originalMap)
	copyMap[itemKey] = "changed"

	assert.Equal(t, "val1", originalMap[itemKey])
}

func TestMapJson(t *testing.T) {

	m := make(map[string]string)
	m["id"] = "test_id"
	json := MapToJson(m)

	rm := MapFromJson(strings.NewReader(json))

	if rm["id"] != "test_id" {
		t.Fatal("map should be valid")
	}

	rm2 := MapFromJson(strings.NewReader(""))
	if len(rm2) > 0 {
		t.Fatal("make should be ivalid")
	}
}

func TestValidEmail(t *testing.T) {
	if !IsValidEmail("corey+test@hulen.com") {
		t.Error("email should be valid")
	}

	if IsValidEmail("@corey+test@hulen.com") {
		t.Error("should be invalid")
	}
}

func TestValidLower(t *testing.T) {
	if !IsLower("corey+test@hulen.com") {
		t.Error("should be valid")
	}

	if IsLower("Corey+test@hulen.com") {
		t.Error("should be invalid")
	}
}

func TestEtag(t *testing.T) {
	etag := Etag("hello", 24)
	if len(etag) <= 0 {
		t.Fatal()
	}
}

var hashtags = map[string]string{
	"#test":           "#test",
	"test":            "",
	"#test123":        "#test123",
	"#123test123":     "",
	"#test-test":      "#test-test",
	"#test?":          "#test",
	"hi #there":       "#there",
	"#bug #idea":      "#bug #idea",
	"#bug or #gif!":   "#bug #gif",
	"#hüllo":          "#hüllo",
	"#?test":          "",
	"#-test":          "",
	"#yo_yo":          "#yo_yo",
	"(#brakets)":      "#brakets",
	")#stekarb(":      "#stekarb",
	"<#less_than<":    "#less_than",
	">#greater_than>": "#greater_than",
	"-#minus-":        "#minus",
	"_#under_":        "#under",
	"+#plus+":         "#plus",
	"=#equals=":       "#equals",
	"%#pct%":          "#pct",
	"&#and&":          "#and",
	"^#hat^":          "#hat",
	"##brown#":        "#brown",
	"*#star*":         "#star",
	"|#pipe|":         "#pipe",
	":#colon:":        "#colon",
	";#semi;":         "#semi",
	"#Mötley;":        "#Mötley",
	".#period.":       "#period",
	"¿#upside¿":       "#upside",
	"\"#quote\"":      "#quote",
	"/#slash/":        "#slash",
	"\\#backslash\\":  "#backslash",
	"#a":              "",
	"#1":              "",
	"foo#bar":         "",
}

func TestParseHashtags(t *testing.T) {
	for input, output := range hashtags {
		if o, _ := ParseHashtags(input); o != output {
			t.Fatal("failed to parse hashtags from input=" + input + " expected=" + output + " actual=" + o)
		}
	}
}

func TestIsValidAlphaNum(t *testing.T) {
	cases := []struct {
		Input  string
		Result bool
	}{
		{
			Input:  "test",
			Result: true,
		},
		{
			Input:  "test-name",
			Result: true,
		},
		{
			Input:  "test--name",
			Result: true,
		},
		{
			Input:  "test__name",
			Result: true,
		},
		{
			Input:  "-",
			Result: false,
		},
		{
			Input:  "__",
			Result: false,
		},
		{
			Input:  "test-",
			Result: false,
		},
		{
			Input:  "test--",
			Result: false,
		},
		{
			Input:  "test__",
			Result: false,
		},
		{
			Input:  "test:name",
			Result: false,
		},
	}

	for _, tc := range cases {
		actual := IsValidAlphaNum(tc.Input)
		if actual != tc.Result {
			t.Fatalf("case: %v\tshould returned: %#v", tc, tc.Result)
		}
	}
}

func TestGetServerIpAddress(t *testing.T) {
	if len(GetServerIpAddress()) == 0 {
		t.Fatal("Should find local ip address")
	}
}

func TestIsValidAlphaNumHyphenUnderscore(t *testing.T) {
	casesWithFormat := []struct {
		Input  string
		Result bool
	}{
		{
			Input:  "test",
			Result: true,
		},
		{
			Input:  "test-name",
			Result: true,
		},
		{
			Input:  "test--name",
			Result: true,
		},
		{
			Input:  "test__name",
			Result: true,
		},
		{
			Input:  "test_name",
			Result: true,
		},
		{
			Input:  "test_-name",
			Result: true,
		},
		{
			Input:  "-",
			Result: false,
		},
		{
			Input:  "__",
			Result: false,
		},
		{
			Input:  "test-",
			Result: false,
		},
		{
			Input:  "test--",
			Result: false,
		},
		{
			Input:  "test__",
			Result: false,
		},
		{
			Input:  "test:name",
			Result: false,
		},
	}

	for _, tc := range casesWithFormat {
		actual := IsValidAlphaNumHyphenUnderscore(tc.Input, true)
		if actual != tc.Result {
			t.Fatalf("case: %v\tshould returned: %#v", tc, tc.Result)
		}
	}

	casesWithoutFormat := []struct {
		Input  string
		Result bool
	}{
		{
			Input:  "test",
			Result: true,
		},
		{
			Input:  "test-name",
			Result: true,
		},
		{
			Input:  "test--name",
			Result: true,
		},
		{
			Input:  "test__name",
			Result: true,
		},
		{
			Input:  "test_name",
			Result: true,
		},
		{
			Input:  "test_-name",
			Result: true,
		},
		{
			Input:  "-",
			Result: true,
		},
		{
			Input:  "_",
			Result: true,
		},
		{
			Input:  "test-",
			Result: true,
		},
		{
			Input:  "test--",
			Result: true,
		},
		{
			Input:  "test__",
			Result: true,
		},
		{
			Input:  ".",
			Result: false,
		},

		{
			Input:  "test,",
			Result: false,
		},
		{
			Input:  "test:name",
			Result: false,
		},
	}

	for _, tc := range casesWithoutFormat {
		actual := IsValidAlphaNumHyphenUnderscore(tc.Input, false)
		if actual != tc.Result {
			t.Fatalf("case: '%v'\tshould returned: %#v", tc.Input, tc.Result)
		}
	}
}

func TestIsValidId(t *testing.T) {
	cases := []struct {
		Input  string
		Result bool
	}{
		{
			Input:  NewId(),
			Result: true,
		},
		{
			Input:  "",
			Result: false,
		},
		{
			Input:  "junk",
			Result: false,
		},
		{
			Input:  "qwertyuiop1234567890asdfg{",
			Result: false,
		},
		{
			Input:  NewId() + "}",
			Result: false,
		},
	}

	for _, tc := range cases {
		actual := IsValidId(tc.Input)
		if actual != tc.Result {
			t.Fatalf("case: %v\tshould returned: %#v", tc, tc.Result)
		}
	}
}

func TestNowhereNil(t *testing.T) {
	t.Parallel()

	var nilStringPtr *string
	var nonNilStringPtr *string = new(string)
	var nilSlice []string
	var nilStruct *struct{}
	var nilMap map[bool]bool

	var nowhereNilStruct = struct {
		X *string
		Y *string
	}{
		nonNilStringPtr,
		nonNilStringPtr,
	}
	var somewhereNilStruct = struct {
		X *string
		Y *string
	}{
		nonNilStringPtr,
		nilStringPtr,
	}

	var privateSomewhereNilStruct = struct {
		X *string
		y *string
	}{
		nonNilStringPtr,
		nilStringPtr,
	}

	testCases := []struct {
		Description string
		Value       interface{}
		Expected    bool
	}{
		{
			"nil",
			nil,
			false,
		},
		{
			"empty string",
			"",
			true,
		},
		{
			"non-empty string",
			"not empty!",
			true,
		},
		{
			"nil string pointer",
			nilStringPtr,
			false,
		},
		{
			"non-nil string pointer",
			nonNilStringPtr,
			true,
		},
		{
			"0",
			0,
			true,
		},
		{
			"1",
			1,
			true,
		},
		{
			"0 (int64)",
			int64(0),
			true,
		},
		{
			"1 (int64)",
			int64(1),
			true,
		},
		{
			"true",
			true,
			true,
		},
		{
			"false",
			false,
			true,
		},
		{
			"nil slice",
			nilSlice,
			// A nil slice is observably the same as an empty slice, so allow it.
			true,
		},
		{
			"empty slice",
			[]string{},
			true,
		},
		{
			"slice containing nils",
			[]*string{nil, nil},
			true,
		},
		{
			"nil map",
			nilMap,
			false,
		},
		{
			"non-nil map",
			make(map[bool]bool),
			true,
		},
		{
			"non-nil map containing nil",
			map[bool]*string{true: nilStringPtr, false: nonNilStringPtr},
			// Map values are not checked
			true,
		},
		{
			"nil struct",
			nilStruct,
			false,
		},
		{
			"empty struct",
			struct{}{},
			true,
		},
		{
			"struct containing no nil",
			nowhereNilStruct,
			true,
		},
		{
			"struct containing nil",
			somewhereNilStruct,
			false,
		},
		{
			"struct pointer containing no nil",
			&nowhereNilStruct,
			true,
		},
		{
			"struct pointer containing nil",
			&somewhereNilStruct,
			false,
		},
		{
			"struct containing private nil",
			privateSomewhereNilStruct,
			true,
		},
		{
			"struct pointer containing private nil",
			&privateSomewhereNilStruct,
			true,
		},
	}

	for _, testCase := range testCases {
		testCase := testCase
		t.Run(testCase.Description, func(t *testing.T) {
			defer func() {
				if r := recover(); r != nil {
					t.Errorf("panic: %v", r)
				}
			}()

			t.Parallel()
			require.Equal(t, testCase.Expected, checkNowhereNil(t, "value", testCase.Value))
		})
	}
}
PLT-5860 Updated copyright date (#6058) * PLT-5860 Updated copyright date in about modal * PLT-5860 Updated copyright notice in JSX files * PLT-5860 Updated copyright notice in go files * Fixed misc copyright dates * Fixed component snapshots 2017-04-12 08:27:57 -04:00			`// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.`
first commit 2015-06-14 23:53:32 -08:00			`// See License.txt for license information.`

			`package model`

			`import (`
Model: NewLocAppError -> NewAppError (#7450) 2017-09-15 13:32:11 +01:00			`"net/http"`
first commit 2015-06-14 23:53:32 -08:00			`"strings"`
			`"testing"`
MM-9977: test config.SetDefaults leaves nothing nil (#8610) * MM-9977: test config.SetDefaults leaves nothing nil * clarify test default config test cases * comment re: allowing nil slice * extend config SetDefaults to handle partially initialized configs 2018-04-13 10:56:09 -04:00
MM-10007 Send an admin and regular WS events when a user is updated (#8588) * Add user.DeepCopy() function * Add omit admins/non-admins to WS broadcast and use for updating users * Updates per feedback and adding unit test for ShouldSendEvent 2018-04-20 08:44:18 -04:00			`"github.com/stretchr/testify/assert"`
MM-9977: test config.SetDefaults leaves nothing nil (#8610) * MM-9977: test config.SetDefaults leaves nothing nil * clarify test default config test cases * comment re: allowing nil slice * extend config SetDefaults to handle partially initialized configs 2018-04-13 10:56:09 -04:00			`"github.com/stretchr/testify/require"`
first commit 2015-06-14 23:53:32 -08:00			`)`

			`func TestNewId(t *testing.T) {`
			`for i := 0; i < 1000; i++ {`
			`id := NewId()`
			`if len(id) > 26 {`
			`t.Fatal("ids shouldn't be longer than 26 chars")`
			`}`
			`}`
			`}`

Generate salts when empty 2015-12-09 15:42:48 -08:00			`func TestRandomString(t *testing.T) {`
			`for i := 0; i < 1000; i++ {`
			`r := NewRandomString(32)`
			`if len(r) != 32 {`
			`t.Fatal("should be 32 chars")`
			`}`
			`}`
			`}`

first commit 2015-06-14 23:53:32 -08:00			`func TestAppError(t *testing.T) {`
Model: NewLocAppError -> NewAppError (#7450) 2017-09-15 13:32:11 +01:00			`err := NewAppError("TestAppError", "message", nil, "", http.StatusInternalServerError)`
first commit 2015-06-14 23:53:32 -08:00			`json := err.ToJson()`
			`rerr := AppErrorFromJson(strings.NewReader(json))`
			`if err.Message != rerr.Message {`
			`t.Fatal()`
			`}`

Adding go vet from hack-a-thon (#5328) * Adding go vet to the api package * Adding go vet to app package * Adding go vet to manualtesting package * Adding go vet to the model package * Adding go vet to the store dir * Adding go vet to utils package * Adding missing dirs with go files * Fixing up makefile * Fixing up makefile * Removing root dir 2017-02-09 13:39:15 -08:00			`t.Log(err.Error())`
first commit 2015-06-14 23:53:32 -08:00			`}`

Merging performance branch into master (#4268) * improve performance on sendNotifications * Fix SQL queries * Remove get direct profiles, not needed anymore * Add raw data to error details if AppError fails to decode * men * Fix decode (#4052) * Fixing json decode * Adding unit test * Initial work for client scaling (#4051) * Begin adding paging to profiles API * Added more paging functionality * Finish hooking up admin console user lists * Add API for searching users and add searching to all user lists * Add lazy loading of profiles * Revert config.json * Fix unit tests and some style issues * Add GetProfilesFromList to Go driver and fix web unit test * Update etag for GetProfiles * Updating ui for filters and pagination (#4044) * Updating UI for pagination * Adjusting margins for filter row * Adjusting margin for specific modals * Adding relative padding to system console * Adjusting responsive view * Update client user tests * Minor fixes for direct messages modal (#4056) * Remove some unneeded initial load calls (#4057) * UX updates to user lists, added smart counts and bug fixes (#4059) * Improved getExplicitMentions and unit tests (#4064) * Refactor getting posts to lazy load profiles correctly (#4062) * Comment out SetActiveChannel test (#4066) * Profiler cpu, block, and memory profiler. (#4081) * Fix TestSetActiveChannel unit test (#4071) * Fixing build failure caused by dependancies updating (#4076) * Adding profiler * Fix admin_team_member_dropdown eslint errors * Bumping session cache size (#4077) * Bumping session cache size * Bumping status cache * Refactor how the client handles channel members to be large team friendly (#4106) * Refactor how the client handles channel members to be large team friendly * Change Id to ChannelId in ChannelStats model * Updated getChannelMember and getProfilesByIds routes to match proposal * Performance improvements (#4100) * Performance improvements * Fixing re-connect issue * Fixing error message * Some other minor perf tweaks * Some other minor perf tweaks * Fixing config file * Fixing buffer size * Fixing web socket send message * adding some error logging * fix getMe to be user required * Fix websocket event for new user * Fixing shutting down * Reverting web socket changes * Fixing logging lvl * Adding caching to GetMember * Adding some logging * Fixing caching * Fixing caching invalidate * Fixing direct message caching * Fixing caching * Fixing caching * Remove GetDirectProfiles from initial load * Adding logging and fixing websocket client * Adding back caching from bad merge. * Explicitly close go driver requests (#4162) * Refactored how the client handles team members to be more large team friendly (#4159) * Refactor getProfilesForDirectMessageList API into getAllProfiles API * Refactored how the client handles team members to be more large team friendly * Fix js error when receiving a notification * Fix JS error caused by current user being overwritten with sanitized version (#4165) * Adding error message to status failure (#4167) * Fix a few bugs caused by client scaling refactoring (#4170) * When there is no read replica, don't open a second set of connections to the master database (#4173) * Adding connection tacking to stats (#4174) * Reduce DB writes for statuses and other status related changes (#4175) * Fix bug preventing opening of DM channels from more modal (#4181) * Fixing socket timing error (#4183) * Fixing ping/pong handler * Fixing socket timing error * Commenting out status broadcasting * Removing user status changes * Removing user status changes * Removing user status changes * Removing user status changes * Adding DoPreComputeJson() * Performance improvements (#4194) * * Fix System Console Analytics queries * Add db.SetConnMaxLifetime to 15 minutes * Add "net/http/pprof" for profiling * Add FreeOSMemory() to manually release memory on reload config * Add flag to enable http profiler * Fix memory leak (#4197) * Fix memory leak * removed unneeded nil assignment * Fixing go routine leak (#4208) * Merge fixes * Merge fix * Refactored statuses to be queried by the client rather than broadcast by the server (#4212) * Refactored server code to reduce status broadcasts and to allow getting statuses by IDs * Refactor client code to periodically fetch statuses * Add store unit test for getting statuses by ids * Fix status unit test * Add getStatusesByIds REST API and move the client over to use that instead of the WebSocket * Adding multiple threads to websocket hub (#4230) * Adding multiple threads to websocket hub * Fixing unit tests * Fixing so websocket connections from the same user end up in the same… (#4240) * Fixing so websocket connections from the same user end up in the same list * Removing old comment * Refactor user autocomplete to query the server (#4239) * Add API for autocompleting users * Converted at mention autocomplete to query server * Converted user search autocomplete to query server * Switch autocomplete API naming to use term instead of username * Split autocomplete API into two, one for channels and for teams * Fix copy/paste error * Some final client scaling fixes (#4246) * Add lazy loading of profiles to integration pages * Add lazy loading of profiles to emoji page * Fix JS error when receiving post in select team menu and also clean up channel store 2016-10-19 14:49:25 -04:00			`func TestAppErrorJunk(t *testing.T) {`
			`rerr := AppErrorFromJson(strings.NewReader("<html><body>This is a broken test</body></html>"))`
			`if "body: <html><body>This is a broken test</body></html>" != rerr.DetailedError {`
			`t.Fatal()`
			`}`
			`}`

MM-10007 Send an admin and regular WS events when a user is updated (#8588) * Add user.DeepCopy() function * Add omit admins/non-admins to WS broadcast and use for updating users * Updates per feedback and adding unit test for ShouldSendEvent 2018-04-20 08:44:18 -04:00			`func TestCopyStringMap(t *testing.T) {`
			`itemKey := "item1"`
			`originalMap := make(map[string]string)`
			`originalMap[itemKey] = "val1"`

			`copyMap := CopyStringMap(originalMap)`
			`copyMap[itemKey] = "changed"`

			`assert.Equal(t, "val1", originalMap[itemKey])`
			`}`

first commit 2015-06-14 23:53:32 -08:00			`func TestMapJson(t *testing.T) {`

			`m := make(map[string]string)`
			`m["id"] = "test_id"`
			`json := MapToJson(m)`

			`rm := MapFromJson(strings.NewReader(json))`

			`if rm["id"] != "test_id" {`
			`t.Fatal("map should be valid")`
			`}`

			`rm2 := MapFromJson(strings.NewReader(""))`
			`if len(rm2) > 0 {`
			`t.Fatal("make should be ivalid")`
			`}`
			`}`

			`func TestValidEmail(t *testing.T) {`
Updated emails in unit tests to include '+' 2015-12-13 14:21:23 -08:00			`if !IsValidEmail("corey+test@hulen.com") {`
first commit 2015-06-14 23:53:32 -08:00			`t.Error("email should be valid")`
			`}`

Updated emails in unit tests to include '+' 2015-12-13 14:21:23 -08:00			`if IsValidEmail("@corey+test@hulen.com") {`
first commit 2015-06-14 23:53:32 -08:00			`t.Error("should be invalid")`
			`}`
			`}`

			`func TestValidLower(t *testing.T) {`
Updated emails in unit tests to include '+' 2015-12-13 14:21:23 -08:00			`if !IsLower("corey+test@hulen.com") {`
first commit 2015-06-14 23:53:32 -08:00			`t.Error("should be valid")`
			`}`

Fixing issues caused by changing test emails 2015-12-13 14:56:57 -08:00			`if IsLower("Corey+test@hulen.com") {`
first commit 2015-06-14 23:53:32 -08:00			`t.Error("should be invalid")`
			`}`
			`}`

			`func TestEtag(t *testing.T) {`
			`etag := Etag("hello", 24)`
			`if len(etag) <= 0 {`
			`t.Fatal()`
			`}`
			`}`
Add hashtag testing and allow special german characters 2015-12-11 13:03:14 -05:00
PLT-2283 Improved trimming of punctuation from hashtags and search terms (#3178) * Improved trimming of punctuation from hashtags and search terms * Separated punctuation regexes used for hashtags and for search terms 2016-06-01 16:05:36 -04:00			`var hashtags = map[string]string{`
Updated serverside hashtag regex to ignore more punctuation around words 2016-01-25 16:47:49 -05:00			`"#test": "#test",`
			`"test": "",`
			`"#test123": "#test123",`
			`"#123test123": "",`
			`"#test-test": "#test-test",`
			`"#test?": "#test",`
			`"hi #there": "#there",`
			`"#bug #idea": "#bug #idea",`
			`"#bug or #gif!": "#bug #gif",`
			`"#hüllo": "#hüllo",`
			`"#?test": "",`
			`"#-test": "",`
			`"#yo_yo": "#yo_yo",`
			`"(#brakets)": "#brakets",`
			`")#stekarb(": "#stekarb",`
			`"<#less_than<": "#less_than",`
			`">#greater_than>": "#greater_than",`
			`"-#minus-": "#minus",`
PLT-2283 Improved trimming of punctuation from hashtags and search terms (#3178) * Improved trimming of punctuation from hashtags and search terms * Separated punctuation regexes used for hashtags and for search terms 2016-06-01 16:05:36 -04:00			`"_#under_": "#under",`
Updated serverside hashtag regex to ignore more punctuation around words 2016-01-25 16:47:49 -05:00			`"+#plus+": "#plus",`
			`"=#equals=": "#equals",`
			`"%#pct%": "#pct",`
			`"&#and&": "#and",`
			`"^#hat^": "#hat",`
			`"##brown#": "#brown",`
			`"#star": "#star",`
			`"\|#pipe\|": "#pipe",`
			`":#colon:": "#colon",`
			`";#semi;": "#semi",`
PLT-2283 Improved trimming of punctuation from hashtags and search terms (#3178) * Improved trimming of punctuation from hashtags and search terms * Separated punctuation regexes used for hashtags and for search terms 2016-06-01 16:05:36 -04:00			`"#Mötley;": "#Mötley",`
			`".#period.": "#period",`
			`"¿#upside¿": "#upside",`
			`"\"#quote\"": "#quote",`
			`"/#slash/": "#slash",`
			`"\\#backslash\\": "#backslash",`
			`"#a": "",`
			`"#1": "",`
			`"foo#bar": "",`
Add hashtag testing and allow special german characters 2015-12-11 13:03:14 -05:00			`}`

			`func TestParseHashtags(t *testing.T) {`
			`for input, output := range hashtags {`
			`if o, _ := ParseHashtags(input); o != output {`
PLT-2283 Improved trimming of punctuation from hashtags and search terms (#3178) * Improved trimming of punctuation from hashtags and search terms * Separated punctuation regexes used for hashtags and for search terms 2016-06-01 16:05:36 -04:00			`t.Fatal("failed to parse hashtags from input=" + input + " expected=" + output + " actual=" + o)`
Add hashtag testing and allow special german characters 2015-12-11 13:03:14 -05:00			`}`
			`}`
			`}`
APIv4 DELETE /users/{user_id}/posts/{post_id}/reactions/name (#6117) * APIv4 DELETE /users/{user_id}/posts/{post_id}/reactions/name * updated v3 deleteReaction endpoint * update parameter of app.DeleteReactionForPost() * update utils.IsValidAlphaNum, add utils.IsValidAlphaNumHyphenUnderscore, and add related tests 2017-04-22 21:52:03 +09:00
			`func TestIsValidAlphaNum(t *testing.T) {`
			`cases := []struct {`
			`Input string`
			`Result bool`
			`}{`
			`{`
			`Input: "test",`
			`Result: true,`
			`},`
			`{`
			`Input: "test-name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test--name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test__name",`
			`Result: true,`
			`},`
			`{`
			`Input: "-",`
			`Result: false,`
			`},`
			`{`
			`Input: "__",`
			`Result: false,`
			`},`
			`{`
			`Input: "test-",`
			`Result: false,`
			`},`
			`{`
			`Input: "test--",`
			`Result: false,`
			`},`
			`{`
			`Input: "test__",`
			`Result: false,`
			`},`
			`{`
			`Input: "test:name",`
			`Result: false,`
			`},`
			`}`

			`for _, tc := range cases {`
			`actual := IsValidAlphaNum(tc.Input)`
			`if actual != tc.Result {`
			`t.Fatalf("case: %v\tshould returned: %#v", tc, tc.Result)`
			`}`
			`}`
			`}`

PLT-6080 moving clustering to memberlist (#6499) * PLT-6080 adding cluster discovery service * Adding memberlist lib * Adding memberlist lib * WIP * WIP * WIP * WIP * Rolling back config changes * Fixing make file * Fixing config for cluster * WIP * Fixing system console for clustering * Fixing default config * Fixing config * Fixing system console for clustering * Tweaking hub setting * Bumping up time * merging vendor dir * Updating vendor dir * Fixing unit test * Fixing bad merge * Remove some testing code * Moving comment * PLT-6868 adding db ping retry * Removing unused loc strings * Adding defer to cancel 2017-06-19 08:44:04 -07:00			`func TestGetServerIpAddress(t *testing.T) {`
			`if len(GetServerIpAddress()) == 0 {`
			`t.Fatal("Should find local ip address")`
			`}`
			`}`

APIv4 DELETE /users/{user_id}/posts/{post_id}/reactions/name (#6117) * APIv4 DELETE /users/{user_id}/posts/{post_id}/reactions/name * updated v3 deleteReaction endpoint * update parameter of app.DeleteReactionForPost() * update utils.IsValidAlphaNum, add utils.IsValidAlphaNumHyphenUnderscore, and add related tests 2017-04-22 21:52:03 +09:00			`func TestIsValidAlphaNumHyphenUnderscore(t *testing.T) {`
			`casesWithFormat := []struct {`
			`Input string`
			`Result bool`
			`}{`
			`{`
			`Input: "test",`
			`Result: true,`
			`},`
			`{`
			`Input: "test-name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test--name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test__name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test_name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test_-name",`
			`Result: true,`
			`},`
			`{`
			`Input: "-",`
			`Result: false,`
			`},`
			`{`
			`Input: "__",`
			`Result: false,`
			`},`
			`{`
			`Input: "test-",`
			`Result: false,`
			`},`
			`{`
			`Input: "test--",`
			`Result: false,`
			`},`
			`{`
			`Input: "test__",`
			`Result: false,`
			`},`
			`{`
			`Input: "test:name",`
			`Result: false,`
			`},`
			`}`

			`for _, tc := range casesWithFormat {`
			`actual := IsValidAlphaNumHyphenUnderscore(tc.Input, true)`
			`if actual != tc.Result {`
			`t.Fatalf("case: %v\tshould returned: %#v", tc, tc.Result)`
			`}`
			`}`

			`casesWithoutFormat := []struct {`
			`Input string`
			`Result bool`
			`}{`
			`{`
			`Input: "test",`
			`Result: true,`
			`},`
			`{`
			`Input: "test-name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test--name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test__name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test_name",`
			`Result: true,`
			`},`
			`{`
			`Input: "test_-name",`
			`Result: true,`
			`},`
			`{`
			`Input: "-",`
			`Result: true,`
			`},`
			`{`
			`Input: "_",`
			`Result: true,`
			`},`
			`{`
			`Input: "test-",`
			`Result: true,`
			`},`
			`{`
			`Input: "test--",`
			`Result: true,`
			`},`
			`{`
			`Input: "test__",`
			`Result: true,`
			`},`
			`{`
			`Input: ".",`
			`Result: false,`
			`},`

			`{`
			`Input: "test,",`
			`Result: false,`
			`},`
			`{`
			`Input: "test:name",`
			`Result: false,`
			`},`
			`}`

			`for _, tc := range casesWithoutFormat {`
			`actual := IsValidAlphaNumHyphenUnderscore(tc.Input, false)`
			`if actual != tc.Result {`
			`t.Fatalf("case: '%v'\tshould returned: %#v", tc.Input, tc.Result)`
			`}`
			`}`
			`}`
Add some checking of channel ID before sending websocket event (#7431) 2017-09-15 06:56:08 -04:00
			`func TestIsValidId(t *testing.T) {`
			`cases := []struct {`
			`Input string`
			`Result bool`
			`}{`
			`{`
			`Input: NewId(),`
			`Result: true,`
			`},`
			`{`
			`Input: "",`
			`Result: false,`
			`},`
			`{`
			`Input: "junk",`
			`Result: false,`
			`},`
			`{`
			`Input: "qwertyuiop1234567890asdfg{",`
			`Result: false,`
			`},`
			`{`
			`Input: NewId() + "}",`
			`Result: false,`
			`},`
			`}`

			`for _, tc := range cases {`
			`actual := IsValidId(tc.Input)`
			`if actual != tc.Result {`
			`t.Fatalf("case: %v\tshould returned: %#v", tc, tc.Result)`
			`}`
			`}`
			`}`
MM-9977: test config.SetDefaults leaves nothing nil (#8610) * MM-9977: test config.SetDefaults leaves nothing nil * clarify test default config test cases * comment re: allowing nil slice * extend config SetDefaults to handle partially initialized configs 2018-04-13 10:56:09 -04:00
			`func TestNowhereNil(t *testing.T) {`
			`t.Parallel()`

			`var nilStringPtr *string`
			`var nonNilStringPtr *string = new(string)`
			`var nilSlice []string`
			`var nilStruct *struct{}`
			`var nilMap map[bool]bool`

			`var nowhereNilStruct = struct {`
			`X *string`
			`Y *string`
			`}{`
			`nonNilStringPtr,`
			`nonNilStringPtr,`
			`}`
			`var somewhereNilStruct = struct {`
			`X *string`
			`Y *string`
			`}{`
			`nonNilStringPtr,`
			`nilStringPtr,`
			`}`

			`var privateSomewhereNilStruct = struct {`
			`X *string`
			`y *string`
			`}{`
			`nonNilStringPtr,`
			`nilStringPtr,`
			`}`

			`testCases := []struct {`
			`Description string`
			`Value interface{}`
			`Expected bool`
			`}{`
			`{`
			`"nil",`
			`nil,`
			`false,`
			`},`
			`{`
			`"empty string",`
			`"",`
			`true,`
			`},`
			`{`
			`"non-empty string",`
			`"not empty!",`
			`true,`
			`},`
			`{`
			`"nil string pointer",`
			`nilStringPtr,`
			`false,`
			`},`
			`{`
			`"non-nil string pointer",`
			`nonNilStringPtr,`
			`true,`
			`},`
			`{`
			`"0",`
			`0,`
			`true,`
			`},`
			`{`
			`"1",`
			`1,`
			`true,`
			`},`
			`{`
			`"0 (int64)",`
			`int64(0),`
			`true,`
			`},`
			`{`
			`"1 (int64)",`
			`int64(1),`
			`true,`
			`},`
			`{`
			`"true",`
			`true,`
			`true,`
			`},`
			`{`
			`"false",`
			`false,`
			`true,`
			`},`
			`{`
			`"nil slice",`
			`nilSlice,`
			`// A nil slice is observably the same as an empty slice, so allow it.`
			`true,`
			`},`
			`{`
			`"empty slice",`
			`[]string{},`
			`true,`
			`},`
			`{`
			`"slice containing nils",`
			`[]*string{nil, nil},`
			`true,`
			`},`
			`{`
			`"nil map",`
			`nilMap,`
			`false,`
			`},`
			`{`
			`"non-nil map",`
			`make(map[bool]bool),`
			`true,`
			`},`
			`{`
			`"non-nil map containing nil",`
			`map[bool]*string{true: nilStringPtr, false: nonNilStringPtr},`
			`// Map values are not checked`
			`true,`
			`},`
			`{`
			`"nil struct",`
			`nilStruct,`
			`false,`
			`},`
			`{`
			`"empty struct",`
			`struct{}{},`
			`true,`
			`},`
			`{`
			`"struct containing no nil",`
			`nowhereNilStruct,`
			`true,`
			`},`
			`{`
			`"struct containing nil",`
			`somewhereNilStruct,`
			`false,`
			`},`
			`{`
			`"struct pointer containing no nil",`
			`&nowhereNilStruct,`
			`true,`
			`},`
			`{`
			`"struct pointer containing nil",`
			`&somewhereNilStruct,`
			`false,`
			`},`
			`{`
			`"struct containing private nil",`
			`privateSomewhereNilStruct,`
			`true,`
			`},`
			`{`
			`"struct pointer containing private nil",`
			`&privateSomewhereNilStruct,`
			`true,`
			`},`
			`}`

			`for _, testCase := range testCases {`
			`testCase := testCase`
			`t.Run(testCase.Description, func(t *testing.T) {`
			`defer func() {`
			`if r := recover(); r != nil {`
			`t.Errorf("panic: %v", r)`
			`}`
			`}()`

			`t.Parallel()`
			`require.Equal(t, testCase.Expected, checkNowhereNil(t, "value", testCase.Value))`
			`})`
			`}`
			`}`