manual_testing.go 4.29 KB
Newer Older
1
// Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
=Corey Hulen's avatar
=Corey Hulen committed
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
// See License.txt for license information.

package manualtesting

import (
	l4g "code.google.com/p/log4go"
	"github.com/mattermost/platform/api"
	"github.com/mattermost/platform/model"
	"github.com/mattermost/platform/utils"
	"hash/fnv"
	"math/rand"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

type TestEnviroment struct {
	Params        map[string][]string
	Client        *model.Client
	CreatedTeamId string
	CreatedUserId string
	Context       *api.Context
	Writer        http.ResponseWriter
	Request       *http.Request
}

func InitManualTesting() {
	api.Srv.Router.Handle("/manualtest", api.AppHandler(manualTest)).Methods("GET")
}

func manualTest(c *api.Context, w http.ResponseWriter, r *http.Request) {
	// Let the world know
	l4g.Info("Setting up for manual test...")

	// URL Parameters
	params, err := url.ParseQuery(r.URL.RawQuery)
	if err != nil {
		c.Err = model.NewAppError("/manual", "Unable to parse URL", "")
		return
	}

	// Grab a uuid (if available) to seed the random number generator so we don't get conflicts.
	uid, ok := params["uid"]
	if ok {
		hasher := fnv.New32a()
		hasher.Write([]byte(uid[0] + strconv.Itoa(int(time.Now().UTC().UnixNano()))))
		hash := hasher.Sum32()
		rand.Seed(int64(hash))
	} else {
		l4g.Debug("No uid in url")
	}

	// Create a client for tests to use
56
	client := model.NewClient("http://localhost" + utils.Cfg.ServiceSettings.ListenAddress)
=Corey Hulen's avatar
=Corey Hulen committed
57 58 59

	// Check for username parameter and create a user if present
	username, ok1 := params["username"]
60
	teamDisplayName, ok2 := params["teamname"]
=Corey Hulen's avatar
=Corey Hulen committed
61 62 63 64 65 66
	var teamID string
	var userID string
	if ok1 && ok2 {
		l4g.Info("Creating user and team")
		// Create team for testing
		team := &model.Team{
67
			DisplayName: teamDisplayName[0],
68
			Name:        utils.RandomName(utils.Range{20, 20}, utils.LOWERCASE),
69 70
			Email:       utils.RandomEmail(utils.Range{20, 20}, utils.LOWERCASE),
			Type:        model.TEAM_OPEN,
=Corey Hulen's avatar
=Corey Hulen committed
71 72 73 74 75 76 77 78 79 80
		}

		if result := <-api.Srv.Store.Team().Save(team); result.Err != nil {
			c.Err = result.Err
			return
		} else {

			createdTeam := result.Data.(*model.Team)

			channel := &model.Channel{DisplayName: "Town Square", Name: "town-square", Type: model.CHANNEL_OPEN, TeamId: createdTeam.Id}
81
			if _, err := api.CreateChannel(c, channel, false); err != nil {
=Corey Hulen's avatar
=Corey Hulen committed
82 83 84 85 86 87 88 89 90 91 92
				c.Err = err
				return
			}

			teamID = createdTeam.Id
		}

		// Create user for testing
		user := &model.User{
			TeamId:   teamID,
			Email:    utils.RandomEmail(utils.Range{20, 20}, utils.LOWERCASE),
93
			Nickname: username[0],
=Corey Hulen's avatar
=Corey Hulen committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
			Password: api.USER_PASSWORD}

		result, err := client.CreateUser(user, "")
		if err != nil {
			c.Err = err
			return
		}
		api.Srv.Store.User().VerifyEmail(result.Data.(*model.User).Id)
		newuser := result.Data.(*model.User)
		userID = newuser.Id

		// Login as user to generate auth token
		_, err = client.LoginById(newuser.Id, api.USER_PASSWORD)
		if err != nil {
			c.Err = err
			return
		}

		// Respond with an auth token this can be overriden by a specific test as required
		sessionCookie := &http.Cookie{
=Corey Hulen's avatar
=Corey Hulen committed
114
			Name:     model.SESSION_COOKIE_TOKEN,
=Corey Hulen's avatar
=Corey Hulen committed
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
			Value:    client.AuthToken,
			Path:     "/",
			MaxAge:   model.SESSION_TIME_WEB_IN_SECS,
			HttpOnly: true,
		}
		http.SetCookie(w, sessionCookie)
		http.Redirect(w, r, "/channels/town-square", http.StatusTemporaryRedirect)
	}

	// Setup test enviroment
	env := TestEnviroment{
		Params:        params,
		Client:        client,
		CreatedTeamId: teamID,
		CreatedUserId: userID,
		Context:       c,
		Writer:        w,
		Request:       r,
	}

	// Grab the test ID and pick the test
	testname, ok := params["test"]
	var err2 *model.AppError
	switch testname[0] {
	case "autolink":
		err2 = testAutoLink(env)
		// ADD YOUR NEW TEST HERE!
	case "general":
		err2 = nil
	}

	if err != nil {
		c.Err = err2
		return
	}
}

func getChannelID(channelname string, teamid string, userid string) (id string, err bool) {
	// Grab all the channels
	result := <-api.Srv.Store.Channel().GetChannels(teamid, userid)
	if result.Err != nil {
		l4g.Debug("Unable to get channels")
		return "", false
	}

	data := result.Data.(*model.ChannelList)

	for _, channel := range data.Channels {
		if channel.Name == channelname {
			return channel.Id, true
		}
	}
	l4g.Debug("Could not find channel: " + channelname + ", " + strconv.Itoa(len(data.Channels)) + " possibilites searched")
	return "", false
}