func (s *LoadBalancedPoolSuite) TestRetries(c *C) {
server, addr := test_utils.SetupTestServer(false)
defer server.Close()
params := ConnectionParams{
MaxIdle: 1,
ResponseTimeout: 100 * time.Millisecond,
}
pool := NewLoadBalancedPool(params)
infos := []LBPoolInstanceInfo{
LBPoolInstanceInfo{
Addr: addr,
InstanceId: 0,
},
LBPoolInstanceInfo{
Addr: "127.0.0.1:1111",
InstanceId: 1,
},
}
pool.Update(infos)
simplePool, err := pool.GetInstancePool(1)
c.Assert(err, IsNil)
c.Assert(simplePool.addr, Equals, "127.0.0.1:1111")
for i := 0; i < 10; i++ {
// no requests should ever fail, because of retries and mark downs
req, err := http.NewRequest("GET", "/", nil)
c.Assert(err, IsNil)
_, err = pool.Do(req)
c.Assert(err, IsNil)
}
}
func (s *SimplePoolSuite) TestSSL(c *C) {
server, addr := test_utils.SetupTestServer(true)
defer server.Close()
params := ConnectionParams{
MaxIdle: 1,
ResponseTimeout: 1 * time.Second,
UseSSL: true,
SkipVerifySSL: true,
}
pool := NewSimplePool(addr, params)
req, err := http.NewRequest("GET", "/", nil)
c.Assert(err, IsNil)
resp, err := pool.Do(req)
c.Assert(err, IsNil)
c.Assert(resp.StatusCode, Equals, http.StatusOK)
}
func (s *SimplePoolSuite) TestConnectTimeout(c *C) {
server, addr := test_utils.SetupTestServer(false)
defer server.Close()
params := ConnectionParams{
MaxIdle: 1,
ConnectTimeout: 1 * time.Nanosecond,
}
var pool Pool = NewSimplePool(addr, params)
req, err := http.NewRequest("GET", "/", nil)
c.Assert(err, IsNil)
_, err = pool.Do(req)
_, ok := err.(DialError)
c.Assert(ok, IsTrue)
}
func (s *SimplePoolSuite) TestResponseTimeout(c *C) {
server, addr := test_utils.SetupTestServer(false)
defer func() {
server.CloseChan <- true
time.Sleep(10 * time.Millisecond)
server.Close()
}()
params := ConnectionParams{
MaxIdle: 1,
ResponseTimeout: 100 * time.Millisecond,
}
pool := NewSimplePool(addr, params)
req, err := http.NewRequest("GET", "/slow_request", nil)
c.Assert(err, IsNil)
_, err = pool.Do(req)
c.Assert(err, NotNil)
}
func (s *SimplePoolSuite) TestHTTP(c *C) {
server, addr := test_utils.SetupTestServer(false)
defer server.Close()
// do single request
params := ConnectionParams{
MaxIdle: 1,
}
var pool Pool = NewSimplePool(addr, params)
// do 10 requests concurrently
origMaxProcs := runtime.GOMAXPROCS(runtime.NumCPU())
defer func() { runtime.GOMAXPROCS(origMaxProcs) }()
const count = 10
finished := make(chan bool)
for i := 0; i < count; i++ {
go func() {
req, err := http.NewRequest("GET", "/", nil)
c.Assert(err, IsNil)
_, err = pool.Do(req)
c.Assert(err, IsNil)
finished <- true
}()
}
for i := 0; i < count; i++ {
select {
case <-finished:
// cool
case <-time.After(5 * time.Second):
c.FailNow()
}
}
}
