func (t *localServerSuite) TestPrecheckInstanceAvailZonesUnsupported(c *gc.C) {
t.srv.Service.Nova.SetAvailabilityZones() // no availability zone support
env := t.Prepare(c)
placement := "zone=test-unknown"
err := env.PrecheckInstance("precise", constraints.Value{}, placement)
c.Assert(err, jc.Satisfies, jujuerrors.IsNotImplemented)
}
// MakeConfig creates a functional environConfig for a test.
func MakeConfig(c *gc.C, attrs testing.Attrs) *environConfig {
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
return env.(*joyentEnviron).Ecfg()
}
func (s *MetaSuite) TestMetaHooks(c *gc.C) {
meta, err := charm.ReadMeta(repoMeta("wordpress"))
c.Assert(err, gc.IsNil)
hooks := meta.Hooks()
expectedHooks := map[string]bool{
"install": true,
"start": true,
"config-changed": true,
"upgrade-charm": true,
"stop": true,
"cache-relation-joined": true,
"cache-relation-changed": true,
"cache-relation-departed": true,
"cache-relation-broken": true,
"db-relation-joined": true,
"db-relation-changed": true,
"db-relation-departed": true,
"db-relation-broken": true,
"logging-dir-relation-joined": true,
"logging-dir-relation-changed": true,
"logging-dir-relation-departed": true,
"logging-dir-relation-broken": true,
"monitoring-port-relation-joined": true,
"monitoring-port-relation-changed": true,
"monitoring-port-relation-departed": true,
"monitoring-port-relation-broken": true,
"url-relation-joined": true,
"url-relation-changed": true,
"url-relation-departed": true,
"url-relation-broken": true,
}
c.Assert(hooks, gc.DeepEquals, expectedHooks)
}
func (s *uniterSuite) TestOpenPort(c *gc.C) {
openedPorts := s.wordpressUnit.OpenedPorts()
c.Assert(openedPorts, gc.HasLen, 0)
args := params.EntitiesPorts{Entities: []params.EntityPort{
{Tag: "unit-mysql-0", Protocol: "tcp", Port: 1234},
{Tag: "unit-wordpress-0", Protocol: "udp", Port: 4321},
{Tag: "unit-foo-42", Protocol: "tcp", Port: 42},
}}
result, err := s.uniter.OpenPort(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{apiservertesting.ErrUnauthorized},
{nil},
{apiservertesting.ErrUnauthorized},
},
})
// Verify the wordpressUnit's port is opened.
err = s.wordpressUnit.Refresh()
c.Assert(err, gc.IsNil)
openedPorts = s.wordpressUnit.OpenedPorts()
c.Assert(openedPorts, gc.DeepEquals, []instance.Port{
{Protocol: "udp", Number: 4321},
})
}
func makeRequestWithManifest(manifest string, c *gocheck.C) (*httptest.ResponseRecorder, *http.Request) {
b := bytes.NewBufferString(manifest)
request, err := http.NewRequest("POST", "/services", b)
c.Assert(err, gocheck.IsNil)
recorder := httptest.NewRecorder()
return recorder, request
}
func (s *uniterSuite) addRelation(c *gc.C, first, second string) *state.Relation {
eps, err := s.State.InferEndpoints([]string{first, second})
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, gc.IsNil)
return rel
}
func (s *localServerSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
env := s.Open(c)
cons := constraints.MustParse("instance-type=m1.large")
placement := ""
err := env.PrecheckInstance("precise", cons, placement)
c.Assert(err, gc.ErrorMatches, `invalid Openstack flavour "m1.large" specified`)
}
// assertCollected reads lines from the string channel linec. It compares if
// those are the one passed with compare until a timeout. If the timeout is
// reached earlier than all lines are collected the assertion fails. The
// injection function allows to interrupt the processing with a function
// generating an error or a regular stopping during the tailing. In case the
// linec is closed due to stopping or an error only the values so far care
// compared. Checking the reason for termination is done in the test.
func assertCollected(c *gc.C, linec chan string, compare []string, injection func([]string)) {
if len(compare) == 0 {
return
}
timeout := time.After(testing.LongWait)
lines := []string{}
for {
select {
case line, ok := <-linec:
if ok {
lines = append(lines, line)
if injection != nil {
injection(lines)
}
if len(lines) == len(compare) {
// All data received.
c.Assert(lines, gc.DeepEquals, compare)
return
}
} else {
// linec closed after stopping or error.
c.Assert(lines, gc.DeepEquals, compare[:len(lines)])
return
}
case <-timeout:
if injection == nil {
c.Fatalf("timeout during tailer collection")
}
return
}
}
}
func (s *deployerSuite) TestAPIAddresses(c *gc.C) {
apiInfo := s.APIInfo(c)
addresses, err := s.st.APIAddresses()
c.Assert(err, gc.IsNil)
c.Assert(addresses, gc.DeepEquals, apiInfo.Addrs)
}
func (s *notifyWorkerSuite) TestStop(c *gc.C) {
err := s.worker.Stop()
c.Assert(err, gc.IsNil)
// After stop, Wait should return right away
err = WaitShort(c, s.worker)
c.Assert(err, gc.IsNil)
}
func (s *unitSuite) SetUpTest(c *gc.C) {
s.firewallerSuite.SetUpTest(c)
var err error
s.apiUnit, err = s.firewaller.Unit(s.units[0].Tag().(names.UnitTag))
c.Assert(err, gc.IsNil)
}
func (s *charmVersionSuite) TestNewCharmRevisionUpdaterAPIRefusesNonStateManager(c *gc.C) {
anAuthoriser := s.authoriser
anAuthoriser.EnvironManager = false
endPoint, err := charmrevisionupdater.NewCharmRevisionUpdaterAPI(s.State, s.resources, anAuthoriser)
c.Assert(endPoint, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "permission denied")
}
func (s *ELBSuite) TestGetCollection(c *gocheck.C) {
manager := ELBManager{}
conn, coll := manager.collection()
defer conn.Close()
other := s.conn.Collection(s.cName)
c.Assert(coll.FullName, gocheck.Equals, other.FullName)
}
func (s *MetaSuite) TestSubordinateWithoutContainerRelation(c *gc.C) {
r := repoMeta("dummy")
hackYaml := ReadYaml(r)
hackYaml["subordinate"] = true
_, err := charm.ReadMeta(hackYaml.Reader())
c.Assert(err, gc.ErrorMatches, "subordinate charm \"dummy\" lacks \"requires\" relation with container scope")
}
func (s *localServerSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
env := s.Open(c)
cons := constraints.MustParse("instance-type=m1.small")
placement := ""
err := env.PrecheckInstance("precise", cons, placement)
c.Assert(err, gc.IsNil)
}
func assertSecurityGroups(c *gc.C, env environs.Environ, expected []string) {
novaClient := openstack.GetNovaClient(env)
groups, err := novaClient.ListSecurityGroups()
c.Assert(err, gc.IsNil)
for _, name := range expected {
found := false
for _, group := range groups {
if group.Name == name {
found = true
break
}
}
if !found {
c.Errorf("expected security group %q not found", name)
}
}
for _, group := range groups {
found := false
for _, name := range expected {
if group.Name == name {
found = true
break
}
}
if !found {
c.Errorf("existing security group %q is not expected", group.Name)
}
}
}
func (s *localServerSuite) TestResolveNetworkNotPresent(c *gc.C) {
env := s.Prepare(c)
var notPresentNetwork = "no-network-with-this-label"
networkId, err := openstack.ResolveNetwork(env, notPresentNetwork)
c.Check(networkId, gc.Equals, "")
c.Assert(err, gc.ErrorMatches, `No networks exist with label "no-network-with-this-label"`)
}
func (s *localServerSuite) TestResolveNetworkUUID(c *gc.C) {
env := s.Prepare(c)
var sampleUUID = "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"
networkId, err := openstack.ResolveNetwork(env, sampleUUID)
c.Assert(err, gc.IsNil)
c.Assert(networkId, gc.Equals, sampleUUID)
}
func (s *ProvisionSuite) makeRequestToServicesHandler(c *gocheck.C) (*httptest.ResponseRecorder, *http.Request) {
request, err := http.NewRequest("GET", "/services", nil)
c.Assert(err, gocheck.IsNil)
request.Header.Set("Content-Type", "application/json")
recorder := httptest.NewRecorder()
return recorder, request
}
func (s *ClientTests) createInstanceAndLB(c *gocheck.C) (*elb.CreateLoadBalancer, string) {
options := ec2.RunInstancesOptions{
ImageId: "ami-ccf405a5",
InstanceType: "t1.micro",
AvailZone: "us-east-1c",
}
resp1, err := s.ec2.RunInstances(&options)
c.Assert(err, gocheck.IsNil)
instId := resp1.Instances[0].InstanceId
createLBReq := elb.CreateLoadBalancer{
Name: "testlb",
AvailZones: []string{"us-east-1c"},
Listeners: []elb.Listener{
{
InstancePort: 80,
InstanceProtocol: "http",
LoadBalancerPort: 80,
Protocol: "http",
},
},
}
_, err = s.elb.CreateLoadBalancer(&createLBReq)
c.Assert(err, gocheck.IsNil)
return &createLBReq, instId
}
func (s *V4SignerSuite) TestCases(c *gocheck.C) {
signer := aws.NewV4Signer(s.auth, "host", s.region)
for _, testCase := range s.cases {
req, err := http.NewRequest(testCase.request.method, "http://"+testCase.request.host+testCase.request.url, strings.NewReader(testCase.request.body))
c.Assert(err, gocheck.IsNil, gocheck.Commentf("Testcase: %s", testCase.label))
for _, v := range testCase.request.headers {
h := strings.SplitN(v, ":", 2)
req.Header.Add(h[0], h[1])
}
req.Header.Set("host", req.Host)
t := signer.RequestTime(req)
canonicalRequest := signer.CanonicalRequest(req)
c.Check(canonicalRequest, gocheck.Equals, testCase.canonicalRequest, gocheck.Commentf("Testcase: %s", testCase.label))
stringToSign := signer.StringToSign(t, canonicalRequest)
c.Check(stringToSign, gocheck.Equals, testCase.stringToSign, gocheck.Commentf("Testcase: %s", testCase.label))
signature := signer.Signature(t, stringToSign)
c.Check(signature, gocheck.Equals, testCase.signature, gocheck.Commentf("Testcase: %s", testCase.label))
authorization := signer.Authorization(req.Header, t, signature)
c.Check(authorization, gocheck.Equals, testCase.authorization, gocheck.Commentf("Testcase: %s", testCase.label))
signer.Sign(req)
c.Check(req.Header.Get("Authorization"), gocheck.Equals, testCase.authorization, gocheck.Commentf("Testcase: %s", testCase.label))
}
}
func (s *S) TestCreateBucketBackward(c *gocheck.C) {
patchRandomReader()
defer unpatchRandomReader()
auth := aws.Auth{AccessKey: "access", SecretKey: "s3cr3t"}
region := aws.Region{
Name: "myregion",
S3Endpoint: s.t.S3Server.URL(),
S3LocationConstraint: true,
S3LowercaseBucket: true,
}
s3Client := s3.New(auth, region)
app := App{Name: "leper"}
err := s3Client.Bucket(app.Name).PutBucket(s3.BucketOwnerFull)
c.Assert(err, gocheck.IsNil)
env := s3Env{
Auth: aws.Auth{AccessKey: "access", SecretKey: "s3cr3t"},
bucket: app.Name,
endpoint: s.t.S3Server.URL(),
locationConstraint: true,
}
ctx := action.BWContext{Params: []interface{}{&app}, FWResult: &env}
createBucketAction.Backward(ctx)
_, err = s3Client.Bucket(app.Name).List("", "/", "", 100)
c.Assert(err, gocheck.NotNil)
}
func (s *localServer) start(c *gc.C, cred *identity.Credentials) {
// Set up the HTTP server.
if s.UseTLS {
s.Server = httptest.NewTLSServer(nil)
} else {
s.Server = httptest.NewServer(nil)
}
c.Assert(s.Server, gc.NotNil)
s.oldHandler = s.Server.Config.Handler
s.Mux = http.NewServeMux()
s.Server.Config.Handler = s.Mux
cred.URL = s.Server.URL
c.Logf("Started service at: %v", s.Server.URL)
s.Service = openstackservice.New(cred, identity.AuthUserPass)
s.Service.SetupHTTP(s.Mux)
s.restoreTimeouts = envtesting.PatchAttemptStrategies(openstack.ShortAttempt, openstack.StorageAttempt)
s.Service.Nova.SetAvailabilityZones(
nova.AvailabilityZone{Name: "test-unavailable"},
nova.AvailabilityZone{
Name: "test-available",
State: nova.AvailabilityZoneState{
Available: true,
},
},
)
}
func (s *provisionerSuite) TestWatchEnvironMachines(c *gc.C) {
w, err := s.provisioner.WatchEnvironMachines()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange(s.machine.Id())
// Add another 2 machines make sure they are detected.
otherMachine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
otherMachine, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
wc.AssertChange("1", "2")
// Change the lifecycle of last machine.
err = otherMachine.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertChange("2")
// Add a container and make sure it's not detected.
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
}
_, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *WriterSuite) SetUpSuite(c *gocheck.C) {
var err error
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_writer_test")
s.conn, err = db.Conn()
c.Assert(err, gocheck.IsNil)
}
func (s *S) TestUnitStatus(c *gocheck.C) {
var tests = []struct {
instance string
agent string
machineAgent string
expected provision.Status
}{
{"something", "nothing", "wut", provision.StatusBuilding},
{"", "", "", provision.StatusBuilding},
{"", "", "pending", provision.StatusBuilding},
{"", "", "not-started", provision.StatusBuilding},
{"pending", "", "", provision.StatusBuilding},
{"", "not-started", "running", provision.StatusBuilding},
{"error", "install-error", "start-error", provision.StatusDown},
{"started", "start-error", "running", provision.StatusDown},
{"started", "charm-upgrade-error", "running", provision.StatusDown},
{"running", "pending", "running", provision.StatusBuilding},
{"running", "started", "running", provision.StatusStarted},
{"running", "down", "running", provision.StatusDown},
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
}))
defer server.Close()
url := strings.Replace(server.URL, "http://", "", -1)
for _, t := range tests {
m := machine{AgentState: t.machineAgent, InstanceState: t.instance}
u := unit{AgentState: t.agent}
unit := provision.Unit{Ip: url}
got := unitStatus(m, u, unit)
c.Assert(got, gocheck.Equals, t.expected)
}
}
func (s *uniterSuite) TestWatchConfigSettings(c *gc.C) {
err := s.wordpressUnit.SetCharmURL(s.wpCharm.URL())
c.Assert(err, gc.IsNil)
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: "unit-mysql-0"},
{Tag: "unit-wordpress-0"},
{Tag: "unit-foo-42"},
}}
result, err := s.uniter.WatchConfigSettings(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{Error: apiservertesting.ErrUnauthorized},
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 1)
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher))
wc.AssertNoChange()
}
func (s *S) TestIsUnreachableOnBadGateway(c *gocheck.C) {
server, url := badGatewayServer()
defer server.Close()
unit := provision.Unit{Ip: url}
reachable, _ := IsReachable(unit)
c.Assert(reachable, gocheck.Equals, false)
}
func (*AddressSuite) TestSortAddresses(c *gc.C) {
addrs := network.NewAddresses(
"127.0.0.1",
"localhost",
"example.com",
"::1",
"fc00::1",
"fe80::2",
"172.16.0.1",
"8.8.8.8",
)
network.SortAddresses(addrs, false)
c.Assert(addrs, jc.DeepEquals, network.NewAddresses(
"example.com",
"localhost",
"127.0.0.1",
"172.16.0.1",
"8.8.8.8",
"::1",
"fe80::2",
"fc00::1",
))
network.SortAddresses(addrs, true)
c.Assert(addrs, jc.DeepEquals, network.NewAddresses(
"example.com",
"localhost",
"fe80::2",
"::1",
"fc00::1",
"127.0.0.1",
"172.16.0.1",
"8.8.8.8",
))
}
func (s *S) TestGetServicesNames(c *gocheck.C) {
s1 := Service{Name: "Foo"}
s2 := Service{Name: "Bar"}
s3 := Service{Name: "FooBar"}
sNames := GetServicesNames([]Service{s1, s2, s3})
c.Assert(sNames, gocheck.DeepEquals, []string{"Foo", "Bar", "FooBar"})
}