func init() {
//Endpoints associated with the test
var (
xaviAgentURL = testsupport.XaviAgentRESTEnpointBaseURI
testUrl = testsupport.XaviAcceptanceTestEndpointBaseURL + "/hello"
server1Url = testsupport.CohostedMountebankEndpointBaseURL + "/imposters/3000"
server2Url = testsupport.CohostedMountebankEndpointBaseURL + "/imposters/3100"
)
//XAVI definitions for the test scenario
const (
hello1Server = `{"Address":"localhost","Port":3000,"PingURI":"/hello"}`
hello2Server = `{"Address":"localhost","Port":3100,"PingURI":"/hello"}`
backend = `{"ServerNames":["hello1","hello2"],"LoadBalancerPolicy":"round-robin"}`
route = `{"URIRoot":"/hello","Backends":["demo-backend"],"Plugins":null,"MsgProps":""}`
listener = `{"RouteNames":["demo-route"]}`
)
var (
testFailure bool
server1RequestCount int
server2RequestCount int
spawnedPID int
)
var doSetup = func() error {
log.Info("set up")
testPort, err := testsupport.GetPortFromURL(testUrl)
if err != nil {
return err
}
//
// XAVI configuration for the test
//
err = testsupport.PutDefinitionOk("v1/servers/hello1", hello1Server, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/servers/hello2", hello2Server, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/backends/demo-backend", backend, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/routes/demo-route", route, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/listeners/demo-listener", listener, xaviAgentURL)
if err != nil {
return err
}
//
// Configuration of the mountebank imposters that represent the servers proxied in
// the test.
//
testsupport.MountebankSetup(testsupport.CohostedMountebankEndpointBaseURL+"/imposters", testsupport.RoundRobin3000Config)
testsupport.MountebankSetup(testsupport.CohostedMountebankEndpointBaseURL+"/imposters", testsupport.RoundRobin3100Config)
//
// Spawn the XAVI process that represents the system under test
//
spawnedPID, err = testsupport.Spawn("demo-listener", testPort, xaviAgentURL)
log.Info("Spawned ", spawnedPID)
return err
}
Given(`^I have a backend definitions with two servers$`, func() {
if err := doSetup(); err != nil {
log.Info("Setup failed: ", err.Error())
T.Errorf("Error in test setup: %s", err.Error())
testFailure = true
return
}
//Baseline the imposter request counts
endpointOutput, err := testsupport.GetTestEndpointOutput(server1Url)
assert.Nil(T, err)
log.Infof("Counting requests from %s for %s", endpointOutput, server1Url)
server1RequestCount = testsupport.CountRequestFrom(endpointOutput)
endpointOutput, err = testsupport.GetTestEndpointOutput(server2Url)
assert.Nil(T, err)
server2RequestCount = testsupport.CountRequestFrom(endpointOutput)
log.Info("server 1 request count: ", server1RequestCount)
log.Info("server 2 request count: ", server2RequestCount)
})
And(`^The load balancing policy is round robin$`, func() {
})
And(`^I send two requests to the listener$`, func() {
if testFailure {
return
}
log.Infof("send request to %s", testUrl)
assert.Equal(T, 200, testsupport.GetTestEndpoint(testUrl))
log.Infof("send request to %s", testUrl)
assert.Equal(T, 200, testsupport.GetTestEndpoint(testUrl))
})
Then(`^Each server gets a single request$`, func() {
if testFailure {
return
}
//Grab the latest request counts for comparison to the baseline counts
endpointOutput, err := testsupport.GetTestEndpointOutput(server1Url)
assert.Nil(T, err)
latestServer1Count := testsupport.CountRequestFrom(endpointOutput)
endpointOutput, err = testsupport.GetTestEndpointOutput(server2Url)
assert.Nil(T, err)
latestServer2Count := testsupport.CountRequestFrom(endpointOutput)
log.Info("updated server 1 request count: ", latestServer1Count)
log.Info("update server 2 request count: ", latestServer2Count)
assert.Equal(T, server1RequestCount+1, latestServer1Count)
assert.Equal(T, server2RequestCount+1, latestServer2Count)
})
After("@basicroundrobin", func() {
log.Info("After")
testPort, err := testsupport.GetPortFromURL(testUrl)
assert.NotNil(T, err)
testsupport.KillSpawnedProcess(spawnedPID, testPort, xaviAgentURL)
})
}
func init() {
//Endpoints associated with the test
var (
xaviAgentURL = testsupport.XaviAgentRESTEnpointBaseURI
testUrl = testsupport.XaviAcceptanceTestEndpointBaseURL + "/hello"
server2Url = testsupport.CohostedMountebankEndpointBaseURL + "/imposters/3100"
)
//XAVI definitions for the test scenario
const (
hello1Server = `{"Address":"localhost","Port":3000,"PingURI":"/hello","HealthCheck":"http-get",
"HealthCheckInterval":200,"HealthCheckTimeout":150}`
hello2Server = `{"Address":"localhost","Port":3100,"PingURI":"/hello","HealthCheck":"http-get",
"HealthCheckInterval":200,"HealthCheckTimeout":150}`
backend = `{"ServerNames":["hello1","hello2"],"LoadBalancerPolicy":"round-robin"}`
route = `{"URIRoot":"/hello","Backends":["demo-backend"],"Plugins":null,"MsgProps":""}`
listener = `{"RouteNames":["demo-route"]}`
)
var (
failedState bool
failures int
spawnedPID int
)
var doSetup = func() error {
testPort, err := testsupport.GetPortFromURL(testUrl)
if err != nil {
return err
}
log.Info("Delete mb imposter")
testsupport.DeleteMountebankImposter(server2Url)
//
// XAVI configuration for the test
//
err = testsupport.PutDefinitionOk("v1/servers/hello1", hello1Server, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/servers/hello2", hello2Server, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/backends/demo-backend", backend, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/routes/demo-route", route, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/listeners/demo-listener", listener, xaviAgentURL)
if err != nil {
return err
}
//
// Configuration of the mountebank imposters that represent the servers proxied in
// the test. Note we only set up one imposter to simulate the unhealhy endpoint
//
log.Info("Set up the healthy server on port 3000")
testsupport.MountebankSetup(testsupport.CohostedMountebankEndpointBaseURL+"/imposters", testsupport.RoundRobin3000Config)
spawnedPID, err = testsupport.Spawn("demo-listener", testPort, xaviAgentURL)
log.Info("spawnedPID is ", spawnedPID)
return err
}
Given(`^A backend with some unhealthy servers$`, func() {
log.Warn("Healthcheck test disabled - see comment in steps file")
failedState = true
return
if err := doSetup(); err != nil {
log.Info("Setup failed: ", err.Error())
T.Errorf("Error in test setup: %s", err.Error())
failedState = true
return
}
})
And(`^I invoke a service against the backend$`, func() {
if failedState {
return
}
time.Sleep(2 * time.Second)
for i := 0; i < 5; i++ {
log.Println("send request")
if testsupport.GetTestEndpoint(testUrl) != 200 {
failures = failures + 1
}
}
})
Then(`^The service calls succeed against the healthy backends$`, func() {
if failedState {
return
}
assert.Equal(T, 0, failures)
})
Given(`^A previously unhealthy server becomes healthy$`, func() {
if failedState {
log.Warn("Healthcheck test disabled - see comment in steps file")
//uncomment the following when re-enabling the test
//T.Errorf("requisite test set up failed")
return
}
log.Info("Set up a healthy server on port 3100")
testsupport.MountebankSetup(testsupport.CohostedMountebankEndpointBaseURL+"/imposters", testsupport.RoundRobin3100Config)
})
Then(`^The healed backend recieves traffic$`, func() {
if failedState {
return
}
failures = 0
time.Sleep(2 * time.Second)
for i := 0; i < 5; i++ {
log.Info("get ", testUrl)
if testsupport.GetTestEndpoint(testUrl) != 200 {
failures = failures + 1
}
assert.Equal(T, 0, failures)
}
})
After("@withhealed", func() {
log.Warn("Healthcheck test disabled - see comment in steps file")
return
testPort, err := testsupport.GetPortFromURL(testUrl)
assert.NotNil(T, err)
testsupport.KillSpawnedProcess(spawnedPID, testPort, xaviAgentURL)
})
}
func init() {
//Definitions used to set up the xavi test server to be spawned
const (
prefLocalServer1 = `{"Address":"localhost","Port":3001,"PingURI":"/hello"}`
prefLocalServer2 = `{"Address":"mbhost","Port":3001,"PingURI":"/hello"}`
backend = `{"ServerNames":["local-hello","remote-hello"],"LoadBalancerPolicy":"prefer-local"}`
route = `{"URIRoot":"/hello2","Backends":["pref-local-backend"],"Plugins":null,"MsgProps":""}`
listener = `{"RouteNames":["pref-local-route"]}`
)
//Endpoints associated with the test
var (
xaviAgentURL = testsupport.XaviAgentRESTEnpointBaseURI
testUrl = testsupport.XaviAcceptanceTestEndpointBaseURL + "/hello2"
server1Url = testsupport.CohostedMountebankEndpointBaseURL + "/imposters/3001"
server2Url = testsupport.StandaloneMountebackEndpointBaseURL + "/imposters/3001"
)
var (
server1RequestCount int
server2RequestCount int
spawnedPID int
testFailure bool
)
var doSetup = func() error {
testPort, err := testsupport.GetPortFromURL(testUrl)
if err != nil {
return err
}
//
// Set up XAVI definitions
//
log.Info("agent url: ", xaviAgentURL)
log.Info("server1Url: ", server1Url)
err = testsupport.PutDefinitionOk("v1/servers/local-hello", prefLocalServer1, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/servers/remote-hello", prefLocalServer2, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/backends/pref-local-backend", backend, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/routes/pref-local-route", route, xaviAgentURL)
if err != nil {
return err
}
err = testsupport.PutDefinitionOk("v1/listeners/pref-local-listener", listener, xaviAgentURL)
if err != nil {
return err
}
//
// Setup the imposters that represent the servers associated with the XAVI backend def
//
testsupport.DeleteMountebankImposter(server1Url)
testsupport.DeleteMountebankImposter(server2Url)
testsupport.MountebankSetup(testsupport.CohostedMountebankEndpointBaseURL+"/imposters", prefLocalImposter)
testsupport.MountebankSetup(testsupport.StandaloneMountebackEndpointBaseURL+"/imposters", prefLocalImposter)
//
// Spawn the XAVI instance to test with the above configuration
//
spawnedPID, err = testsupport.Spawn("pref-local-listener", testPort, xaviAgentURL)
log.Println("Spawned ", spawnedPID)
return err
}
Given(`^A preflocal route with backend definitions with two servers$`, func() {
if err := doSetup(); err != nil {
log.Info("Setup failed: ", err.Error())
T.Errorf("Error in test setup: %s", err.Error())
testFailure = true
return
}
//Baseline the request counts at the imposters
endpointOutput, err := testsupport.GetTestEndpointOutput(server1Url)
assert.Nil(T, err)
server1RequestCount = testsupport.CountRequestFrom(endpointOutput)
endpointOutput, err = testsupport.GetTestEndpointOutput(server2Url)
assert.Nil(T, err)
server2RequestCount = testsupport.CountRequestFrom(endpointOutput)
log.Info("server 1 request count: ", server1RequestCount)
log.Info("server 2 request count: ", server2RequestCount)
})
And(`^The load balancing policy is prefer local$`, func() {
})
And(`^I send two requests to the prelocal listener$`, func() {
if testFailure {
return
}
//Send two requests to the proxies endpoint
log.Info("send request to endpoint ", testUrl)
assert.Equal(T, 200, testsupport.GetTestEndpoint(testUrl))
log.Info("send request")
assert.Equal(T, 200, testsupport.GetTestEndpoint(testUrl))
})
Then(`^Only the local server handles the requests$`, func() {
if testFailure {
return
}
//Grab the counts and compare them to the baseline - only the endpoint in the
//container should see requests
endpointOutput, err := testsupport.GetTestEndpointOutput(server1Url)
assert.Nil(T, err)
latestServer1Count := testsupport.CountRequestFrom(endpointOutput)
endpointOutput, err = testsupport.GetTestEndpointOutput(server2Url)
assert.Nil(T, err)
latestServer2Count := testsupport.CountRequestFrom(endpointOutput)
log.Info("updated server 1 request count", latestServer1Count)
log.Info("update server 2 request count", latestServer2Count)
assert.Equal(T, server1RequestCount+2, latestServer1Count)
assert.Equal(T, server2RequestCount, latestServer2Count)
})
After("@preflocal", func() {
testPort, err := testsupport.GetPortFromURL(testUrl)
assert.NotNil(T, err)
testsupport.KillSpawnedProcess(spawnedPID, testPort, xaviAgentURL)
})
}