src/foundation/api/revel/testing/testsuite_test.go

   1 // Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
   2 // Revel Framework source code and usage is governed by a MIT style
   3 // license that can be found in the LICENSE file.
   4
   5 package testing
   6
   7 import (
   8         "bytes"
   9         "fmt"
  10         "net/http"
  11         "net/http/httptest"
  12         "net/url"
  13         "os"
  14         "path/filepath"
  15         "strings"
  16         "testing"
  17         "time"
  18
  19         "github.com/revel/revel"
  20         "github.com/revel/revel/session"
  21 )
  22
  23 func TestMisc(t *testing.T) {
  24         testSuite := createNewTestSuite(t)
  25
  26         // test Host value
  27         if !strings.EqualFold("127.0.0.1:9001", testSuite.Host()) {
  28                 t.Error("Incorrect Host value found.")
  29         }
  30
  31         // test BaseUrl
  32         if !strings.EqualFold("http://127.0.0.1:9001", testSuite.BaseUrl()) {
  33                 t.Error("Incorrect BaseUrl http value found.")
  34         }
  35         revel.HTTPSsl = true
  36         if !strings.EqualFold("https://127.0.0.1:9001", testSuite.BaseUrl()) {
  37                 t.Error("Incorrect BaseUrl https value found.")
  38         }
  39         revel.HTTPSsl = false
  40
  41         // test WebSocketUrl
  42         if !strings.EqualFold("ws://127.0.0.1:9001", testSuite.WebSocketUrl()) {
  43                 t.Error("Incorrect WebSocketUrl value found.")
  44         }
  45
  46         testSuite.AssertNotEqual("Yes", "No")
  47         testSuite.Assert(true)
  48 }
  49
  50 func TestGet(t *testing.T) {
  51         ts := createTestServer(testHandle)
  52         defer ts.Close()
  53
  54         testSuite := createNewTestSuite(t)
  55
  56         testSuite.Get("/")
  57         testSuite.AssertOk()
  58         testSuite.AssertContains("this is testcase homepage")
  59         testSuite.AssertNotContains("not exists")
  60 }
  61
  62 func TestGetNotFound(t *testing.T) {
  63         ts := createTestServer(testHandle)
  64         defer ts.Close()
  65
  66         testSuite := createNewTestSuite(t)
  67
  68         testSuite.Get("/notfound")
  69         testSuite.AssertNotFound()
  70         // testSuite.AssertContains("this is testcase homepage")
  71         // testSuite.AssertNotContains("not exists")
  72 }
  73
  74 // This test is known to fail
  75 func TestGetCustom(t *testing.T) {
  76         testSuite := createNewTestSuite(t)
  77         for x := 0; x < 5; x++ {
  78                 testSuite.GetCustom("http://httpbin.org/get").Send()
  79                 if testSuite.Response.StatusCode == http.StatusOK {
  80                         break
  81                 }
  82                 println("Failed request from http://httpbin.org/get", testSuite.Response.StatusCode)
  83         }
  84
  85         testSuite.AssertOk()
  86         testSuite.AssertContentType("application/json")
  87         testSuite.AssertContains("httpbin.org")
  88         testSuite.AssertContainsRegex("gzip|deflate")
  89 }
  90
  91 func TestDelete(t *testing.T) {
  92         ts := createTestServer(testHandle)
  93         defer ts.Close()
  94
  95         testSuite := createNewTestSuite(t)
  96
  97         testSuite.Delete("/purchases/10001")
  98         testSuite.AssertOk()
  99 }
 100
 101 func TestPut(t *testing.T) {
 102         ts := createTestServer(testHandle)
 103         defer ts.Close()
 104
 105         testSuite := createNewTestSuite(t)
 106
 107         testSuite.Put("/purchases/10002",
 108                 "application/json",
 109                 bytes.NewReader([]byte(`{"sku":"163645GHT", "desc":"This is test product"}`)),
 110         )
 111         testSuite.AssertStatus(http.StatusNoContent)
 112 }
 113
 114 func TestPutForm(t *testing.T) {
 115         ts := createTestServer(testHandle)
 116         defer ts.Close()
 117
 118         testSuite := createNewTestSuite(t)
 119
 120         data := url.Values{}
 121         data.Add("name", "beacon1name")
 122         data.Add("value", "beacon1value")
 123
 124         testSuite.PutForm("/send", data)
 125         testSuite.AssertStatus(http.StatusNoContent)
 126 }
 127
 128 func TestPatch(t *testing.T) {
 129         ts := createTestServer(testHandle)
 130         defer ts.Close()
 131
 132         testSuite := createNewTestSuite(t)
 133
 134         testSuite.Patch("/purchases/10003",
 135                 "application/json",
 136                 bytes.NewReader([]byte(`{"desc": "This is test patch for product"}`)),
 137         )
 138         testSuite.AssertStatus(http.StatusNoContent)
 139 }
 140
 141 func TestPost(t *testing.T) {
 142         ts := createTestServer(testHandle)
 143         defer ts.Close()
 144
 145         testSuite := createNewTestSuite(t)
 146
 147         testSuite.Post("/login",
 148                 "application/json",
 149                 bytes.NewReader([]byte(`{"username":"testuser", "password":"testpass"}`)),
 150         )
 151         testSuite.AssertOk()
 152         testSuite.AssertContains("login successful")
 153 }
 154
 155 func TestPostForm(t *testing.T) {
 156         ts := createTestServer(testHandle)
 157         defer ts.Close()
 158
 159         testSuite := createNewTestSuite(t)
 160
 161         data := url.Values{}
 162         data.Add("username", "testuser")
 163         data.Add("password", "testpassword")
 164
 165         testSuite.PostForm("/login", data)
 166         testSuite.AssertOk()
 167         testSuite.AssertContains("login successful")
 168 }
 169
 170 func TestPostFileUpload(t *testing.T) {
 171         ts := createTestServer(testHandle)
 172         defer ts.Close()
 173
 174         testSuite := createNewTestSuite(t)
 175
 176         params := url.Values{}
 177         params.Add("first_name", "Jeevanandam")
 178         params.Add("last_name", "M.")
 179
 180         currentDir, _ := os.Getwd()
 181         basePath := filepath.Dir(currentDir)
 182
 183         filePaths := url.Values{}
 184         filePaths.Add("revel_file", filepath.Join(basePath, "revel.go"))
 185         filePaths.Add("server_file", filepath.Join(basePath, "server.go"))
 186         filePaths.Add("readme_file", filepath.Join(basePath, "README.md"))
 187
 188         testSuite.PostFile("/upload", params, filePaths)
 189
 190         testSuite.AssertOk()
 191         testSuite.AssertContains("File: revel.go")
 192         testSuite.AssertContains("File: server.go")
 193         testSuite.AssertNotContains("File: not_exists.go")
 194         testSuite.AssertEqual("text/plain; charset=utf-8", testSuite.Response.Header.Get("Content-Type"))
 195
 196 }
 197
 198 func createNewTestSuite(t *testing.T) *TestSuite {
 199         suite := NewTestSuite()
 200
 201         if suite.Client == nil || suite.SessionEngine == nil {
 202                 t.Error("Unable to create a testsuite")
 203         }
 204
 205         return &suite
 206 }
 207
 208 func testHandle(w http.ResponseWriter, r *http.Request) {
 209         if r.Method == "GET" {
 210                 if r.URL.Path == "/" {
 211                         _, _ = w.Write([]byte(`this is testcase homepage`))
 212                         return
 213                 }
 214         }
 215
 216         if r.Method == "POST" {
 217                 if r.URL.Path == "/login" {
 218                         http.SetCookie(w, &http.Cookie{
 219                                 Name:     session.SessionCookieSuffix,
 220                                 Value:    "This is simple session value",
 221                                 Path:     "/",
 222                                 HttpOnly: true,
 223                                 Secure:   false,
 224                                 Expires:  time.Now().Add(time.Minute * 5).UTC(),
 225                         })
 226
 227                         w.Header().Set("Content-Type", "application/json")
 228                         _, _ = w.Write([]byte(`{ "id": "success", "message": "login successful" }`))
 229                         return
 230                 }
 231
 232                 handleFileUpload(w, r)
 233                 return
 234         }
 235
 236         if r.Method == "DELETE" {
 237                 if r.URL.Path == "/purchases/10001" {
 238                         w.WriteHeader(http.StatusOK)
 239                         return
 240                 }
 241         }
 242
 243         if r.Method == "PUT" {
 244                 if r.URL.Path == "/purchases/10002" {
 245                         w.WriteHeader(http.StatusNoContent)
 246                         return
 247                 }
 248
 249                 if r.URL.Path == "/send" {
 250                         w.WriteHeader(http.StatusNoContent)
 251                         return
 252                 }
 253         }
 254
 255         if r.Method == "PATCH" {
 256                 if r.URL.Path == "/purchases/10003" {
 257                         w.WriteHeader(http.StatusNoContent)
 258                         return
 259                 }
 260         }
 261
 262         w.WriteHeader(http.StatusNotFound)
 263 }
 264
 265 func handleFileUpload(w http.ResponseWriter, r *http.Request) {
 266         if r.URL.Path == "/upload" {
 267                 _ = r.ParseMultipartForm(10e6)
 268                 var buf bytes.Buffer
 269                 for _, fhdrs := range r.MultipartForm.File {
 270                         for _, hdr := range fhdrs {
 271                                 dotPos := strings.LastIndex(hdr.Filename, ".")
 272                                 fname := fmt.Sprintf("%s-%v%s", hdr.Filename[:dotPos], time.Now().Unix(), hdr.Filename[dotPos:])
 273                                 _, _ = buf.WriteString(fmt.Sprintf(
 274                                         "Firstname: %v\nLastname: %v\nFile: %v\nHeader: %v\nUploaded as: %v\n",
 275                                         r.FormValue("first_name"),
 276                                         r.FormValue("last_name"),
 277                                         hdr.Filename,
 278                                         hdr.Header,
 279                                         fname))
 280                         }
 281                 }
 282
 283                 _, _ = w.Write(buf.Bytes())
 284
 285                 return
 286         }
 287 }
 288
 289 func createTestServer(fn func(w http.ResponseWriter, r *http.Request)) *httptest.Server {
 290         testServer := httptest.NewServer(http.HandlerFunc(fn))
 291         revel.ServerEngineInit.Address = testServer.URL[7:]
 292         return testServer
 293 }
 294
 295 func init() {
 296         if revel.ServerEngineInit == nil {
 297                 revel.ServerEngineInit = &revel.EngineInit{
 298                         Address: ":9001",
 299                         Network: "http",
 300                         Port:    9001,
 301                 }
 302         }
 303 }