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) 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 (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
}
// 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 *S) TestExportEnvironmentsBackward(c *gocheck.C) {
envNames := []string{
"TSURU_S3_ACCESS_KEY_ID", "TSURU_S3_SECRET_KEY",
"TSURU_APPNAME", "TSURU_HOST", "TSURU_S3_ENDPOINT",
"TSURU_S3_LOCATIONCONSTRAINT", "TSURU_S3_BUCKET",
"TSURU_APP_TOKEN",
}
app := App{Name: "moon", Platform: "opeth", Env: make(map[string]bind.EnvVar)}
for _, name := range envNames {
envVar := bind.EnvVar{Name: name, Value: name, Public: false}
if strings.HasPrefix(name, "TSURU_S3_") {
envVar.InstanceName = s3InstanceName
}
app.Env[name] = envVar
}
token, err := auth.CreateApplicationToken(app.Name)
c.Assert(err, gocheck.IsNil)
app.Env["TSURU_APP_TOKEN"] = bind.EnvVar{Name: "TSURU_APP_NAME", Value: token.Token}
err = s.conn.Apps().Insert(app)
c.Assert(err, gocheck.IsNil)
defer s.conn.Apps().Remove(bson.M{"name": app.Name})
ctx := action.BWContext{Params: []interface{}{&app}}
exportEnvironmentsAction.Backward(ctx)
copy, err := GetByName(app.Name)
c.Assert(err, gocheck.IsNil)
for _, name := range envNames {
if _, ok := copy.Env[name]; ok {
c.Errorf("Variable %q should be unexported, but it's still exported.", name)
}
}
_, err = auth.GetToken("bearer " + token.Token)
c.Assert(err, gocheck.Equals, auth.ErrInvalidToken)
}
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 (*GrubTester) TestParseGfxmode(c *C.C) {
sw, sh := getPrimaryScreenBestResolution()
data := []struct {
v string
w, h uint16
}{
{"auto", sw, sh},
{"auto,800x600", sw, sh},
{"1024x768", 1024, 768},
{"1024x768x24", 1024, 768},
{"1024x768,800x600,auto", 1024, 768},
{"1024x768;800x600;auto", 1024, 768},
{"1024x768x24,800x600,auto", 1024, 768},
}
for _, d := range data {
w, h, _ := doParseGfxmode(d.v)
c.Check(w, C.Equals, d.w)
c.Check(h, C.Equals, d.h)
}
// test wrong format
_, _, err := doParseGfxmode("")
c.Check(err, C.NotNil)
_, _, err = doParseGfxmode("1024")
c.Check(err, C.NotNil)
_, _, err = doParseGfxmode("1024x")
c.Check(err, C.NotNil)
_, _, err = doParseGfxmode("autox24")
c.Check(err, C.NotNil)
}
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)
}
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 *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 (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`)
}
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
}
// startReading starts a goroutine receiving the lines out of the reader
// in the background and passing them to a created string channel. This
// will used in the assertions.
func startReading(c *gc.C, tailer *tailer.Tailer, reader *io.PipeReader, writer *io.PipeWriter) chan string {
linec := make(chan string)
// Start goroutine for reading.
go func() {
defer close(linec)
reader := bufio.NewReader(reader)
for {
line, err := reader.ReadString('\n')
switch err {
case nil:
linec <- line
case io.EOF:
return
default:
c.Fail()
}
}
}()
// Close writer when tailer is stopped or has an error. Tailer using
// components can do it the same way.
go func() {
tailer.Wait()
writer.Close()
}()
return linec
}
func (s *S) TestCollectStatusIDChangeFromPending(c *gocheck.C) {
server, url := badGatewayServer()
defer server.Close()
tmpdir, err := commandmocker.Add("juju", generateOutput(url))
c.Assert(err, gocheck.IsNil)
defer commandmocker.Remove(tmpdir)
p := JujuProvisioner{}
collection := p.unitsCollection()
defer collection.Close()
err = collection.Insert(instance{UnitName: "as_i_rise/0", InstanceID: "pending"})
c.Assert(err, gocheck.IsNil)
defer collection.Remove(bson.M{"_id": bson.M{"$in": []string{"as_i_rise/0", "the_infanta/0"}}})
_, err = p.CollectStatus()
c.Assert(err, gocheck.IsNil)
done := make(chan int8)
go func() {
for {
q := bson.M{"_id": "as_i_rise/0", "instanceid": "i-00000439"}
ct, err := collection.Find(q).Count()
c.Assert(err, gocheck.IsNil)
if ct == 1 {
done <- 1
return
}
runtime.Gosched()
}
}()
select {
case <-done:
case <-time.After(5e9):
c.Fatal("Did not update the unit after 5 seconds.")
}
}
func (s *MetaSuite) TestRelationsConstraints(c *gc.C) {
check := func(s, e string) {
meta, err := charm.ReadMeta(strings.NewReader(s))
if e != "" {
c.Assert(err, gc.ErrorMatches, e)
c.Assert(meta, gc.IsNil)
} else {
c.Assert(err, gc.IsNil)
c.Assert(meta, gc.NotNil)
}
}
prefix := "name: a\nsummary: b\ndescription: c\n"
for i, t := range relationsConstraintsTests {
c.Logf("test %d", i)
check(prefix+t.rels, t.err)
check(prefix+"subordinate: true\n"+t.rels, t.err)
}
// The juju-* namespace is accessible to container-scoped require
// relations on subordinate charms.
check(prefix+`
subordinate: true
requires:
juju-info:
interface: juju-info
scope: container`, "")
// The juju-* interfaces are allowed on any require relation.
check(prefix+`
requires:
innocuous: juju-info`, "")
}
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 *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 *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 (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 (tw *TestWatcher) TriggerChange(c *gc.C) {
select {
case tw.changes <- struct{}{}:
case <-time.After(coretesting.LongWait):
c.Errorf("Timeout changes triggering change after %s", coretesting.LongWait)
}
}
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 *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 *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 *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 *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 *deployerSuite) TearDownTest(c *gc.C) {
if s.stateAPI != nil {
err := s.stateAPI.Close()
c.Check(err, gc.IsNil)
}
s.JujuConnSuite.TearDownTest(c)
}
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 *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
}