)
342 | func (c *Context) SetCookie(name string, value string, others ...interface{}) {
343 | cookie := http.Cookie{}
344 | cookie.Name = name
345 | cookie.Value = url.QueryEscape(value)
346 |
347 | if len(others) > 0 {
348 | switch v := others[0].(type) {
349 | case int:
350 | cookie.MaxAge = v
351 | case int64:
352 | cookie.MaxAge = int(v)
353 | case int32:
354 | cookie.MaxAge = int(v)
355 | }
356 | }
357 |
358 | cookie.Path = "/"
359 | if len(others) > 1 {
360 | if v, ok := others[1].(string); ok && len(v) > 0 {
361 | cookie.Path = v
362 | }
363 | }
364 |
365 | if len(others) > 2 {
366 | if v, ok := others[2].(string); ok && len(v) > 0 {
367 | cookie.Domain = v
368 | }
369 | }
370 |
371 | if len(others) > 3 {
372 | switch v := others[3].(type) {
373 | case bool:
374 | cookie.Secure = v
375 | default:
376 | if others[3] != nil {
377 | cookie.Secure = true
378 | }
379 | }
380 | }
381 |
382 | if len(others) > 4 {
383 | if v, ok := others[4].(bool); ok && v {
384 | cookie.HttpOnly = true
385 | }
386 | }
387 |
388 | c.Resp.Header().Add("Set-Cookie", cookie.String())
389 | }
390 |
391 | // GetCookie returns given cookie value from request header.
392 | func (c *Context) GetCookie(name string) string {
393 | cookie, err := c.Req.Cookie(name)
394 | if err != nil {
395 | return ""
396 | }
397 | v, _ := url.QueryUnescape(cookie.Value)
398 | return v
399 | }
400 |
401 | // GetCookieInt returns cookie result in int type.
402 | func (c *Context) GetCookieInt(name string) int {
403 | v, _ := strconv.Atoi(c.GetCookie(name))
404 | return v
405 | }
406 |
407 | // GetCookieInt32 returns cookie result in int32 type.
408 | func (c *Context) GetCookieInt32(name string) int32 {
409 | return int32(c.GetCookieInt64(name))
410 | }
411 |
412 | // GetCookieInt64 returns cookie result in int64 type.
413 | func (c *Context) GetCookieInt64(name string) int64 {
414 | v, _ := strconv.ParseInt(c.GetCookie(name), 10, 64)
415 | return v
416 | }
417 |
418 | // GetCookieFloat64 returns cookie result in float64 type.
419 | func (c *Context) GetCookieFloat64(name string) float64 {
420 | v, _ := strconv.ParseFloat(c.GetCookie(name), 64)
421 | return v
422 | }
423 |
424 | // GetCookieBool returns cookie result in float64 type.
425 | func (c *Context) GetCookieBool(name string) bool {
426 | v, _ := strconv.ParseBool(c.GetCookie(name))
427 | return v
428 | }
429 |
430 | // String write text by string
431 | func (c *Context) String(code int, s string) {
432 | c.Resp.Header().Set("Content-Type", TextPlainCharsetUTF8)
433 | c.Resp.WriteHeader(code)
434 | c.Resp.Write([]byte(s))
435 | }
436 |
437 | // Text write text by []byte
438 | func (c *Context) Text(code int, s []byte) {
439 | c.Resp.Header().Set("Content-Type", TextHTMLCharsetUTF8)
440 | c.Resp.WriteHeader(code)
441 | c.Resp.Write(s)
442 | }
443 |
444 | // JSON write data by json format
445 | func (c *Context) JSON(code int, v interface{}) {
446 | var re []byte
447 | var err error
448 | if c.baa.debug {
449 | re, err = json.MarshalIndent(v, "", " ")
450 | } else {
451 | re, err = json.Marshal(v)
452 | }
453 | if err != nil {
454 | c.Error(err)
455 | return
456 | }
457 |
458 | c.Resp.Header().Set("Content-Type", ApplicationJSONCharsetUTF8)
459 | c.Resp.WriteHeader(code)
460 | c.Resp.Write(re)
461 | }
462 |
463 | // JSONString return string by Marshal interface
464 | func (c *Context) JSONString(v interface{}) (string, error) {
465 | var re []byte
466 | var err error
467 | if c.baa.debug {
468 | re, err = json.MarshalIndent(v, "", " ")
469 | } else {
470 | re, err = json.Marshal(v)
471 | }
472 | if err != nil {
473 | return "", err
474 | }
475 | return string(re), nil
476 | }
477 |
478 | // JSONP write data by jsonp format
479 | func (c *Context) JSONP(code int, callback string, v interface{}) {
480 | re, err := json.Marshal(v)
481 | if err != nil {
482 | c.Error(err)
483 | return
484 | }
485 |
486 | c.Resp.Header().Set("Content-Type", ApplicationJavaScriptCharsetUTF8)
487 | c.Resp.WriteHeader(code)
488 | c.Resp.Write([]byte(callback + "("))
489 | c.Resp.Write(re)
490 | c.Resp.Write([]byte(");"))
491 | }
492 |
493 | // XML sends an XML response with status code.
494 | func (c *Context) XML(code int, v interface{}) {
495 | var re []byte
496 | var err error
497 | if c.baa.debug {
498 | re, err = xml.MarshalIndent(v, "", " ")
499 | } else {
500 | re, err = xml.Marshal(v)
501 | }
502 | if err != nil {
503 | c.Error(err)
504 | return
505 | }
506 |
507 | c.Resp.Header().Set("Content-Type", ApplicationXMLCharsetUTF8)
508 | c.Resp.WriteHeader(code)
509 | c.Resp.Write([]byte(xml.Header))
510 | c.Resp.Write(re)
511 | }
512 |
513 | // HTML write render data by html template engine use context.store
514 | // it is a alias of c.Render
515 | func (c *Context) HTML(code int, tpl string) {
516 | c.Render(code, tpl)
517 | }
518 |
519 | // Render write render data by html template engine use context.store
520 | func (c *Context) Render(code int, tpl string) {
521 | re, err := c.Fetch(tpl)
522 | if err != nil {
523 | c.Error(err)
524 | return
525 | }
526 | c.Resp.Header().Set("Content-Type", TextHTMLCharsetUTF8)
527 | c.Resp.WriteHeader(code)
528 | c.Resp.Write(re)
529 | }
530 |
531 | // Fetch render data by html template engine use context.store and returns data
532 | func (c *Context) Fetch(tpl string) ([]byte, error) {
533 | buf := new(bytes.Buffer)
534 |
535 | if err := c.baa.Render().Render(buf, tpl, c.Gets()); err != nil {
536 | return nil, err
537 | }
538 |
539 | // clear go template generated black lines
540 | nbuf := new(bytes.Buffer)
541 | r := bufio.NewReader(buf)
542 | for {
543 | line, _, err := r.ReadLine()
544 | if err != nil {
545 | break
546 | }
547 | clearLine := strings.TrimSpace(string(line))
548 | if len(clearLine) == 0 {
549 | continue
550 | }
551 | nbuf.Write(line)
552 | nbuf.WriteRune('\n')
553 | }
554 |
555 | return nbuf.Bytes(), nil
556 | }
557 |
558 | // Redirect redirects the request using http.Redirect with status code.
559 | func (c *Context) Redirect(code int, url string) error {
560 | if code < http.StatusMultipleChoices || code > http.StatusTemporaryRedirect {
561 | return fmt.Errorf("invalid redirect status code")
562 | }
563 | http.Redirect(c.Resp, c.Req, url, code)
564 | return nil
565 | }
566 |
567 | // RemoteAddr returns more real IP address.
568 | func (c *Context) RemoteAddr() string {
569 | var addr string
570 | key := "__ctx_remoteAddr"
571 | if addr, ok := c.Get(key).(string); ok {
572 | return addr
573 | }
574 |
575 | for _, k := range []string{"X-Forwarded-For", "Ali-Cdn-Real-Ip", "X-Real-IP"} {
576 | if addr = c.Req.Header.Get(k); addr != "" {
577 | if strings.Contains(addr, ",") {
578 | addrs := strings.Split(addr, ",")
579 | addr = addrs[0]
580 | }
581 | break
582 | }
583 | }
584 |
585 | if addr == "" {
586 | addr = c.Req.RemoteAddr
587 | addr, _, _ = net.SplitHostPort(addr)
588 | }
589 |
590 | c.Set(key, addr)
591 | return addr
592 | }
593 |
594 | // Referer returns http request Referer
595 | func (c *Context) Referer() string {
596 | return c.Req.Header.Get("Referer")
597 | }
598 |
599 | // UserAgent returns http request UserAgent
600 | func (c *Context) UserAgent() string {
601 | return c.Req.Header.Get("User-Agent")
602 | }
603 |
604 | // URL returns http request full url
605 | func (c *Context) URL(hasQuery bool) string {
606 | scheme := c.Req.URL.Scheme
607 | host := c.Req.URL.Host
608 | if scheme == "" {
609 | if c.Req.TLS != nil {
610 | scheme = "https"
611 | } else {
612 | scheme = "http"
613 | }
614 | }
615 | if host == "" {
616 | host = c.Req.Host
617 | }
618 | if len(host) > 0 {
619 | if host[0] == ':' {
620 | //
621 | } else if host[0] == '/' {
622 | scheme += ":"
623 | } else {
624 | scheme += "://"
625 | }
626 | } else {
627 | scheme = ""
628 | }
629 | if hasQuery {
630 | url := c.Req.RequestURI
631 | if url == "" {
632 | url = c.Req.URL.Path
633 | if len(c.Req.URL.RawQuery) > 0 {
634 | url += "?" + c.Req.URL.RawQuery
635 | }
636 | }
637 | return scheme + host + url
638 | }
639 | return scheme + host + c.Req.URL.Path
640 | }
641 |
642 | // IsMobile returns if it is a mobile phone device request
643 | func (c *Context) IsMobile() bool {
644 | userAgent := c.UserAgent()
645 | for _, v := range []string{"iPhone", "iPod", "Android"} {
646 | if strings.Contains(userAgent, v) {
647 | return true
648 | }
649 | }
650 | return false
651 | }
652 |
653 | // IsAJAX returns if it is a ajax request
654 | func (c *Context) IsAJAX() bool {
655 | return c.Req.Header.Get("X-Requested-With") == "XMLHttpRequest"
656 | }
657 |
658 | // ParseForm parses a request body as multipart/form-data or
659 | // parses the raw query from the URL and updates r.Form.
660 | func (c *Context) ParseForm(maxSize int64) error {
661 | if c.Req.Form != nil {
662 | return nil
663 | }
664 | contentType := c.Req.Header.Get("Content-Type")
665 | if (c.Req.Method == "POST" || c.Req.Method == "PUT") &&
666 | len(contentType) > 0 && strings.Contains(contentType, MultipartForm) {
667 | if maxSize == 0 {
668 | maxSize = defaultMaxMemory
669 | }
670 | return c.Req.ParseMultipartForm(maxSize)
671 | }
672 | return c.Req.ParseForm()
673 | }
674 |
675 | // Next execute next handler
676 | // handle middleware first, last execute route handler
677 | // if something wrote to http, break chain and return
678 | func (c *Context) Next() {
679 | if c.hi >= len(c.handlers) {
680 | return
681 | }
682 | if c.Resp.Wrote() {
683 | if c.baa.Debug() {
684 | c.baa.Logger().Println("Warning: content has been written, handle chain break.")
685 | }
686 | return
687 | }
688 | i := c.hi
689 | c.hi++
690 | if c.handlers[i] != nil {
691 | c.handlers[i](c)
692 | } else {
693 | c.Next()
694 | }
695 | }
696 |
697 | // Break break the handles chain and Immediate return
698 | func (c *Context) Break() {
699 | c.hi = len(c.handlers)
700 | }
701 |
702 | // Error invokes the registered HTTP error handler.
703 | func (c *Context) Error(err error) {
704 | c.baa.Error(err, c)
705 | }
706 |
707 | // NotFound invokes the registered HTTP NotFound handler.
708 | func (c *Context) NotFound() {
709 | c.baa.NotFound(c)
710 | }
711 |
712 | // Baa get app instance
713 | func (c *Context) Baa() *Baa {
714 | return c.baa
715 | }
716 |
717 | // DI get registered dependency injection service
718 | func (c *Context) DI(name string) interface{} {
719 | return c.baa.GetDI(name)
720 | }
721 |
722 | /**
723 | implement for context.Context
724 | */
725 |
726 | // Deadline returns that there is no deadline (ok==false) when c.Req has no Context.
727 | func (c *Context) Deadline() (deadline time.Time, ok bool) {
728 | if c.Req == nil || c.Req.Context() == nil {
729 | return
730 | }
731 | return c.Req.Context().Deadline()
732 | }
733 |
734 | // Done returns nil (chan which will wait forever) when c.Req has no Context.
735 | func (c *Context) Done() <-chan struct{} {
736 | if c.Req == nil || c.Req.Context() == nil {
737 | return nil
738 | }
739 | return c.Req.Context().Done()
740 | }
741 |
742 | // Err returns nil when c.Req has no Context.
743 | func (c *Context) Err() error {
744 | if c.Req == nil || c.Req.Context() == nil {
745 | return nil
746 | }
747 | return c.Req.Context().Err()
748 | }
749 |
750 | // Value returns the value associated with this context for key, or nil
751 | // if no value is associated with key. Successive calls to Value with
752 | // the same key returns the same result.
753 | func (c *Context) Value(key interface{}) interface{} {
754 | if key == 0 {
755 | return c.Req
756 | }
757 | if keyAsString, ok := key.(string); ok {
758 | if val := c.Get(keyAsString); val != nil {
759 | return val
760 | }
761 | }
762 | if c.Req == nil || c.Req.Context() == nil {
763 | return nil
764 | }
765 | return c.Req.Context().Value(key)
766 | }
767 |
--------------------------------------------------------------------------------
/context_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "bytes"
5 | "context"
6 | "encoding/json"
7 | "encoding/xml"
8 | "fmt"
9 | "io"
10 | "mime/multipart"
11 | "net/http"
12 | "net/http/httptest"
13 | "net/url"
14 | "os"
15 | "path/filepath"
16 | "strings"
17 | "testing"
18 |
19 | . "github.com/smartystreets/goconvey/convey"
20 | )
21 |
22 | var _ context.Context = &Context{}
23 |
24 | func TestContextStore(t *testing.T) {
25 | Convey("context store", t, func() {
26 | b.Get("/context", func(c *Context) {
27 | c.Get("name")
28 | c.Gets()
29 | c.Set("name", "Baa")
30 | c.Get("name")
31 | c.Gets()
32 | })
33 |
34 | w := request("GET", "/context")
35 | So(w.Code, ShouldEqual, http.StatusOK)
36 | })
37 | }
38 |
39 | func TestContextParam(t *testing.T) {
40 | Convey("context route param", t, func() {
41 | Convey("param", func() {
42 | b.Get("/context/p1/:id", func(c *Context) {
43 | id := c.Param("id")
44 | So(id, ShouldEqual, "123")
45 | })
46 |
47 | w := request("GET", "/context/p1/123")
48 | So(w.Code, ShouldEqual, http.StatusOK)
49 | })
50 |
51 | Convey("param int", func() {
52 | b.Get("/context/p2/:id", func(c *Context) {
53 | id := c.ParamInt("id")
54 | So(id, ShouldEqual, 123)
55 | })
56 |
57 | w := request("GET", "/context/p2/123")
58 | So(w.Code, ShouldEqual, http.StatusOK)
59 | })
60 |
61 | Convey("param int32", func() {
62 | b.Get("/context/p3/:id", func(c *Context) {
63 | id := c.ParamInt32("id")
64 | So(id, ShouldEqual, 123)
65 | })
66 |
67 | w := request("GET", "/context/p3/123")
68 | So(w.Code, ShouldEqual, http.StatusOK)
69 | })
70 |
71 | Convey("param int64", func() {
72 | b.Get("/context/p4/:id", func(c *Context) {
73 | id := c.ParamInt64("id")
74 | So(id, ShouldEqual, 123)
75 | })
76 |
77 | w := request("GET", "/context/p4/123")
78 | So(w.Code, ShouldEqual, http.StatusOK)
79 | })
80 |
81 | Convey("param float", func() {
82 | b.Get("/context/p5/:id", func(c *Context) {
83 | id := c.ParamFloat("id")
84 | So(id, ShouldEqual, 123.4)
85 | })
86 |
87 | w := request("GET", "/context/p5/123.4")
88 | So(w.Code, ShouldEqual, http.StatusOK)
89 | })
90 |
91 | Convey("param bool", func() {
92 | b.Get("/context/p6/:id", func(c *Context) {
93 | id := c.ParamBool("id")
94 | So(id, ShouldEqual, true)
95 | })
96 |
97 | w := request("GET", "/context/p6/1")
98 | So(w.Code, ShouldEqual, http.StatusOK)
99 | })
100 | })
101 | }
102 |
103 | func TestContextQuery(t *testing.T) {
104 | Convey("context query param", t, func() {
105 | Convey("query string param", func() {
106 | b.Get("/context/1/:id", func(c *Context) {
107 | id := c.Query("p")
108 | So(id, ShouldEqual, "123")
109 | })
110 |
111 | w := request("GET", "/context/1/1?p=123")
112 | So(w.Code, ShouldEqual, http.StatusOK)
113 | })
114 |
115 | Convey("form string param", func() {
116 | b.Post("/context/2/:id", func(c *Context) {
117 | id := c.Query("p")
118 | So(id, ShouldEqual, "123")
119 | })
120 | data := url.Values{}
121 | data.Add("p", "123")
122 | req, _ := http.NewRequest("POST", "/context/2/1", strings.NewReader(data.Encode()))
123 | req.Header.Set("Content-Type", ApplicationForm)
124 | w := httptest.NewRecorder()
125 | b.ServeHTTP(w, req)
126 | So(w.Code, ShouldEqual, http.StatusOK)
127 | })
128 |
129 | Convey("type param", func() {
130 | b.Post("/context/3/:id", func(c *Context) {
131 | var p interface{}
132 | p = c.QueryInt("int")
133 | So(p, ShouldEqual, 123)
134 |
135 | p = c.QueryInt32("int32")
136 | So(p, ShouldEqual, 123)
137 |
138 | p = c.QueryInt64("int64")
139 | So(p, ShouldEqual, 123)
140 |
141 | p = c.QueryFloat("float")
142 | So(p, ShouldEqual, 123.4)
143 |
144 | p = c.QueryBool("bool")
145 | So(p, ShouldEqual, true)
146 |
147 | p = c.QueryBool("bool2")
148 | So(p, ShouldEqual, false)
149 |
150 | p = c.QueryTrim("trim")
151 | So(p, ShouldEqual, "abc")
152 |
153 | p = c.QueryStrings("strings")
154 | So(fmt.Sprintf("%s", p.([]string)), ShouldEqual, "[abc1 abc2]")
155 |
156 | p = c.QueryStrings("strings2")
157 | So(fmt.Sprintf("%s", p.([]string)), ShouldEqual, "[]")
158 |
159 | p = c.QueryEscape("escape")
160 | So(p, ShouldEqual, "<a href>string</a>")
161 | })
162 | data := url.Values{}
163 | data.Add("int", "123")
164 | data.Add("int32", "123")
165 | data.Add("int64", "123")
166 | data.Add("float", "123.4")
167 | data.Add("bool", "1")
168 | data.Add("bool2", "0")
169 | data.Add("trim", "abc ")
170 | data.Add("strings", "abc1")
171 | data.Add("strings", "abc2")
172 | data.Add("escape", "string")
173 | req, _ := http.NewRequest("POST", "/context/3/1", strings.NewReader(data.Encode()))
174 | req.Header.Set("Content-Type", ApplicationForm)
175 | w := httptest.NewRecorder()
176 | b.ServeHTTP(w, req)
177 | So(w.Code, ShouldEqual, http.StatusOK)
178 | })
179 |
180 | Convey("querys/gets, not contains form data", func() {
181 | b.Post("/context/4/:id", func(c *Context) {
182 | querys := c.Querys()
183 | So(querys, ShouldNotBeNil)
184 | p := querys["a"].(string)
185 | So(p, ShouldEqual, "1")
186 | p = querys["b"].(string)
187 | So(p, ShouldEqual, "1")
188 | ps := querys["d"].([]string)
189 | So(fmt.Sprintf("%s", ps), ShouldEqual, "[1 2]")
190 | })
191 | data := url.Values{}
192 | data.Add("a", "2")
193 | data.Add("b", "2")
194 | data.Add("d", "2")
195 | req, _ := http.NewRequest("POST", "/context/4/1?a=1&b=1&d=1&d=2", strings.NewReader(data.Encode()))
196 | req.Header.Set("Content-Type", ApplicationForm)
197 | w := httptest.NewRecorder()
198 | b.ServeHTTP(w, req)
199 | So(w.Code, ShouldEqual, http.StatusOK)
200 | })
201 |
202 | Convey("posts, not contains get params", func() {
203 | b.Post("/contextp/:id", func(c *Context) {
204 | querys := c.Posts()
205 | So(querys, ShouldNotBeNil)
206 | p := querys["a"].(string)
207 | So(p, ShouldEqual, "2")
208 | p = querys["b"].(string)
209 | So(p, ShouldEqual, "2")
210 | ps := querys["d"].([]string)
211 | So(fmt.Sprintf("%s", ps), ShouldEqual, "[2 3]")
212 | })
213 | data := url.Values{}
214 | data.Add("a", "2")
215 | data.Add("b", "2")
216 | data.Add("d", "2")
217 | data.Add("d", "3")
218 | req, _ := http.NewRequest("POST", "/contextp/1?a=1&b=1&d=1", strings.NewReader(data.Encode()))
219 | req.Header.Set("Content-Type", ApplicationForm)
220 | w := httptest.NewRecorder()
221 | b.ServeHTTP(w, req)
222 | So(w.Code, ShouldEqual, http.StatusOK)
223 | })
224 |
225 | Convey("body json param", func() {
226 | dataSource := map[string]interface{}{"test": "json"}
227 | b.Post("/context/json", func(c *Context) {
228 | var dataFromBody map[string]interface{}
229 | c.QueryJSON(&dataFromBody)
230 | So(dataFromBody["test"], ShouldEqual, dataSource["test"])
231 | })
232 | body, _ := json.Marshal(dataSource)
233 | req, _ := http.NewRequest("POST", "/context/json", bytes.NewReader(body))
234 | req.Header.Set("Content-Type", ApplicationJSON)
235 | w := httptest.NewRecorder()
236 | b.ServeHTTP(w, req)
237 | So(w.Code, ShouldEqual, http.StatusOK)
238 | })
239 |
240 | Convey("body json param nil", func() {
241 | dataSource := map[string]interface{}{"test": "json"}
242 | b.Post("/context/json2", func(c *Context) {
243 | var dataFromBody interface{}
244 | c.QueryJSON(dataFromBody)
245 | So(dataFromBody, ShouldBeNil)
246 | })
247 | body, _ := json.Marshal(dataSource)
248 | req, _ := http.NewRequest("POST", "/context/json2", bytes.NewReader(body))
249 | req.Header.Set("Content-Type", ApplicationJSON)
250 | w := httptest.NewRecorder()
251 | b.ServeHTTP(w, req)
252 | So(w.Code, ShouldEqual, http.StatusOK)
253 | })
254 |
255 | Convey("body json param diffrent struct", func() {
256 | dataSource := map[string]interface{}{"test": "json"}
257 | b.Post("/context/json3", func(c *Context) {
258 | var dataFromBody struct {
259 | Test string
260 | }
261 | c.QueryJSON(&dataFromBody)
262 | So(dataFromBody.Test, ShouldEqual, dataSource["test"])
263 | })
264 | body, _ := json.Marshal(dataSource)
265 | req, _ := http.NewRequest("POST", "/context/json3", bytes.NewReader(body))
266 | req.Header.Set("Content-Type", ApplicationJSON)
267 | w := httptest.NewRecorder()
268 | b.ServeHTTP(w, req)
269 | So(w.Code, ShouldEqual, http.StatusOK)
270 | })
271 |
272 | Convey("body json param is empty", func() {
273 | b.Post("/context/json/empty", func(c *Context) {
274 | var dataFromBody map[string]interface{}
275 | err := c.QueryJSON(&dataFromBody)
276 | So(err, ShouldBeError, ErrJSONPayloadEmpty)
277 | })
278 | req, _ := http.NewRequest("POST", "/context/json/empty", strings.NewReader(""))
279 | req.Header.Set("Content-Type", ApplicationJSON)
280 | w := httptest.NewRecorder()
281 | b.ServeHTTP(w, req)
282 | So(w.Code, ShouldEqual, http.StatusOK)
283 | })
284 |
285 | Convey("body xml param", func() {
286 | type XML struct {
287 | Test string `xml:"test"`
288 | }
289 | dataSource := XML{Test: "xml"}
290 | b.Post("/context/xml", func(c *Context) {
291 | var dataFromBody XML
292 | c.QueryXML(&dataFromBody)
293 | So(dataFromBody.Test, ShouldEqual, dataSource.Test)
294 | })
295 | body, _ := xml.Marshal(dataSource)
296 | req, _ := http.NewRequest("POST", "/context/xml", bytes.NewReader(body))
297 | req.Header.Set("Content-Type", ApplicationXML)
298 | w := httptest.NewRecorder()
299 | b.ServeHTTP(w, req)
300 | So(w.Code, ShouldEqual, http.StatusOK)
301 | })
302 |
303 | Convey("body xml param is empty", func() {
304 | b.Post("/context/xml/empty", func(c *Context) {
305 | var dataFromBody map[string]interface{}
306 | err := c.QueryXML(&dataFromBody)
307 | So(err, ShouldBeError, ErrXMLPayloadEmpty)
308 | })
309 | req, _ := http.NewRequest("POST", "/context/xml/empty", strings.NewReader(""))
310 | req.Header.Set("Content-Type", ApplicationXML)
311 | w := httptest.NewRecorder()
312 | b.ServeHTTP(w, req)
313 | So(w.Code, ShouldEqual, http.StatusOK)
314 | })
315 | })
316 | }
317 |
318 | func TestContextFile(t *testing.T) {
319 | Convey("context file", t, func() {
320 | b.Post("/file", func(c *Context) {
321 | c.Posts()
322 | c.GetFile("file1")
323 | c.SaveToFile("file1", "/tmp/baa.jpg")
324 | c.SaveToFile("file1", "/tmpx/baa.jpg")
325 | c.SaveToFile("file2", "/tmpx/baa.jpg")
326 | })
327 | data := make(map[string]string)
328 | data["a"] = "1"
329 | req, _ := newfileUploadRequest("/file", data, "file1", "./_fixture/img/baa.jpg")
330 | w := httptest.NewRecorder()
331 | b.ServeHTTP(w, req)
332 | So(w.Code, ShouldEqual, http.StatusOK)
333 | })
334 | }
335 |
336 | func TestContextCookie(t *testing.T) {
337 | Convey("context cookie", t, func() {
338 | Convey("cookie get", func() {
339 | b.Get("/cookie/get", func(c *Context) {
340 | var p interface{}
341 | p = c.GetCookie("s")
342 | So(p, ShouldEqual, "123")
343 | p = c.GetCookieInt("int")
344 | So(p, ShouldEqual, 123)
345 | p = c.GetCookieInt32("int32")
346 | So(p, ShouldEqual, 123)
347 | p = c.GetCookieInt64("int64")
348 | So(p, ShouldEqual, 123)
349 | p = c.GetCookieFloat64("float")
350 | So(p, ShouldEqual, 123.4)
351 | p = c.GetCookieBool("bool")
352 | So(p, ShouldEqual, true)
353 | p = c.GetCookieBool("bool2")
354 | So(p, ShouldEqual, false)
355 | p = c.GetCookie("not")
356 | So(p, ShouldEqual, "")
357 | })
358 | req, _ := http.NewRequest("GET", "/cookie/get", nil)
359 | req.Header.Set("Cookie", "s=123; int=123; int32=123; int64=123; float=123.4; bool=1; boo2=0;")
360 | w := httptest.NewRecorder()
361 | b.ServeHTTP(w, req)
362 |
363 | So(w.Code, ShouldEqual, http.StatusOK)
364 | })
365 | Convey("cookie set", func() {
366 | b.Get("/cookie/set", func(c *Context) {
367 | c.SetCookie("name", "baa")
368 | c.SetCookie("name", "baa", 10)
369 | c.SetCookie("name", "baa", int32(10))
370 | c.SetCookie("name", "baa", int64(10))
371 | c.SetCookie("name", "baa", 10, "/")
372 | c.SetCookie("name", "baa", 10, "/", "localhost")
373 | c.SetCookie("name", "baa", 10, "/", "localhost", "1")
374 | c.SetCookie("name", "baa", 10, "/", "localhost", true, true)
375 | })
376 | w := request("GET", "/cookie/set")
377 | So(w.Code, ShouldEqual, http.StatusOK)
378 | So(w.Header().Get("set-cookie"), ShouldContainSubstring, "name=baa;")
379 | })
380 | })
381 | }
382 |
383 | func TestContextWriter(t *testing.T) {
384 | Convey("context writer", t, func() {
385 | b.SetDebug(true)
386 | Convey("write string", func() {
387 | b.Get("/writer/string", func(c *Context) {
388 | c.String(200, "abc\n")
389 | })
390 | w := request("GET", "/writer/string")
391 | So(w.Code, ShouldEqual, http.StatusOK)
392 | })
393 | Convey("write byte", func() {
394 | b.Get("/writer/byte", func(c *Context) {
395 | c.Text(200, []byte("abc\n"))
396 | })
397 | w := request("GET", "/writer/byte")
398 | So(w.Code, ShouldEqual, http.StatusOK)
399 | })
400 | Convey("write JSON", func() {
401 | b.Get("/writer/json", func(c *Context) {
402 | data := map[string]interface{}{"a": "1"}
403 | c.JSON(200, data)
404 | })
405 | w := request("GET", "/writer/json")
406 | So(w.Code, ShouldEqual, http.StatusOK)
407 | })
408 | Convey("write JSON error", func() {
409 | b.Get("/writer/json/error", func(c *Context) {
410 | data := f
411 | c.JSON(200, data)
412 | })
413 | w := request("GET", "/writer/json/error")
414 | So(w.Code, ShouldEqual, http.StatusInternalServerError)
415 | fmt.Println(w.Body)
416 | })
417 | Convey("write JSONString", func() {
418 | b.Get("/writer/jsonstring", func(c *Context) {
419 | data := map[string]interface{}{"a": "1"}
420 | str, _ := c.JSONString(data)
421 | c.String(200, str)
422 | })
423 | w := request("GET", "/writer/jsonstring")
424 | So(w.Code, ShouldEqual, http.StatusOK)
425 | })
426 | Convey("write JSONString error", func() {
427 | b.Get("/writer/jsonstring/error", func(c *Context) {
428 | data := f
429 | str, _ := c.JSONString(data)
430 | c.String(200, str)
431 | })
432 | w := request("GET", "/writer/jsonstring/error")
433 | So(w.Code, ShouldEqual, http.StatusOK)
434 | fmt.Println(w.Body)
435 | })
436 | Convey("write JSONP", func() {
437 | b.Get("/writer/jsonp", func(c *Context) {
438 | data := map[string]interface{}{"a": "1"}
439 | callback := c.Query("callback")
440 | c.JSONP(200, callback, data)
441 | })
442 | w := request("GET", "/writer/jsonp?callback=callback")
443 | So(w.Code, ShouldEqual, http.StatusOK)
444 | })
445 | Convey("write JSONP error", func() {
446 | b.Get("/writer/jsonp/error", func(c *Context) {
447 | data := f
448 | callback := c.Query("callback")
449 | c.JSONP(200, callback, data)
450 | })
451 | w := request("GET", "/writer/jsonp/error?callback=callback")
452 | So(w.Code, ShouldEqual, http.StatusInternalServerError)
453 | fmt.Println(w.Body)
454 | })
455 | Convey("write XML", func() {
456 | b.Get("/writer/xml", func(c *Context) {
457 | type XMLNode struct {
458 | XMLName xml.Name `xml:"item"`
459 | Name string `xml:"name"`
460 | ID int `xml:"id,attr"`
461 | Addr string `xml:"adr"`
462 | }
463 | data := &XMLNode{Name: "baa", ID: 1, Addr: "beijing"}
464 | c.XML(200, data)
465 | })
466 | w := request("GET", "/writer/xml")
467 | So(w.Code, ShouldEqual, http.StatusOK)
468 | })
469 | Convey("write XML error", func() {
470 | b.Get("/writer/xml/error", func(c *Context) {
471 | data := map[string]interface{}{"name": "123"}
472 | c.XML(200, data)
473 | })
474 | w := request("GET", "/writer/xml/error")
475 | So(w.Code, ShouldEqual, http.StatusInternalServerError)
476 | })
477 | })
478 | }
479 |
480 | func TestContextWrite_WithoutDebug(t *testing.T) {
481 | Convey("context writer without debug mode", t, func() {
482 | b.SetDebug(false)
483 | Convey("write JSON", func() {
484 | w := request("GET", "/writer/json")
485 | So(w.Code, ShouldEqual, http.StatusOK)
486 | })
487 | Convey("write JSONString", func() {
488 | w := request("GET", "/writer/jsonstring")
489 | So(w.Code, ShouldEqual, http.StatusOK)
490 | })
491 | Convey("write JSONP", func() {
492 | w := request("GET", "/writer/jsonp?callback=callback")
493 | So(w.Code, ShouldEqual, http.StatusOK)
494 | })
495 | Convey("write XML", func() {
496 | w := request("GET", "/writer/xml")
497 | So(w.Code, ShouldEqual, http.StatusOK)
498 | })
499 | })
500 | b.SetDebug(true)
501 | }
502 |
503 | func TestConextRedirect(t *testing.T) {
504 | Convey("redirect", t, func() {
505 | Convey("redirect normal", func() {
506 | b.Get("/redirect/1", func(c *Context) {
507 | c.Redirect(301, "/")
508 | })
509 | w := request("GET", "/redirect/1")
510 | So(w.Code, ShouldEqual, http.StatusMovedPermanently)
511 | })
512 | Convey("redirect error", func() {
513 | b.Get("/redirect/2", func(c *Context) {
514 | c.Redirect(500, "/")
515 | })
516 | w := request("GET", "/redirect/2")
517 | So(w.Code, ShouldEqual, http.StatusOK)
518 | })
519 | })
520 | }
521 |
522 | func TestContextIP(t *testing.T) {
523 | Convey("get remote addr", t, func() {
524 | b.Get("/ip", func(c *Context) {
525 | _ = c.RemoteAddr()
526 | _ = c.RemoteAddr()
527 | ip := c.RemoteAddr()
528 | So(ip, ShouldEqual, "10.1.2.1")
529 | })
530 | b.Get("/ip2", func(c *Context) {
531 | ip := c.RemoteAddr()
532 | So(ip, ShouldBeEmpty)
533 | })
534 | req, _ := http.NewRequest("GET", "/ip", nil)
535 | req.Header.Set("X-Forwarded-For", "10.1.2.1, 10.1.2.2")
536 | w := httptest.NewRecorder()
537 | b.ServeHTTP(w, req)
538 | So(w.Code, ShouldEqual, http.StatusOK)
539 |
540 | req, _ = http.NewRequest("GET", "/ip2", nil)
541 | w = httptest.NewRecorder()
542 | b.ServeHTTP(w, req)
543 | So(w.Code, ShouldEqual, http.StatusOK)
544 | })
545 | }
546 |
547 | func TestContextUnits(t *testing.T) {
548 | Convey("request methods", t, func() {
549 | Convey("Referer, UserAgent, IsMobile", func() {
550 | b.Get("/req", func(c *Context) {
551 | c.Referer()
552 | c.UserAgent()
553 | isMobile := c.IsMobile()
554 | So(isMobile, ShouldBeTrue)
555 | })
556 | req, _ := http.NewRequest("GET", "/req", nil)
557 | req.Header.Set("User-Agent", "Mozilla/5.0 (iPod; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1")
558 | w := httptest.NewRecorder()
559 | b.ServeHTTP(w, req)
560 | So(w.Code, ShouldEqual, http.StatusOK)
561 | })
562 | Convey("IsMobile false", func() {
563 | b.Get("/req2", func(c *Context) {
564 | isMobile := c.IsMobile()
565 | So(isMobile, ShouldBeFalse)
566 | })
567 | req, _ := http.NewRequest("GET", "/req2", nil)
568 | req.Header.Set("User-Agent", "Mozilla/5.0 Version/9.0 Mobile/13B143 Safari/601.1")
569 | w := httptest.NewRecorder()
570 | b.ServeHTTP(w, req)
571 | So(w.Code, ShouldEqual, http.StatusOK)
572 | })
573 | Convey("IsAJAX", func() {
574 | b.Get("/req/ajax", func(c *Context) {
575 | isAJAX := c.IsAJAX()
576 | So(isAJAX, ShouldBeTrue)
577 | })
578 | req, _ := http.NewRequest("GET", "/req/ajax", nil)
579 | req.Header.Set("X-Requested-With", "XMLHttpRequest")
580 | w := httptest.NewRecorder()
581 | b.ServeHTTP(w, req)
582 | So(w.Code, ShouldEqual, http.StatusOK)
583 | })
584 | Convey("Get URL", func() {
585 | b.Get("/url", func(c *Context) {
586 | So(c.URL(false), ShouldEqual, "/url")
587 | So(c.URL(true), ShouldEqual, "/url?id=xx&ib=yy")
588 | })
589 | w := request("GET", "/url?id=xx&ib=yy")
590 | So(w.Code, ShouldEqual, http.StatusOK)
591 | })
592 | Convey("occur error", func() {
593 | b.Get("/error2", func(c *Context) {
594 | c.Error(nil)
595 | })
596 | b.Get("/notfound3", func(c *Context) {
597 | c.NotFound()
598 | })
599 | w := request("GET", "/error2")
600 | So(w.Code, ShouldEqual, http.StatusInternalServerError)
601 | w = request("GET", "/notfound3")
602 | So(w.Code, ShouldEqual, http.StatusNotFound)
603 | })
604 | })
605 | }
606 |
607 | func TestContextContext(t *testing.T) {
608 | Convey("context cancel", t, func() {
609 | c.Req, _ = http.NewRequest("GET", "/context", nil)
610 | ctx, cancel := context.WithCancel(c)
611 | cancel()
612 | ctx.Done()
613 | So(ctx.Err(), ShouldEqual, context.Canceled)
614 | })
615 | }
616 |
617 | func TestContextBaa(t *testing.T) {
618 | Convey("get baa", t, func() {
619 | Convey("get baa", func() {
620 | So(c.Baa(), ShouldNotBeNil)
621 | })
622 | Convey("get di", func() {
623 | logger := c.DI("logger")
624 | _, ok := logger.(Logger)
625 | So(ok, ShouldBeTrue)
626 | })
627 | })
628 | }
629 |
630 | // newfileUploadRequest Creates a new file upload http request with optional extra params
631 | func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (*http.Request, error) {
632 | file, err := os.Open(path)
633 | if err != nil {
634 | return nil, err
635 | }
636 | defer file.Close()
637 |
638 | body := &bytes.Buffer{}
639 | writer := multipart.NewWriter(body)
640 | part, err := writer.CreateFormFile(paramName, filepath.Base(path))
641 | if err != nil {
642 | return nil, err
643 | }
644 | _, _ = io.Copy(part, file)
645 |
646 | for key, val := range params {
647 | _ = writer.WriteField(key, val)
648 | }
649 | err = writer.Close()
650 | if err != nil {
651 | return nil, err
652 | }
653 |
654 | req, err := http.NewRequest("POST", uri, body)
655 | req.Header.Add("Content-Type", writer.FormDataContentType())
656 | return req, err
657 | }
658 |
--------------------------------------------------------------------------------
/di.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "sync"
5 | )
6 |
7 | // DIer is an interface for baa dependency injection
8 | type DIer interface {
9 | Set(name string, v interface{})
10 | Get(name string) interface{}
11 | }
12 |
13 | // DI provlider a dependency injection service for baa
14 | type DI struct {
15 | store map[string]interface{}
16 | mutex sync.RWMutex
17 | }
18 |
19 | // NewDI create a DI instance
20 | func NewDI() DIer {
21 | d := new(DI)
22 | d.store = make(map[string]interface{})
23 | return d
24 | }
25 |
26 | // Set register a di
27 | // baa dependency injection must be the special interface
28 | func (d *DI) Set(name string, v interface{}) {
29 | d.mutex.Lock()
30 | d.store[name] = v
31 | d.mutex.Unlock()
32 | }
33 |
34 | // Get fetch a di by name, return nil when name not set.
35 | func (d *DI) Get(name string) interface{} {
36 | d.mutex.RLock()
37 | v := d.store[name]
38 | d.mutex.RUnlock()
39 | return v
40 | }
41 |
--------------------------------------------------------------------------------
/di_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | . "github.com/smartystreets/goconvey/convey"
5 | "log"
6 | "os"
7 | "testing"
8 | )
9 |
10 | func TestDISetLogger1(t *testing.T) {
11 | Convey("register error logger", t, func() {
12 | defer func() {
13 | e := recover()
14 | So(e, ShouldNotBeNil)
15 | }()
16 | b := New()
17 | b.SetDI("logger", nil)
18 | })
19 | }
20 |
21 | func TestDISetLogger2(t *testing.T) {
22 | Convey("register correct logger", t, func() {
23 | defer func() {
24 | e := recover()
25 | So(e, ShouldBeNil)
26 | }()
27 | b := New()
28 | b.SetDI("logger", log.New(os.Stderr, "BaaTest ", log.LstdFlags))
29 | })
30 | }
31 | func TestDISetRender1(t *testing.T) {
32 | Convey("register error render", t, func() {
33 | defer func() {
34 | e := recover()
35 | So(e, ShouldNotBeNil)
36 | }()
37 | b := New()
38 | b.SetDI("render", nil)
39 | })
40 | }
41 |
42 | func TestDISetRender2(t *testing.T) {
43 | Convey("register correct render", t, func() {
44 | defer func() {
45 | e := recover()
46 | So(e, ShouldBeNil)
47 | }()
48 | b := New()
49 | b.SetDI("render", newRender())
50 | })
51 | }
52 |
53 | func TestDISet1(t *testing.T) {
54 | Convey("register di", t, func() {
55 | b.SetDI("test", "hiDI")
56 | })
57 | }
58 |
59 | func TestDIGet1(t *testing.T) {
60 | Convey("get registerd di", t, func() {
61 | var v interface{}
62 | v = b.GetDI("")
63 | So(v, ShouldBeNil)
64 | v = b.GetDI("test")
65 | So(v, ShouldNotBeNil)
66 | So(v.(string), ShouldEqual, "hiDI")
67 | })
68 | }
69 |
--------------------------------------------------------------------------------
/doc.go:
--------------------------------------------------------------------------------
1 | // Package baa provides an express Go web framework.
2 | //
3 | /*
4 | package main
5 |
6 | import (
7 | "github.com/go-baa/baa"
8 | )
9 |
10 | func main() {
11 | app := baa.New()
12 | app.Get("/", func(c *baa.Context) {
13 | c.String(200, "Hello World!")
14 | })
15 | app.Run(":8001")
16 | }
17 | */
18 | package baa
19 |
--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/go-baa/baa
2 |
3 | go 1.18
4 |
5 | require (
6 | github.com/gorilla/websocket v1.5.0
7 | github.com/smartystreets/goconvey v1.7.2
8 | )
9 |
10 | require (
11 | github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 // indirect
12 | github.com/jtolds/gls v4.20.0+incompatible // indirect
13 | github.com/smartystreets/assertions v1.2.0 // indirect
14 | )
15 |
--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
2 | github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
3 | github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
4 | github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
5 | github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
6 | github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
7 | github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N3yZFZkDFs=
8 | github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
9 | github.com/smartystreets/goconvey v1.7.2 h1:9RBaZCeXEQ3UselpuwUQHltGVXvdwm6cv1hgR6gDIPg=
10 | github.com/smartystreets/goconvey v1.7.2/go.mod h1:Vw0tHAZW6lzCRk3xgdin6fKYcG+G3Pg9vgXWeJpQFMM=
11 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
12 | golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
13 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
14 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
15 | golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
16 |
--------------------------------------------------------------------------------
/logger.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | // Logger provlider a basic log interface for baa
4 | type Logger interface {
5 | Print(v ...interface{})
6 | Printf(format string, v ...interface{})
7 | Println(v ...interface{})
8 | Fatal(v ...interface{})
9 | Fatalf(format string, v ...interface{})
10 | Fatalln(v ...interface{})
11 | Panic(v ...interface{})
12 | Panicf(format string, v ...interface{})
13 | Panicln(v ...interface{})
14 | }
15 |
--------------------------------------------------------------------------------
/logger_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
--------------------------------------------------------------------------------
/render.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "html/template"
5 | "io"
6 | "io/ioutil"
7 | "path/filepath"
8 | )
9 |
10 | // Renderer is the interface that wraps the Render method.
11 | type Renderer interface {
12 | Render(w io.Writer, tpl string, data interface{}) error
13 | }
14 |
15 | // Render default baa template engine
16 | type Render struct {
17 | }
18 |
19 | // Render ...
20 | func (r *Render) Render(w io.Writer, tpl string, data interface{}) error {
21 | t, err := parseFile(tpl)
22 | if err != nil {
23 | return err
24 | }
25 | return t.Execute(w, data)
26 | }
27 |
28 | // parseFile ...
29 | func parseFile(filename string) (*template.Template, error) {
30 | var t *template.Template
31 | b, err := ioutil.ReadFile(filename)
32 | if err != nil {
33 | return nil, err
34 | }
35 | s := string(b)
36 | name := filepath.Base(filename)
37 | t = template.New(name)
38 | _, err = t.Parse(s)
39 | if err != nil {
40 | return nil, err
41 | }
42 | return t, nil
43 | }
44 |
45 | // newRender create a render instance
46 | func newRender() *Render {
47 | r := new(Render)
48 | return r
49 | }
50 |
--------------------------------------------------------------------------------
/render_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 |
8 | . "github.com/smartystreets/goconvey/convey"
9 | )
10 |
11 | func TestRender1(t *testing.T) {
12 | Convey("response method", t, func() {
13 | b.Get("/render", func(c *Context) {
14 | c.Set("name", "Baa")
15 | c.HTML(200, "_fixture/index1.html")
16 | })
17 |
18 | b.Get("/render2", func(c *Context) {
19 | c.Set("name", "Baa")
20 | c.HTML(200, "_fixture/index2.html")
21 | })
22 |
23 | b.Get("/render3", func(c *Context) {
24 | c.Set("name", "Baa")
25 | c.HTML(200, "_fixture/index3.html")
26 | })
27 |
28 | req, _ := http.NewRequest("GET", "/render", nil)
29 | w := httptest.NewRecorder()
30 | b.ServeHTTP(w, req)
31 | So(w.Code, ShouldEqual, http.StatusOK)
32 |
33 | req, _ = http.NewRequest("GET", "/render2", nil)
34 | w = httptest.NewRecorder()
35 | b.ServeHTTP(w, req)
36 | So(w.Code, ShouldEqual, http.StatusInternalServerError)
37 |
38 | req, _ = http.NewRequest("GET", "/render3", nil)
39 | w = httptest.NewRecorder()
40 | b.ServeHTTP(w, req)
41 | So(w.Code, ShouldEqual, http.StatusInternalServerError)
42 | })
43 | }
44 |
--------------------------------------------------------------------------------
/request.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "io"
5 | "io/ioutil"
6 | )
7 |
8 | // RequestBody represents a request body.
9 | type RequestBody struct {
10 | reader io.ReadCloser
11 | }
12 |
13 | // NewRequestBody ...
14 | func NewRequestBody(r io.ReadCloser) *RequestBody {
15 | return &RequestBody{
16 | reader: r,
17 | }
18 | }
19 |
20 | // Bytes reads and returns content of request body in bytes.
21 | func (rb *RequestBody) Bytes() ([]byte, error) {
22 | return ioutil.ReadAll(rb.reader)
23 | }
24 |
25 | // String reads and returns content of request body in string.
26 | func (rb *RequestBody) String() (string, error) {
27 | data, err := rb.Bytes()
28 | return string(data), err
29 | }
30 |
31 | // ReadCloser returns a ReadCloser for request body.
32 | func (rb *RequestBody) ReadCloser() io.ReadCloser {
33 | return rb.reader
34 | }
35 |
--------------------------------------------------------------------------------
/request_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "bytes"
5 | "io/ioutil"
6 | "net/http"
7 | "net/http/httptest"
8 | "testing"
9 |
10 | . "github.com/smartystreets/goconvey/convey"
11 | )
12 |
13 | func TestRequest1(t *testing.T) {
14 | Convey("request body", t, func() {
15 |
16 | b.Get("/body", func(c *Context) {
17 | s, err := c.Body().String()
18 | So(err, ShouldBeNil)
19 | So(s, ShouldEqual, "{}")
20 |
21 | // because one req can only read once
22 | b, err := c.Body().Bytes()
23 | So(err, ShouldBeNil)
24 | So(string(b), ShouldEqual, "")
25 |
26 | r := c.Body().ReadCloser()
27 | b, err = ioutil.ReadAll(r)
28 | So(err, ShouldBeNil)
29 | So(string(b), ShouldEqual, "")
30 | })
31 | body := bytes.NewBuffer(nil)
32 | body.Write([]byte("{}"))
33 | req, _ := http.NewRequest("GET", "/body", body)
34 | w := httptest.NewRecorder()
35 | b.ServeHTTP(w, req)
36 | So(w.Code, ShouldEqual, http.StatusOK)
37 | })
38 | }
39 |
--------------------------------------------------------------------------------
/response.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "bufio"
5 | "errors"
6 | "io"
7 | "net"
8 | "net/http"
9 | )
10 |
11 | // Response implement ResponseWriter
12 | type Response struct {
13 | wroteHeader bool // reply header has been (logically) written
14 | written int64 // number of bytes written in body
15 | status int // status code passed to WriteHeader
16 | resp http.ResponseWriter
17 | writer io.Writer
18 | baa *Baa
19 | }
20 |
21 | // NewResponse ...
22 | func NewResponse(w http.ResponseWriter, b *Baa) *Response {
23 | r := new(Response)
24 | r.resp = w
25 | r.writer = w
26 | r.baa = b
27 | return r
28 | }
29 |
30 | // Header returns the header map that will be sent by
31 | // WriteHeader. Changing the header after a call to
32 | // WriteHeader (or Write) has no effect unless the modified
33 | // headers were declared as trailers by setting the
34 | // "Trailer" header before the call to WriteHeader (see example).
35 | // To suppress implicit response headers, set their value to nil.
36 | func (r *Response) Header() http.Header {
37 | return r.resp.Header()
38 | }
39 |
40 | // Write writes the data to the connection as part of an HTTP reply.
41 | // If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)
42 | // before writing the data. If the Header does not contain a
43 | // Content-Type line, Write adds a Content-Type set to the result of passing
44 | // the initial 512 bytes of written data to DetectContentType.
45 | func (r *Response) Write(b []byte) (int, error) {
46 | if !r.wroteHeader {
47 | r.WriteHeader(http.StatusOK)
48 | }
49 | n, err := r.writer.Write(b)
50 | r.written += int64(n)
51 | return n, err
52 | }
53 |
54 | // WriteHeader sends an HTTP response header with status code.
55 | // If WriteHeader is not called explicitly, the first call to Write
56 | // will trigger an implicit WriteHeader(http.StatusOK).
57 | // Thus explicit calls to WriteHeader are mainly used to
58 | // send error codes.
59 | func (r *Response) WriteHeader(code int) {
60 | if r.wroteHeader {
61 | r.baa.Logger().Println("http: multiple response.WriteHeader calls")
62 | return
63 | }
64 | r.wroteHeader = true
65 | r.status = code
66 | r.resp.WriteHeader(code)
67 | }
68 |
69 | // Flush implements the http.Flusher interface to allow an HTTP handler to flush
70 | // buffered data to the client.
71 | // See [http.Flusher](https://golang.org/pkg/net/http/#Flusher)
72 | func (r *Response) Flush() {
73 | if v, ok := r.resp.(http.Flusher); ok {
74 | v.Flush()
75 | }
76 | }
77 |
78 | // Pusher is the interface implemented by ResponseWriters that support
79 | // HTTP/2 server push. For more background, see
80 | // https://tools.ietf.org/html/rfc7540#section-8.2.
81 | func (r *Response) Pusher() (http.Pusher, bool) {
82 | v, ok := r.resp.(http.Pusher)
83 | return v, ok
84 | }
85 |
86 | // Hijack implements the http.Hijacker interface to allow an HTTP handler to
87 | // take over the connection.
88 | // See [http.Hijacker](https://golang.org/pkg/net/http/#Hijacker)
89 | func (r *Response) Hijack() (net.Conn, *bufio.ReadWriter, error) {
90 | if v, ok := r.resp.(http.Hijacker); ok {
91 | return v.Hijack()
92 | }
93 | return nil, nil, errors.New("http.response denot implements the http.Hijacker")
94 | }
95 |
96 | // reset reuse response
97 | func (r *Response) reset(w http.ResponseWriter) {
98 | r.resp = w
99 | r.writer = w
100 | r.wroteHeader = false
101 | r.written = 0
102 | r.status = http.StatusOK
103 | }
104 |
105 | // Status returns status code
106 | func (r *Response) Status() int {
107 | return r.status
108 | }
109 |
110 | // Size returns body size
111 | func (r *Response) Size() int64 {
112 | return r.written
113 | }
114 |
115 | // Wrote returns if writes something
116 | func (r *Response) Wrote() bool {
117 | return r.wroteHeader
118 | }
119 |
120 | // GetWriter returns response io writer
121 | func (r *Response) GetWriter() io.Writer {
122 | return r.writer
123 | }
124 |
125 | // SetWriter set response io writer
126 | func (r *Response) SetWriter(w io.Writer) {
127 | r.writer = w
128 | }
129 |
--------------------------------------------------------------------------------
/response_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 |
8 | . "github.com/smartystreets/goconvey/convey"
9 | )
10 |
11 | func TestResponse1(t *testing.T) {
12 | Convey("response method", t, func() {
13 |
14 | b.Get("/response", func(c *Context) {
15 | c.Resp.Size()
16 | c.Resp.Write([]byte("1"))
17 | c.Resp.Write([]byte("2"))
18 | c.Resp.WriteHeader(200)
19 | c.Resp.Flush()
20 | c.Resp.Status()
21 |
22 | func() {
23 | defer func() {
24 | e := recover()
25 | So(e, ShouldBeNil)
26 | }()
27 | c.Resp.Hijack()
28 | }()
29 | })
30 | req, _ := http.NewRequest("GET", "/response", nil)
31 | w := httptest.NewRecorder()
32 | b.ServeHTTP(w, req)
33 | So(w.Code, ShouldEqual, http.StatusOK)
34 | })
35 | }
36 |
--------------------------------------------------------------------------------
/router.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | const (
4 | GET int = iota
5 | POST
6 | PUT
7 | DELETE
8 | PATCH
9 | OPTIONS
10 | HEAD
11 | // RouteLength route table length
12 | RouteLength
13 | )
14 |
15 | // RouterMethods declare method key in route table
16 | var RouterMethods = map[string]int{
17 | "GET": GET,
18 | "POST": POST,
19 | "PUT": PUT,
20 | "DELETE": DELETE,
21 | "PATCH": PATCH,
22 | "OPTIONS": OPTIONS,
23 | "HEAD": HEAD,
24 | }
25 |
26 | // RouterMethodName declare method name with route table key
27 | var RouterMethodName = map[int]string{
28 | GET: "GET",
29 | POST: "POST",
30 | PUT: "PUT",
31 | DELETE: "DELETE",
32 | PATCH: "PATCH",
33 | OPTIONS: "OPTIONS",
34 | HEAD: "HEAD",
35 | }
36 |
37 | // Router is an router interface for baa
38 | type Router interface {
39 | // SetAutoHead sets the value who determines whether add HEAD method automatically
40 | // when GET method is added. Combo router will not be affected by this value.
41 | SetAutoHead(v bool)
42 | // SetAutoTrailingSlash optional trailing slash.
43 | SetAutoTrailingSlash(v bool)
44 | // Match find matched route then returns handlers and name
45 | Match(method, uri string, c *Context) ([]HandlerFunc, string)
46 | // URLFor use named route return format url
47 | URLFor(name string, args ...interface{}) string
48 | // Add registers a new handle with the given method, pattern and handlers.
49 | Add(method, pattern string, handlers []HandlerFunc) RouteNode
50 | // GroupAdd registers a list of same prefix route
51 | GroupAdd(pattern string, f func(), handlers []HandlerFunc)
52 | // Routes returns registered route uri in a string slice
53 | Routes() map[string][]string
54 | // NamedRoutes returns named route uri in a string slice
55 | NamedRoutes() map[string]string
56 | }
57 |
58 | // RouteNode is an router node
59 | type RouteNode interface {
60 | Name(name string)
61 | }
62 |
63 | // IsParamChar check the char can used for route params
64 | // a-z->65:90, A-Z->97:122, 0-9->48->57, _->95
65 | func IsParamChar(c byte) bool {
66 | if (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c == 95 {
67 | return true
68 | }
69 | return false
70 | }
71 |
--------------------------------------------------------------------------------
/static.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "fmt"
5 | "html/template"
6 | "net/http"
7 | "net/url"
8 | "os"
9 | )
10 |
11 | // compatible with go net standard indexPage
12 | const indexPage = "/index.html"
13 |
14 | // Static provider static file serve for baa.
15 | type static struct {
16 | handler HandlerFunc
17 | prefix string
18 | dir string
19 | index bool
20 | }
21 |
22 | // newStatic returns a route handler with static file serve
23 | func newStatic(prefix, dir string, index bool, h HandlerFunc) HandlerFunc {
24 | if len(prefix) > 1 && prefix[len(prefix)-1] == '/' {
25 | prefix = prefix[:len(prefix)-1]
26 | }
27 | if len(dir) > 1 && dir[len(dir)-1] == '/' {
28 | dir = dir[:len(dir)-1]
29 | }
30 | s := &static{
31 | dir: dir,
32 | index: index,
33 | prefix: prefix,
34 | handler: h,
35 | }
36 |
37 | return func(c *Context) {
38 | file := c.Param("")
39 | if len(file) > 0 && file[0] == '/' {
40 | file = file[1:]
41 | }
42 | file = s.dir + "/" + file
43 |
44 | if s.handler != nil {
45 | s.handler(c)
46 | }
47 |
48 | // directory index
49 | if f, err := os.Stat(file); err == nil {
50 | if f.IsDir() {
51 | if s.index {
52 | // if no end slash, add slah and redriect
53 | if c.Req.URL.Path[len(c.Req.URL.Path)-1] != '/' {
54 | c.Redirect(302, c.Req.URL.Path+"/")
55 | return
56 | }
57 | listDir(file, s, c)
58 | } else {
59 | // check index
60 | if err := serveFile(file+indexPage, c); err != nil {
61 | c.Resp.WriteHeader(http.StatusForbidden)
62 | }
63 | }
64 | return
65 | }
66 | }
67 |
68 | if len(file) >= len(indexPage) && file[len(file)-len(indexPage):] == indexPage {
69 | if err := serveFile(file, c); err != nil {
70 | c.Error(err)
71 | }
72 | } else {
73 | http.ServeFile(c.Resp, c.Req, file)
74 | }
75 | }
76 | }
77 |
78 | // listDir list given dir files
79 | func listDir(dir string, s *static, c *Context) {
80 | f, err := os.Open(dir)
81 | if err != nil {
82 | c.baa.Error(fmt.Errorf("baa.Static listDir Error: %s", err), c)
83 | }
84 | defer f.Close()
85 | fl, err := f.Readdir(-1)
86 | if err != nil {
87 | c.baa.Error(fmt.Errorf("baa.Static listDir Error: %s", err), c)
88 | }
89 |
90 | dirName := f.Name()
91 | dirName = dirName[len(s.dir):]
92 | c.Resp.Header().Add("Content-Type", "text/html; charset=utf-8")
93 | fmt.Fprintf(c.Resp, "%s
\n", dirName)
94 | fmt.Fprintf(c.Resp, "\n")
95 | var color, name string
96 | for _, v := range fl {
97 | name = v.Name()
98 | color = "#333333"
99 | if v.IsDir() {
100 | name += "/"
101 | color = "#3F89C8"
102 | }
103 | // name may contain '?' or '#', which must be escaped to remain
104 | // part of the URL path, and not indicate the start of a query
105 | // string or fragment.
106 | url := url.URL{Path: name}
107 | fmt.Fprintf(c.Resp, "%s\n", color, url.String(), template.HTMLEscapeString(name))
108 | }
109 | fmt.Fprintf(c.Resp, "\n")
110 | }
111 |
112 | func serveFile(file string, c *Context) error {
113 | f, err := os.Open(file)
114 | if err != nil {
115 | return err
116 | }
117 | defer f.Close()
118 | fs, err := f.Stat()
119 | if err != nil {
120 | return err
121 | }
122 | if fs.IsDir() {
123 | return fmt.Errorf("given path is dir, not file")
124 | }
125 | http.ServeContent(c.Resp, c.Req, f.Name(), fs.ModTime(), f)
126 | return nil
127 | }
128 |
--------------------------------------------------------------------------------
/static_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 |
8 | . "github.com/smartystreets/goconvey/convey"
9 | )
10 |
11 | func TestStaticRoute1(t *testing.T) {
12 | Convey("static serve register", t, func() {
13 | Convey("register without slash", func() {
14 | b.Static("/static", "./_fixture", false, f)
15 | })
16 | Convey("register with slash", func() {
17 | b.Static("/assets/", "./_fixture/", true, f)
18 | })
19 | Convey("register with empty path", func() {
20 | b2 := New()
21 | defer func() {
22 | e := recover()
23 | So(e, ShouldNotBeNil)
24 | }()
25 | b2.Static("", "./_fixture/", true, f)
26 | })
27 | Convey("register with empty dir", func() {
28 | b2 := New()
29 | defer func() {
30 | e := recover()
31 | So(e, ShouldNotBeNil)
32 | }()
33 | b2.Static("/static", "", true, f)
34 | })
35 | })
36 | }
37 |
38 | func TestStaticServe(t *testing.T) {
39 | Convey("static serve request", t, func() {
40 | req, _ := http.NewRequest("GET", "/static", nil)
41 | w := httptest.NewRecorder()
42 | b.ServeHTTP(w, req)
43 | So(w.Code, ShouldEqual, http.StatusForbidden)
44 |
45 | req, _ = http.NewRequest("GET", "/assets/", nil)
46 | w = httptest.NewRecorder()
47 | b.ServeHTTP(w, req)
48 | So(w.Code, ShouldEqual, http.StatusOK)
49 |
50 | req, _ = http.NewRequest("GET", "/assets/img", nil)
51 | w = httptest.NewRecorder()
52 | b.ServeHTTP(w, req)
53 | So(w.Code, ShouldEqual, http.StatusFound)
54 |
55 | req, _ = http.NewRequest("GET", "/static/index1.html", nil)
56 | w = httptest.NewRecorder()
57 | b.ServeHTTP(w, req)
58 | So(w.Code, ShouldEqual, http.StatusOK)
59 |
60 | req, _ = http.NewRequest("GET", "/static/favicon.ico", nil)
61 | w = httptest.NewRecorder()
62 | b.ServeHTTP(w, req)
63 | So(w.Code, ShouldEqual, http.StatusOK)
64 |
65 | req, _ = http.NewRequest("GET", "/static/notfound", nil)
66 | w = httptest.NewRecorder()
67 | b.ServeHTTP(w, req)
68 | So(w.Code, ShouldEqual, http.StatusNotFound)
69 | })
70 | }
71 |
--------------------------------------------------------------------------------
/tree.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "fmt"
5 | "sync"
6 | )
7 |
8 | const (
9 | leafKindStatic uint = iota
10 | leafKindParam
11 | leafKindWide
12 | )
13 |
14 | // Tree provlider router for baa with radix tree
15 | type Tree struct {
16 | autoHead bool
17 | autoTrailingSlash bool
18 | mu sync.RWMutex
19 | groups []*group
20 | nodes [RouteLength]*leaf
21 | baa *Baa
22 | nameNodes map[string]*Node
23 | }
24 |
25 | // Node is struct for named route
26 | type Node struct {
27 | paramNum int
28 | pattern string
29 | format string
30 | name string
31 | root *Tree
32 | }
33 |
34 | // Leaf is a tree node
35 | type leaf struct {
36 | kind uint
37 | pattern string
38 | param string
39 | handlers []HandlerFunc
40 | children []*leaf
41 | childrenNum uint
42 | paramChild *leaf
43 | wideChild *leaf
44 | root *Tree
45 | nameNode *Node
46 | }
47 |
48 | // group route
49 | type group struct {
50 | pattern string
51 | handlers []HandlerFunc
52 | }
53 |
54 | // NewTree create a router instance
55 | func NewTree(b *Baa) Router {
56 | t := new(Tree)
57 | for i := 0; i < len(t.nodes); i++ {
58 | t.nodes[i] = newLeaf("/", nil, t)
59 | }
60 | t.nameNodes = make(map[string]*Node)
61 | t.groups = make([]*group, 0)
62 | t.baa = b
63 | return t
64 | }
65 |
66 | // NewNode create a route node
67 | func NewNode(pattern string, root *Tree) *Node {
68 | return &Node{
69 | pattern: pattern,
70 | root: root,
71 | }
72 | }
73 |
74 | // newLeaf create a tree leaf
75 | func newLeaf(pattern string, handlers []HandlerFunc, root *Tree) *leaf {
76 | l := new(leaf)
77 | l.pattern = pattern
78 | l.handlers = handlers
79 | l.root = root
80 | l.kind = leafKindStatic
81 | l.children = make([]*leaf, 128)
82 | return l
83 | }
84 |
85 | // newGroup create a group router
86 | func newGroup() *group {
87 | g := new(group)
88 | g.handlers = make([]HandlerFunc, 0)
89 | return g
90 | }
91 |
92 | // SetAutoHead sets the value who determines whether add HEAD method automatically
93 | // when GET method is added. Combo router will not be affected by this value.
94 | func (t *Tree) SetAutoHead(v bool) {
95 | t.autoHead = v
96 | }
97 |
98 | // SetAutoTrailingSlash optional trailing slash.
99 | func (t *Tree) SetAutoTrailingSlash(v bool) {
100 | t.autoTrailingSlash = v
101 | }
102 |
103 | // Match find matched route then returns handlers and name
104 | func (t *Tree) Match(method, pattern string, c *Context) ([]HandlerFunc, string) {
105 | var i, l int
106 | var root, nl *leaf
107 | root = t.nodes[RouterMethods[method]]
108 | current := root
109 |
110 | for {
111 | switch current.kind {
112 | case leafKindStatic:
113 | // static route
114 | l = len(current.pattern)
115 | if l > len(pattern) {
116 | break
117 | }
118 | i := l - 1
119 | for ; i >= 0; i-- {
120 | if current.pattern[i] != pattern[i] {
121 | break
122 | }
123 | }
124 | if i >= 0 {
125 | break
126 | }
127 | if len(pattern) == l || current.children[pattern[l]] != nil ||
128 | current.paramChild != nil ||
129 | current.wideChild != nil {
130 | pattern = pattern[l:]
131 | root = current
132 | }
133 | case leafKindParam:
134 | // params route
135 | l = len(pattern)
136 | for i = 0; i < l && pattern[i] != '/'; i++ {
137 | }
138 | if len(pattern[:i]) == 0 {
139 | return nil, "" // param is empty
140 | }
141 | c.SetParam(current.param, pattern[:i])
142 | pattern = pattern[i:]
143 | root = current
144 | case leafKindWide:
145 | // wide route
146 | c.SetParam(current.param, pattern)
147 | pattern = pattern[:0]
148 | default:
149 | }
150 |
151 | if len(pattern) == 0 {
152 | if current.handlers != nil {
153 | if current.nameNode != nil {
154 | return current.handlers, current.nameNode.name
155 | }
156 | return current.handlers, ""
157 | }
158 | if root.paramChild == nil && root.wideChild == nil {
159 | return nil, ""
160 | }
161 | } else {
162 | // children static route
163 | if current == root {
164 | if nl = root.children[pattern[0]]; nl != nil {
165 | current = nl
166 | continue
167 | }
168 | }
169 | }
170 |
171 | // param route
172 | if root.paramChild != nil {
173 | current = root.paramChild
174 | continue
175 | }
176 |
177 | // wide route
178 | if root.wideChild != nil {
179 | current = root.wideChild
180 | continue
181 | }
182 |
183 | break
184 | }
185 |
186 | return nil, ""
187 | }
188 |
189 | // URLFor use named route return format url
190 | func (t *Tree) URLFor(name string, args ...interface{}) string {
191 | if name == "" {
192 | return ""
193 | }
194 | node := t.nameNodes[name]
195 | if node == nil || len(node.format) == 0 {
196 | return ""
197 | }
198 | format := make([]byte, len(node.format))
199 | copy(format, node.format)
200 | for i := node.paramNum + 1; i <= len(args); i++ {
201 | format = append(format, "%v"...)
202 | }
203 | return fmt.Sprintf(string(format), args...)
204 | }
205 |
206 | // Routes returns registered route uri in a string slice
207 | func (t *Tree) Routes() map[string][]string {
208 | routes := make(map[string][]string)
209 | for _, method := range RouterMethodName {
210 | routes[method] = make([]string, 0)
211 | }
212 | for k := range t.nodes {
213 | routes[RouterMethodName[k]] = t.routes(t.nodes[k])
214 | }
215 |
216 | return routes
217 | }
218 |
219 | // routes print the route table
220 | func (t *Tree) routes(l *leaf) []string {
221 | if l == nil {
222 | return nil
223 | }
224 | var data []string
225 | if l.handlers != nil {
226 | data = append(data, l.String())
227 | }
228 | l.children = append(l.children, l.paramChild)
229 | l.children = append(l.children, l.wideChild)
230 | for i := range l.children {
231 | if l.children[i] != nil {
232 | cdata := t.routes(l.children[i])
233 | for i := range cdata {
234 | data = append(data, l.String()+cdata[i])
235 | }
236 | }
237 | }
238 |
239 | return data
240 | }
241 |
242 | // NamedRoutes returns named route uri in a string slice
243 | func (t *Tree) NamedRoutes() map[string]string {
244 | routes := make(map[string]string)
245 | for k, v := range t.nameNodes {
246 | routes[k] = v.pattern
247 | }
248 | return routes
249 | }
250 |
251 | // Add registers a new handle with the given method, pattern and handlers.
252 | // add check training slash option.
253 | func (t *Tree) Add(method, pattern string, handlers []HandlerFunc) RouteNode {
254 | if method == "GET" && t.autoHead {
255 | t.add("HEAD", pattern, handlers)
256 | }
257 | if t.autoTrailingSlash && (len(pattern) > 1 || len(t.groups) > 0) {
258 | var index byte
259 | if len(pattern) > 0 {
260 | index = pattern[len(pattern)-1]
261 | }
262 | if index == '/' {
263 | t.add(method, pattern[:len(pattern)-1], handlers)
264 | } else if index == '*' {
265 | // wideChild not need trail slash
266 | } else {
267 | t.add(method, pattern+"/", handlers)
268 | }
269 | }
270 | return t.add(method, pattern, handlers)
271 | }
272 |
273 | // GroupAdd add a group route has same prefix and handle chain
274 | func (t *Tree) GroupAdd(pattern string, f func(), handlers []HandlerFunc) {
275 | g := newGroup()
276 | g.pattern = pattern
277 | g.handlers = handlers
278 | t.groups = append(t.groups, g)
279 |
280 | f()
281 |
282 | t.groups = t.groups[:len(t.groups)-1]
283 | }
284 |
285 | // add registers a new request handle with the given method, pattern and handlers.
286 | func (t *Tree) add(method, pattern string, handlers []HandlerFunc) RouteNode {
287 | if _, ok := RouterMethods[method]; !ok {
288 | panic("unsupport http method [" + method + "]")
289 | }
290 |
291 | t.mu.Lock()
292 | defer t.mu.Unlock()
293 |
294 | // check group set
295 | if len(t.groups) > 0 {
296 | var gpattern string
297 | var ghandlers []HandlerFunc
298 | for i := range t.groups {
299 | gpattern += t.groups[i].pattern
300 | if len(t.groups[i].handlers) > 0 {
301 | ghandlers = append(ghandlers, t.groups[i].handlers...)
302 | }
303 | }
304 | pattern = gpattern + pattern
305 | ghandlers = append(ghandlers, handlers...)
306 | handlers = ghandlers
307 | }
308 |
309 | // check pattern (for training slash move behind group check)
310 | if pattern == "" {
311 | panic("route pattern can not be emtpy!")
312 | }
313 | if pattern[0] != '/' {
314 | panic("route pattern must begin /")
315 | }
316 |
317 | for i := 0; i < len(handlers); i++ {
318 | handlers[i] = WrapHandlerFunc(handlers[i])
319 | }
320 |
321 | root := t.nodes[RouterMethods[method]]
322 | origPattern := pattern
323 | nameNode := NewNode(origPattern, t)
324 |
325 | // specialy route = /
326 | if len(pattern) == 1 {
327 | root.handlers = handlers
328 | root.nameNode = nameNode
329 | return nameNode
330 | }
331 |
332 | // left trim slash, because root is slash /
333 | pattern = pattern[1:]
334 |
335 | var radix []byte
336 | var param []byte
337 | var i, k int
338 | var tl *leaf
339 | for i = 0; i < len(pattern); i++ {
340 | // wide route
341 | if pattern[i] == '*' {
342 | // clear static route
343 | if len(radix) > 0 {
344 | root = root.insertChild(newLeaf(string(radix), nil, t))
345 | radix = radix[:0]
346 | }
347 | tl = newLeaf("*", handlers, t)
348 | tl.kind = leafKindWide
349 | tl.nameNode = nameNode
350 | root.insertChild(tl)
351 | break
352 | }
353 |
354 | // param route
355 | if pattern[i] == ':' {
356 | // clear static route
357 | if len(radix) > 0 {
358 | root = root.insertChild(newLeaf(string(radix), nil, t))
359 | radix = radix[:0]
360 | }
361 | // set param route
362 | param = param[:0]
363 | k = 0
364 | for i = i + 1; i < len(pattern); i++ {
365 | if pattern[i] == '/' {
366 | i--
367 | break
368 | }
369 | param = append(param, pattern[i])
370 | k++
371 | }
372 | if k == 0 {
373 | panic("route pattern param is empty")
374 | }
375 | // check last character
376 | if i == len(pattern) {
377 | tl = newLeaf(":", handlers, t)
378 | tl.nameNode = nameNode
379 | } else {
380 | tl = newLeaf(":", nil, t)
381 | }
382 | tl.param = string(param[:k])
383 | tl.kind = leafKindParam
384 | root = root.insertChild(tl)
385 | continue
386 | }
387 | radix = append(radix, pattern[i])
388 | }
389 |
390 | // static route
391 | if len(radix) > 0 {
392 | tl = newLeaf(string(radix), handlers, t)
393 | tl.nameNode = nameNode
394 | root.insertChild(tl)
395 | }
396 |
397 | return nameNode
398 | }
399 |
400 | // insertChild insert child into root route, and returns the child route
401 | func (l *leaf) insertChild(node *leaf) *leaf {
402 | // wide route
403 | if node.kind == leafKindWide {
404 | if l.wideChild != nil {
405 | panic("Router Tree.insert error: cannot set two wide route with same prefix!")
406 | }
407 | l.wideChild = node
408 | return node
409 | }
410 |
411 | // param route
412 | if node.kind == leafKindParam {
413 | if l.paramChild == nil {
414 | l.paramChild = node
415 | return l.paramChild
416 | }
417 | if l.paramChild.param != node.param {
418 | panic("Router Tree.insert error cannot use two param [:" + l.paramChild.param + ", :" + node.param + "] with same prefix!")
419 | }
420 | if node.handlers != nil {
421 | if l.paramChild.handlers != nil {
422 | panic("Router Tree.insert error: cannot twice set handler for same route")
423 | }
424 | l.paramChild.handlers = node.handlers
425 | l.paramChild.nameNode = node.nameNode
426 | }
427 | return l.paramChild
428 | }
429 |
430 | // static route
431 | child := l.children[node.pattern[0]]
432 | if child == nil {
433 | // new child
434 | l.children[node.pattern[0]] = node
435 | l.childrenNum++
436 | return node
437 | }
438 |
439 | pos := child.hasPrefixString(node.pattern)
440 | pre := node.pattern[:pos]
441 | if pos == len(child.pattern) {
442 | // same route
443 | if pos == len(node.pattern) {
444 | if node.handlers != nil {
445 | if child.handlers != nil {
446 | panic("Router Tree.insert error: cannot twice set handler for same route")
447 | }
448 | child.handlers = node.handlers
449 | child.nameNode = node.nameNode
450 | }
451 | return child
452 | }
453 |
454 | // child is prefix or node
455 | node.pattern = node.pattern[pos:]
456 | return child.insertChild(node)
457 | }
458 |
459 | newChild := newLeaf(child.pattern[pos:], child.handlers, child.root)
460 | newChild.nameNode = child.nameNode
461 | newChild.children = child.children
462 | newChild.childrenNum = child.childrenNum
463 | newChild.paramChild = child.paramChild
464 | newChild.wideChild = child.wideChild
465 |
466 | // node is prefix of child
467 | if pos == len(node.pattern) {
468 | child.reset(node.pattern, node.handlers)
469 | child.nameNode = node.nameNode
470 | child.children[newChild.pattern[0]] = newChild
471 | child.childrenNum++
472 | return child
473 | }
474 |
475 | // child and node has same prefix
476 | child.reset(pre, nil)
477 | child.children[newChild.pattern[0]] = newChild
478 | child.childrenNum++
479 | node.pattern = node.pattern[pos:]
480 | child.children[node.pattern[0]] = node
481 | child.childrenNum++
482 | return node
483 | }
484 |
485 | // resetPattern reset route pattern and alpha
486 | func (l *leaf) reset(pattern string, handlers []HandlerFunc) {
487 | l.pattern = pattern
488 | l.children = make([]*leaf, 128)
489 | l.childrenNum = 0
490 | l.paramChild = nil
491 | l.wideChild = nil
492 | l.nameNode = nil
493 | l.param = ""
494 | l.handlers = handlers
495 | }
496 |
497 | // hasPrefixString returns the same prefix position, if none return 0
498 | func (l *leaf) hasPrefixString(s string) int {
499 | var i, j int
500 | j = len(l.pattern)
501 | if len(s) < j {
502 | j = len(s)
503 | }
504 | for i = 0; i < j && s[i] == l.pattern[i]; i++ {
505 | }
506 | return i
507 | }
508 |
509 | // String returns pattern of leaf
510 | func (l *leaf) String() string {
511 | s := l.pattern
512 | if l.kind == leafKindParam {
513 | s += l.param
514 | }
515 | return s
516 | }
517 |
518 | // Name set name of route
519 | func (n *Node) Name(name string) {
520 | if name == "" {
521 | return
522 | }
523 | p := 0
524 | f := make([]byte, 0, len(n.pattern))
525 | for i := 0; i < len(n.pattern); i++ {
526 | if n.pattern[i] != ':' {
527 | f = append(f, n.pattern[i])
528 | continue
529 | }
530 | f = append(f, '%')
531 | f = append(f, 'v')
532 | p++
533 | for i = i + 1; i < len(n.pattern); i++ {
534 | if n.pattern[i] == '/' {
535 | i--
536 | break
537 | }
538 | }
539 | }
540 | n.format = string(f)
541 | n.paramNum = p
542 | n.name = name
543 | n.root.nameNodes[name] = n
544 | }
545 |
--------------------------------------------------------------------------------
/tree_test.go:
--------------------------------------------------------------------------------
1 | package baa
2 |
3 | import (
4 | "fmt"
5 | "net/http"
6 | "net/http/httptest"
7 | "testing"
8 |
9 | . "github.com/smartystreets/goconvey/convey"
10 | )
11 |
12 | // print the route map
13 | func (t *Tree) print(prefix string, root *leaf) {
14 | if root == nil {
15 | for m := range t.nodes {
16 | fmt.Println(m)
17 | t.print("", t.nodes[m])
18 | }
19 | return
20 | }
21 | prefix = fmt.Sprintf("%s -> %s", prefix, root.pattern)
22 | fmt.Println(prefix)
23 | root.children = append(root.children, root.paramChild)
24 | root.children = append(root.children, root.wideChild)
25 | for i := range root.children {
26 | if root.children[i] != nil {
27 | t.print(prefix, root.children[i])
28 | }
29 | }
30 | }
31 |
32 | func TestTreeRouteAdd1(t *testing.T) {
33 | Convey("add static route", t, func() {
34 | r.Add("GET", "/", []HandlerFunc{f})
35 | r.Add("GET", "/bcd", []HandlerFunc{f})
36 | r.Add("GET", "/abcd", []HandlerFunc{f})
37 | r.Add("GET", "/abc", []HandlerFunc{f})
38 | r.Add("GET", "/abd", []HandlerFunc{f})
39 | r.Add("GET", "/abcdef", []HandlerFunc{f})
40 | r.Add("GET", "/bcdefg", []HandlerFunc{f})
41 | r.Add("GET", "/abc/123", []HandlerFunc{f})
42 | r.Add("GET", "/abc/234", []HandlerFunc{f})
43 | r.Add("GET", "/abc/125", []HandlerFunc{f})
44 | r.Add("GET", "/abc/235", []HandlerFunc{f})
45 | r.Add("GET", "/cbd/123", []HandlerFunc{f})
46 | r.Add("GET", "/cbd/234", []HandlerFunc{f})
47 | r.Add("GET", "/cbd/345", []HandlerFunc{f})
48 | r.Add("GET", "/cbd/456", []HandlerFunc{f})
49 | r.Add("GET", "/cbd/346", []HandlerFunc{f})
50 | })
51 | }
52 |
53 | func TestTreeRouteAdd2(t *testing.T) {
54 | Convey("add param route", t, func() {
55 | r.Add("GET", "/a/:id/id", []HandlerFunc{f})
56 | r.Add("GET", "/a/:id/name", []HandlerFunc{f})
57 | r.Add("GET", "/a", []HandlerFunc{f})
58 | r.Add("GET", "/a/:id/", []HandlerFunc{f})
59 | r.Add("GET", "/a/", []HandlerFunc{f})
60 | r.Add("GET", "/a/*/xxx", []HandlerFunc{f})
61 | r.Add("GET", "/p/:project/file/:fileName", []HandlerFunc{f})
62 | r.Add("GET", "/cbd/:id", []HandlerFunc{f})
63 |
64 | defer func() {
65 | e := recover()
66 | So(e, ShouldNotBeNil)
67 | }()
68 | r.Add("GET", "/p/:/a", []HandlerFunc{f})
69 | })
70 | }
71 |
72 | func TestTreeRouteAdd3(t *testing.T) {
73 | Convey("add param route with two different param", t, func() {
74 | defer func() {
75 | e := recover()
76 | So(e, ShouldNotBeNil)
77 | }()
78 | r.Add("GET", "/a/:id", []HandlerFunc{f})
79 | r.Add("GET", "/a/:name", []HandlerFunc{f})
80 | })
81 | }
82 |
83 | func TestTreeRouteAdd4(t *testing.T) {
84 | Convey("add route by group", t, func() {
85 | b.Group("/user", func() {
86 | b.Get("/info", f)
87 | b.Get("/info2", f)
88 | b.Group("/group", func() {
89 | b.Get("/info", f)
90 | b.Get("/info2", f)
91 | })
92 | })
93 | b.Group("/user", func() {
94 | b.Get("/", f)
95 | b.Get("/pass", f)
96 | b.Get("/pass2", f)
97 | }, f)
98 | })
99 | }
100 |
101 | func TestTreeRouteAdd5(t *testing.T) {
102 | Convey("add route then set name, URLFor", t, func() {
103 | b.Get("/article/:id/show", f).Name("articleShow")
104 | b.Get("/article/:id/detail", f).Name("")
105 | url := b.URLFor("articleShow", 123)
106 | So(url, ShouldEqual, "/article/123/show")
107 | url = b.URLFor("", nil)
108 | So(url, ShouldEqual, "")
109 | url = b.URLFor("not exits", "no")
110 | So(url, ShouldEqual, "")
111 | ru, name := r.Match("GET", "/article/123/show", c)
112 | So(ru, ShouldNotBeNil)
113 | So(name, ShouldEqual, "articleShow")
114 | })
115 | }
116 |
117 | func TestTreeRouteAdd6(t *testing.T) {
118 | Convey("add route with not support method", t, func() {
119 | defer func() {
120 | e := recover()
121 | So(e, ShouldNotBeNil)
122 | }()
123 | r.Add("TRACE", "/", []HandlerFunc{f})
124 | })
125 | }
126 |
127 | func TestTreeRouteAdd7(t *testing.T) {
128 | Convey("add route with empty pattern", t, func() {
129 | defer func() {
130 | e := recover()
131 | So(e, ShouldNotBeNil)
132 | }()
133 | r.Add("GET", "", []HandlerFunc{f})
134 | })
135 | }
136 |
137 | func TestTreeRouteAdd8(t *testing.T) {
138 | Convey("add route with pattern that not begin with /", t, func() {
139 | defer func() {
140 | e := recover()
141 | So(e, ShouldNotBeNil)
142 | }()
143 | r.Add("GET", "abc", []HandlerFunc{f})
144 | })
145 | }
146 |
147 | func TestTreeRouteAdd9(t *testing.T) {
148 | Convey("other route method", t, func() {
149 | b2 := New()
150 | Convey("set auto head route", func() {
151 | b2.SetAutoHead(true)
152 | b2.Get("/head", func(c *Context) {
153 | So(c.Req.Method, ShouldEqual, "HEAD")
154 | })
155 | req, _ := http.NewRequest("HEAD", "/head", nil)
156 | w := httptest.NewRecorder()
157 | b2.ServeHTTP(w, req)
158 | So(w.Code, ShouldEqual, http.StatusOK)
159 | })
160 | Convey("set auto training slash", func() {
161 | b2.SetAutoTrailingSlash(true)
162 | b2.Get("/slash", func(c *Context) {})
163 | b2.Group("/slash2", func() {
164 | b2.Get("/", func(c *Context) {})
165 | b2.Get("/exist", func(c *Context) {})
166 | })
167 | req, _ := http.NewRequest("GET", "/slash", nil)
168 | w := httptest.NewRecorder()
169 | b2.ServeHTTP(w, req)
170 | So(w.Code, ShouldEqual, http.StatusOK)
171 | req, _ = http.NewRequest("GET", "/slash/", nil)
172 | w = httptest.NewRecorder()
173 | b2.ServeHTTP(w, req)
174 | So(w.Code, ShouldEqual, http.StatusOK)
175 | req, _ = http.NewRequest("GET", "/slash2", nil)
176 | w = httptest.NewRecorder()
177 | b2.ServeHTTP(w, req)
178 | So(w.Code, ShouldEqual, http.StatusOK)
179 | req, _ = http.NewRequest("GET", "/slash2/", nil)
180 | w = httptest.NewRecorder()
181 | b2.ServeHTTP(w, req)
182 | So(w.Code, ShouldEqual, http.StatusOK)
183 | req, _ = http.NewRequest("GET", "/slash2/exist/", nil)
184 | w = httptest.NewRecorder()
185 | b2.ServeHTTP(w, req)
186 | So(w.Code, ShouldEqual, http.StatusOK)
187 | })
188 | Convey("set multi method", func() {
189 | b2.Route("/mul1", "*", func(c *Context) {
190 | c.String(200, "mul")
191 | })
192 | b2.Route("/mul2", "GET,HEAD,POST", func(c *Context) {
193 | c.String(200, "mul")
194 | })
195 | req, _ := http.NewRequest("HEAD", "/mul2", nil)
196 | w := httptest.NewRecorder()
197 | b2.ServeHTTP(w, req)
198 | So(w.Code, ShouldEqual, http.StatusOK)
199 |
200 | req, _ = http.NewRequest("GET", "/mul2", nil)
201 | w = httptest.NewRecorder()
202 | b2.ServeHTTP(w, req)
203 | So(w.Code, ShouldEqual, http.StatusOK)
204 | req, _ = http.NewRequest("POST", "/mul2", nil)
205 | w = httptest.NewRecorder()
206 | b2.ServeHTTP(w, req)
207 | So(w.Code, ShouldEqual, http.StatusOK)
208 | })
209 | Convey("methods", func() {
210 | b2.Get("/methods", f)
211 | b2.Patch("/methods", f)
212 | b2.Post("/methods", f)
213 | b2.Put("/methods", f)
214 | b2.Delete("/methods", f)
215 | b2.Options("/methods", f)
216 | b2.Head("/methods", f)
217 | b2.Any("/any", f)
218 | b2.SetNotFound(func(c *Context) {
219 | c.String(404, "baa not found")
220 | })
221 | })
222 | })
223 | }
224 |
225 | func TestTreeRouteMatch1(t *testing.T) {
226 | Convey("match route", t, func() {
227 |
228 | ru, _ := r.Match("GET", "/", c)
229 | So(ru, ShouldNotBeNil)
230 |
231 | ru, _ = r.Match("GET", "/abc/1234", c)
232 | So(ru, ShouldBeNil)
233 |
234 | ru, _ = r.Match("GET", "xxx", c)
235 | So(ru, ShouldBeNil)
236 |
237 | ru, _ = r.Match("GET", "/a/123/id", c)
238 | So(ru, ShouldNotBeNil)
239 |
240 | ru, _ = r.Match("GET", "/p/yst/file/a.jpg", c)
241 | So(ru, ShouldNotBeNil)
242 |
243 | ru, _ = r.Match("GET", "/user/info", c)
244 | So(ru, ShouldNotBeNil)
245 |
246 | ru, _ = r.Match("GET", "/user/pass", c)
247 | So(ru, ShouldNotBeNil)
248 |
249 | ru, _ = r.Match("GET", "/user/pass32", c)
250 | So(ru, ShouldBeNil)
251 |
252 | ru, _ = r.Match("GET", "/user/xxx", c)
253 | So(ru, ShouldBeNil)
254 |
255 | ru, _ = r.Match("GET", "/xxxx", c)
256 | So(ru, ShouldBeNil)
257 |
258 | b.Get("/notifications/threads/:id", f)
259 | b.Get("/notifications/threads/:id/subscription", f)
260 | b.Get("/notifications/threads/:id/subc", f)
261 | b.Put("/notifications/threads/:id/subscription", f)
262 | b.Delete("/notifications/threads/:id/subscription", f)
263 | ru, _ = r.Match("GET", "/notifications/threads/:id", c)
264 | So(ru, ShouldNotBeNil)
265 | ru, _ = r.Match("GET", "/notifications/threads/:id/sub", c)
266 | So(ru, ShouldBeNil)
267 | })
268 | }
269 |
270 | func TestTreeRouteMatch2(t *testing.T) {
271 | Convey("match route with params", t, func() {
272 | b.Get("/withparams/:id", f)
273 | ru, _ := r.Match("GET", "/withparams/:id", c)
274 | So(ru, ShouldNotBeNil)
275 | ru, _ = r.Match("GET", "/withparams", c)
276 | So(ru, ShouldBeNil)
277 | ru, _ = r.Match("GET", "/withparams/", c)
278 | So(ru, ShouldBeNil)
279 | })
280 | }
281 |
282 | func _TestTreeRoutePrint1(t *testing.T) {
283 | Convey("print route table", t, func() {
284 | r.(*Tree).print("", nil)
285 | })
286 | }
287 |
288 | func _TestTreeRoutePrint2(t *testing.T) {
289 | Convey("print routes", t, func() {
290 | fmt.Println("")
291 | for method, routes := range r.Routes() {
292 | fmt.Println("Method: ", method)
293 | for i, route := range routes {
294 | fmt.Printf(" %3d %s\n", i, route)
295 | }
296 | }
297 | })
298 | }
299 |
300 | func _TestTreeRoutePrint3(t *testing.T) {
301 | Convey("print named routes", t, func() {
302 | fmt.Println("")
303 | for name, route := range r.NamedRoutes() {
304 | fmt.Printf("%20s \t %s\n", name, route)
305 | }
306 | })
307 | }
308 |
--------------------------------------------------------------------------------