← Back to branch summary

~niemeyer/goamz/sdb

« back to all changes in this revision

Viewing changes to suite_test.go

  • Committer: Andrew Chilton
  • Date: 2011-08-20 11:15:01 UTC
  • Revision ID: chilts@appsattic.com-20110820111501-gkaury1ioufs49ay
Adding initial revision to repository.

Show diffs side-by-side

added added

removed removed

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