~prudhvikrishna/sqs/trunk

« back to all changes in this revision

Viewing changes to suite_test.go

  • Committer: Prudhvi Krishna Surapaneni
  • Date: 2012-05-24 21:06:40 UTC
  • Revision ID: me@prudhvi.net-20120524210640-rt0mcxlp42v5kwze
Import SQS

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
package sqs_test
 
2
 
 
3
import (
 
4
        "fmt"
 
5
        . "launchpad.net/gocheck"
 
6
        "net/http"
 
7
        "net/url"
 
8
        "os"
 
9
        "testing"
 
10
        "time"
 
11
)
 
12
 
 
13
func Test(t *testing.T) {
 
14
        TestingT(t)
 
15
}
 
16
 
 
17
type HTTPSuite struct{}
 
18
 
 
19
var testServer = NewTestHTTPServer("http://localhost:4444", 5*time.Second)
 
20
 
 
21
func (s *HTTPSuite) SetUpSuite(c *C) {
 
22
        testServer.Start()
 
23
}
 
24
 
 
25
func (s *HTTPSuite) TearDownTest(c *C) {
 
26
        testServer.FlushRequests()
 
27
}
 
28
 
 
29
type TestHTTPServer struct {
 
30
        URL      string
 
31
        Timeout  time.Duration
 
32
        started  bool
 
33
        request  chan *http.Request
 
34
        response chan *testResponse
 
35
        pending  chan bool
 
36
}
 
37
 
 
38
type testResponse struct {
 
39
        Status  int
 
40
        Headers map[string]string
 
41
        Body    string
 
42
}
 
43
 
 
44
func NewTestHTTPServer(url string, timeout time.Duration) *TestHTTPServer {
 
45
        return &TestHTTPServer{URL: url, Timeout: timeout}
 
46
}
 
47
 
 
48
func (s *TestHTTPServer) Start() {
 
49
        if s.started {
 
50
                return
 
51
        }
 
52
        s.started = true
 
53
 
 
54
        s.request = make(chan *http.Request, 64)
 
55
        s.response = make(chan *testResponse, 64)
 
56
        s.pending = make(chan bool, 64)
 
57
 
 
58
        url, _ := url.Parse(s.URL)
 
59
        go http.ListenAndServe(url.Host, s)
 
60
 
 
61
        s.PrepareResponse(202, nil, "Nothing.")
 
62
        for {
 
63
                // Wait for it to be up.
 
64
                resp, err := http.Get(s.URL)
 
65
                if err == nil && resp.StatusCode == 202 {
 
66
                        break
 
67
                }
 
68
                fmt.Fprintf(os.Stderr, "\nWaiting for fake server to be up... ")
 
69
                time.Sleep(1e8)
 
70
        }
 
71
        fmt.Fprintf(os.Stderr, "done\n\n")
 
72
        s.WaitRequest() // Consume dummy request
 
73
}
 
74
 
 
75
// FulshRequests discards requests which were not yet consumed by WaitRequest
 
76
func (s *TestHTTPServer) FlushRequests() {
 
77
        for {
 
78
                select {
 
79
                case <-s.request:
 
80
                default:
 
81
                        return
 
82
                }
 
83
        }
 
84
}
 
85
 
 
86
func (s *TestHTTPServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 
87
        s.request <- req
 
88
        var resp *testResponse
 
89
        select {
 
90
        case resp = <-s.response:
 
91
        case <-time.After(s.Timeout):
 
92
                fmt.Fprintf(os.Stderr, "ERROR: Timeout waiting for test to provide response\n")
 
93
                resp = &testResponse{500, nil, ""}
 
94
        }
 
95
        if resp.Headers != nil {
 
96
                h := w.Header()
 
97
                for k, v := range resp.Headers {
 
98
                        h.Set(k, v)
 
99
                }
 
100
        }
 
101
        if resp.Status != 0 {
 
102
                w.WriteHeader(resp.Status)
 
103
        }
 
104
        w.Write([]byte(resp.Body))
 
105
}
 
106
 
 
107
func (s *TestHTTPServer) WaitRequest() *http.Request {
 
108
        select {
 
109
        case req := <-s.request:
 
110
                req.ParseForm()
 
111
                return req
 
112
        case <-time.After(s.Timeout):
 
113
                panic("Timeout waiting for goamz request")
 
114
        }
 
115
        panic("unreached")
 
116
}
 
117
 
 
118
func (s *TestHTTPServer) PrepareResponse(status int, headers map[string]string, body string) {
 
119
        s.response <- &testResponse{status, headers, body}
 
120
}