func (s *S) TestRemoveUnits(c *gocheck.C) { var calls int32 ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { v := atomic.LoadInt32(&calls) atomic.StoreInt32(&calls, v+1) w.WriteHeader(http.StatusNoContent) })) srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}} err := srvc.Create() c.Assert(err, gocheck.IsNil) defer s.conn.Services().Remove(bson.M{"_id": "mysql"}) app := App{ Name: "chemistry", Framework: "python", } instance := service.ServiceInstance{ Name: "my-inst", ServiceName: "mysql", Teams: []string{s.team.Name}, Apps: []string{app.Name}, } instance.Create() defer s.conn.ServiceInstances().Remove(bson.M{"name": "my-inst"}) err = s.conn.Apps().Insert(app) c.Assert(err, gocheck.IsNil) defer s.conn.Apps().Remove(bson.M{"name": app.Name}) c.Assert(err, gocheck.IsNil) s.provisioner.Provision(&app) defer s.provisioner.Destroy(&app) app.AddUnits(4) otherApp := App{Name: app.Name, Units: app.Units} err = otherApp.RemoveUnits(2) c.Assert(err, gocheck.IsNil) ts.Close() units := s.provisioner.GetUnits(&app) c.Assert(units, gocheck.HasLen, 3) // when you provision you already have one, so it's 4+1-2 (in provisioner, in app struct we have 2) c.Assert(units[0].Name, gocheck.Equals, "chemistry/0") c.Assert(units[1].Name, gocheck.Equals, "chemistry/3") c.Assert(units[2].Name, gocheck.Equals, "chemistry/4") err = app.Get() c.Assert(err, gocheck.IsNil) c.Assert(app.Framework, gocheck.Equals, "python") c.Assert(app.Units, gocheck.HasLen, 2) c.Assert(app.Units[0].Name, gocheck.Equals, "chemistry/3") c.Assert(app.Units[1].Name, gocheck.Equals, "chemistry/4") ok := make(chan int8) go func() { for _ = range time.Tick(1e3) { if atomic.LoadInt32(&calls) == 2 { ok <- 1 return } } }() select { case <-ok: case <-time.After(2e9): c.Fatal("Did not call service endpoint twice.") } }
func (s *S) TestPiler(c *check.C) { epsilon := 0.95 for _, f := range []PileFilter{ nil, func(a, b *feat.Feature, pa, pb *PileInterval) bool { lpa := float64(pa.End - pa.Start) lpb := float64(pb.End - pb.Start) return float64(a.Len()) >= lpa*epsilon || float64(b.Len()) >= lpb*epsilon }, } { p := NewPiler(0) for _, fp := range testPairs { err := p.Add(fp) if err != nil { c.Fatal(err) } } piles, err := p.Piles(f) if err != nil { c.Fatal(err) } for i, pi := range piles { c.Logf("%d %v", i, pi) for _, fp := range pi.Images { c.Logf("\t%v", fp) c.Check(fp.A.Meta, check.DeepEquals, pi) } } } }
func (s *QueryBuilderSuite) TestGetItemQuery(c *gocheck.C) { primary := dynamodb.NewStringAttribute("domain", "") key := dynamodb.PrimaryKey{primary, nil} table := s.server.NewTable("sites", key) q := dynamodb.NewQuery(table) q.AddKey(table, &dynamodb.Key{HashKey: "test"}) queryJson, err := simplejson.NewJson([]byte(q.String())) if err != nil { c.Fatal(err) } expectedJson, err := simplejson.NewJson([]byte(` { "Key": { "domain": { "S": "test" } }, "TableName": "sites" } `)) if err != nil { c.Fatal(err) } c.Check(queryJson, gocheck.DeepEquals, expectedJson) }
func (s *S) TestWrite(c *check.C) { b := &B{&bytes.Buffer{}} w := NewWriter(b, 0, 60, false) for _, t := range T { if f1, err := featureOf(ps, t.start, t.end, false); err != nil { c.Fatal(err) } else { if f2, err := featureOf(ps, t.start, t.end, false); err != nil { c.Fatal(err) } else { n, err := w.Write(&FeaturePair{A: f1, B: f2}) c.Check(n, check.Not(check.Equals), 0) c.Check(err, check.Equals, nil) } } } c.Check(string(b.Bytes()), check.Equals, "") w.Close() c.Check(string(b.Bytes()), check.Equals, `deBruijn2 pals hit 1 6 0.0000 . . Target deBruijn2 1 6; maxe 0 deBruijn2 pals hit 2 6 0.0000 . . Target deBruijn2 2 6; maxe 0 deBruijn2 pals hit 1 16 0.0000 . . Target deBruijn2 1 16; maxe 0 deBruijn1 pals hit 1 4 0.0000 . . Target deBruijn1 1 4; maxe 0 deBruijn5 pals hit 1 904 0.0000 . . Target deBruijn5 1 904; maxe 0 deBruijn8 pals hit 1025 4095 0.0000 . . Target deBruijn8 1025 4095; maxe 0 `) }
// Tests func (s *S) TestHash(c *check.C) { var ( err error f *os.File md5hash []byte ) // FIXME: This will not work with MacOS. if _, err = exec.LookPath("md5sum"); err != nil { c.Skip(err.Error()) } md5sum := exec.Command("md5sum", "./files_test.go") b := &bytes.Buffer{} md5sum.Stdout = b if err = md5sum.Run(); err != nil { c.Fatal(err) } if f, err = os.Open("./files_test.go"); err != nil { c.Fatalf("%v %s", md5sum, err) } if md5hash, err = Hash(md5.New(), f); err != nil { c.Fatal(err) } md5string := fmt.Sprintf("%x .*\n", md5hash) c.Check(string(b.Bytes()), check.Matches, md5string) }
func (s *S) TestKmerFrequencies(c *check.C) { for k := MinKmerLen; k <= MaxKmerLen; k++ { if i, err := New(k, s.Seq); err != nil { c.Fatalf("New KmerIndex failed: %v", err) } else { freqs, ok := i.KmerFrequencies() c.Check(ok, check.Equals, true) hashFreqs := make(map[string]int) for i := 0; i+k <= s.Seq.Len(); i++ { hashFreqs[string(s.Seq.Seq[i:i+k])]++ } for key := range freqs { if freqs[key] != hashFreqs[i.Stringify(key)] { c.Logf("seq %s\n", s.Seq) c.Logf("key %x, string of %q\n", key, i.Stringify(key)) } c.Check(freqs[key], check.Equals, hashFreqs[i.Stringify(key)]) } for key := range hashFreqs { if keyKmer, err := i.KmerOf(key); err != nil { c.Fatal(err) } else { if freqs[keyKmer] != hashFreqs[key] { c.Logf("seq %s\n", s.Seq) c.Logf("keyKmer %x, string of %q, key %q\n", keyKmer, i.Stringify(keyKmer), key) } c.Check(freqs[keyKmer], check.Equals, hashFreqs[key]) } } } } }
func (s *S) TestWeightedTimeSeeded(c *check.C) { c.Log("Note: This test is stochastic and is expected to fail with probability ≈ 0.05.") rand.Seed(time.Now().Unix()) f := make([]float64, len(sel)) ts := make(Selector, len(sel)) for i := 0; i < 1e6; i++ { copy(ts, sel) ts.Init() item, err := ts.Select() if err != nil { c.Fatal(err) } f[item-1]++ } fsum, exsum := 0., 0. for i := range f { fsum += f[i] exsum += exp[i] } fac := fsum / exsum for i := range f { exp[i] *= fac } // Check that our obtained values are within statistical expectations for p = 0.05. // This will not be true approximately 1 in 20 tests. X := chi2(f, exp) c.Logf("H₀: d(Sample) = d(Expect), H₁: d(S) ≠ d(Expect). df = %d, p = 0.05, X² threshold = %.2f, X² = %f", len(f)-1, sigChi2, X) c.Check(X < sigChi2, check.Equals, true) }
func (s *S) TestCreateTokenRemoveOldTokens(c *gocheck.C) { config.Set("auth:max-simultaneous-sessions", 2) u := User{Email: "*****@*****.**", Password: "******"} err := u.Create() c.Assert(err, gocheck.IsNil) defer s.conn.Users().Remove(bson.M{"email": u.Email}) defer s.conn.Tokens().RemoveAll(bson.M{"useremail": u.Email}) t1, err := newUserToken(&u) c.Assert(err, gocheck.IsNil) t2 := t1 t2.Token += "aa" err = s.conn.Tokens().Insert(t1, t2) _, err = u.CreateToken("123456") c.Assert(err, gocheck.IsNil) ok := make(chan bool, 1) go func() { for { ct, err := s.conn.Tokens().Find(bson.M{"useremail": u.Email}).Count() c.Assert(err, gocheck.IsNil) if ct == 2 { ok <- true return } runtime.Gosched() } }() select { case <-ok: case <-time.After(2e9): c.Fatal("Did not remove old tokens after 2 seconds") } }
func (s *S) TestProvisionerDestroy(c *gocheck.C) { err := newImage("tsuru/python", s.server.URL()) c.Assert(err, gocheck.IsNil) cont, err := s.newContainer(nil) c.Assert(err, gocheck.IsNil) app := testing.NewFakeApp(cont.AppName, "python", 1) var p dockerProvisioner p.Provision(app) c.Assert(p.Destroy(app), gocheck.IsNil) ok := make(chan bool, 1) go func() { coll := collection() defer coll.Close() for { ct, err := coll.Find(bson.M{"appname": cont.AppName}).Count() if err != nil { c.Fatal(err) } if ct == 0 { ok <- true return } runtime.Gosched() } }() select { case <-ok: case <-time.After(10e9): c.Fatal("Timed out waiting for the container to be destroyed (10 seconds)") } c.Assert(rtesting.FakeRouter.HasBackend("myapp"), gocheck.Equals, false) }
func (s *AmazonServer) SetUp(c *gocheck.C) { auth, err := aws.EnvAuth() if err != nil { c.Fatal(err) } s.auth = auth }
func (s *S) TestUndirectedConnectedComponent(c *check.C) { g := undirected(c, uv) f := func(_ Edge) bool { return true } c.Check(len(g.ConnectedComponents(f)), check.Equals, 1) g.DeleteByID(deleteNode) nodes, edges := make(map[int]int), make(map[int]int) for _, n := range uv { nodes[n.u], nodes[n.v] = 1, 1 edges[n.u]++ edges[n.v]++ } c.Check(g.Order(), check.Equals, len(nodes)-1) c.Check(g.Size(), check.Equals, len(uv)-edges[deleteNode]) cc := g.ConnectedComponents(f) c.Check(len(cc), check.Equals, 2) for i, p := range cc { c.Check(len(p), check.Equals, partSizes[i]) for _, n := range p { c.Check(parts[n.ID()], check.Equals, i) } g0, err := p.BuildUndirected(true) if err != nil { c.Fatal(err) } c.Check(g0.Order(), check.Equals, partSizes[i]) c.Check(g0.Size(), check.Equals, partSizes[i]) } }
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 *S) TestCollectStatusIDChangeDisabledELB(c *gocheck.C) { tmpdir, err := commandmocker.Add("juju", collectOutput) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) p := JujuProvisioner{} conn, collection := p.unitsCollection() defer conn.Close() err = collection.Insert(instance{UnitName: "as_i_rise/0", InstanceId: "i-00000239"}) 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 } time.Sleep(1e3) } }() select { case <-done: case <-time.After(5e9): c.Fatal("Did not update the unit after 5 seconds.") } }
func (s *DynamoDBTest) WaitUntilStatus(c *gocheck.C, status string) { // We should wait until the table is in specified status because a real DynamoDB has some delay for ready done := make(chan bool) timeout := time.After(TIMEOUT) go func() { for { select { case <-done: return default: desc, err := s.table.DescribeTable() if err != nil { c.Fatal(err) } if desc.TableStatus == status { done <- true return } time.Sleep(5 * time.Second) } } }() select { case <-done: break case <-timeout: c.Errorf("Expect a status to be %s, but timed out", status) close(done) } }
func (s *S) TestProvisionerProvision(c *gocheck.C) { config.Set("local:authorized-key-path", "somepath") rfs := &fstesting.RecordingFs{} fsystem = rfs defer func() { fsystem = nil }() f, _ := os.Open("testdata/dnsmasq.leases") data, err := ioutil.ReadAll(f) c.Assert(err, gocheck.IsNil) file, err := rfs.Create("/var/lib/misc/dnsmasq.leases") c.Assert(err, gocheck.IsNil) _, err = file.Write(data) c.Assert(err, gocheck.IsNil) tmpdir, err := commandmocker.Add("sudo", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) sshTempDir, err := commandmocker.Add("ssh", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(sshTempDir) scpTempDir, err := commandmocker.Add("scp", "$*") c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(scpTempDir) var p LocalProvisioner app := testing.NewFakeApp("myapp", "python", 0) defer p.collection().Remove(bson.M{"name": "myapp"}) c.Assert(p.Provision(app), gocheck.IsNil) ok := make(chan bool, 1) go func() { for { coll := s.conn.Collection(s.collName) ct, err := coll.Find(bson.M{"name": "myapp", "status": provision.StatusStarted}).Count() if err != nil { c.Fatal(err) } if ct > 0 { ok <- true return } time.Sleep(1e3) } }() select { case <-ok: case <-time.After(10e9): c.Fatal("Timed out waiting for the container to be provisioned (10 seconds)") } c.Assert(commandmocker.Ran(tmpdir), gocheck.Equals, true) expected := "lxc-create -t ubuntu -n myapp -- -S somepath" expected += "lxc-start --daemon -n myapp" expected += "service nginx restart" c.Assert(commandmocker.Output(tmpdir), gocheck.Equals, expected) var unit provision.Unit err = s.conn.Collection(s.collName).Find(bson.M{"name": "myapp"}).One(&unit) c.Assert(err, gocheck.IsNil) c.Assert(unit.Ip, gocheck.Equals, "10.10.10.15") }
func (s *S) TestFeaturise(c *check.C) { for _, t := range T { f, err := featureOf(ps, t.start, t.end, false) if err != nil { c.Fatal(err) } c.Check(f.String(), check.Equals, t.result) } }
func (s *ELBSuite) TestCollectStatusWithELBAndIDChange(c *gocheck.C) { a := testing.NewFakeApp("symfonia", "symfonia", 0) p := JujuProvisioner{} router, err := Router() c.Assert(err, gocheck.IsNil) err = router.AddBackend(a.GetName()) c.Assert(err, gocheck.IsNil) defer router.RemoveBackend(a.GetName()) id1 := s.server.NewInstance() defer s.server.RemoveInstance(id1) id2 := s.server.NewInstance() defer s.server.RemoveInstance(id2) id3 := s.server.NewInstance() defer s.server.RemoveInstance(id3) collection := p.unitsCollection() defer collection.Close() err = collection.Insert(instance{UnitName: "symfonia/0", InstanceID: id3}) c.Assert(err, gocheck.IsNil) err = router.AddRoute(a.GetName(), id3) c.Assert(err, gocheck.IsNil) err = router.AddRoute(a.GetName(), id2) c.Assert(err, gocheck.IsNil) q := bson.M{"_id": bson.M{"$in": []string{"symfonia/0", "symfonia/1", "symfonia/2", "raise/0"}}} defer collection.Remove(q) output := strings.Replace(simpleCollectOutput, "i-00004444", id1, 1) output = strings.Replace(output, "i-00004445", id2, 1) tmpdir, err := commandmocker.Add("juju", output) c.Assert(err, gocheck.IsNil) defer commandmocker.Remove(tmpdir) _, err = p.CollectStatus() c.Assert(err, gocheck.IsNil) done := make(chan int8) go func() { for { q := bson.M{"_id": "symfonia/0", "instanceid": id1} 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 save the unit after 5 seconds.") } resp, err := s.client.DescribeLoadBalancers(a.GetName()) c.Assert(err, gocheck.IsNil) c.Assert(resp.LoadBalancerDescriptions, gocheck.HasLen, 1) instances := resp.LoadBalancerDescriptions[0].Instances c.Assert(instances, gocheck.HasLen, 2) c.Assert(instances[0].InstanceId, gocheck.Equals, id2) c.Assert(instances[1].InstanceId, gocheck.Equals, id1) }
func (s *LiveSuite) SetUpSuite(c *gocheck.C) { if !Amazon { c.Skip("amazon tests not enabled (-amazon flag)") } auth, err := aws.EnvAuth() if err != nil { c.Fatal(err.Error()) } s.auth = auth }
func (s *SuiteI) SetUpSuite(c *gocheck.C) { if !*integration { c.Skip("Integration tests not enabled (-int flag)") } auth, err := aws.EnvAuth() if err != nil { c.Fatal(err) } s.auth = auth }
func (s *S) TestNotifyFiltered(c *gocheck.C) { var logs struct { l []interface{} sync.Mutex } app := App{Name: "fade"} l, err := NewLogListener(&app, Applog{Source: "tsuru", Unit: "unit1"}) c.Assert(err, gocheck.IsNil) defer l.Close() go func() { for log := range l.C { logs.Lock() logs.l = append(logs.l, log) logs.Unlock() } }() t := time.Date(2014, 7, 10, 15, 0, 0, 0, time.UTC) ms := []interface{}{ Applog{Date: t, Message: "Something went wrong. Check it out:", Source: "tsuru", Unit: "unit1"}, Applog{Date: t, Message: "This program has performed an illegal operation.", Source: "other", Unit: "unit1"}, Applog{Date: t, Message: "Last one.", Source: "tsuru", Unit: "unit2"}, } notify(app.Name, ms) done := make(chan bool, 1) q := make(chan bool) go func(quit chan bool) { for _ = range time.Tick(1e3) { select { case <-quit: return default: } logs.Lock() if len(logs.l) == 1 { logs.Unlock() done <- true return } logs.Unlock() } }(q) select { case <-done: case <-time.After(2e9): defer close(q) c.Fatal("Timed out.") } logs.Lock() defer logs.Unlock() expected := []interface{}{ Applog{Date: t, Message: "Something went wrong. Check it out:", Source: "tsuru", Unit: "unit1"}, } c.Assert(logs.l, gocheck.DeepEquals, expected) }
func (s *TestSuite) TestCustomJSONMarshals(c *gocheck.C) { /* Heartbeat (for Heartbeat request/response) */ var hb, hB *Heartbeat hb = &Heartbeat{time.Now()} js, err := hb.MarshalJSON() c.Assert(err, gocheck.IsNil) err = json.Unmarshal(js, &hB) c.Assert(err, gocheck.IsNil) if hb.Timestamp.UnixNano()/1e6 != hB.Timestamp.UnixNano()/1e6 { c.Fatal("Timestamp changed during Marshal/Unmarshal") } }
func (s *UpgradeSuite) TestDowngradeOnMasterWhenOtherStateServerDoesntStartUpgrade(c *gc.C) { // This test checks that the master triggers a downgrade if one of // the other state server fails to signal it is ready for upgrade. // // This test is functional, ensuring that the upgrader worker // terminates the machine agent with the UpgradeReadyError which // makes the downgrade happen. // Speed up the watcher frequency to make the test much faster. s.PatchValue(&watcher.Period, 200*time.Millisecond) // Provide (fake) tools so that the upgrader has something to downgrade to. envtesting.AssertUploadFakeToolsVersions(c, s.Environ.Storage(), s.oldVersion) // Only the first machine is going to be ready for upgrade. machineIdA, machineIdB, _ := s.createUpgradingStateServers(c) // One of the other state servers is ready for upgrade (but machine C doesn't). info, err := s.State.EnsureUpgradeInfo(machineIdB, s.oldVersion.Number, version.Current.Number) c.Assert(err, gc.IsNil) agent := s.newAgentFromMachineId(c, machineIdA) defer agent.Stop() s.machineIsMaster = true var agentErr error agentDone := make(chan bool) go func() { agentErr = agent.Run(nil) close(agentDone) }() select { case <-agentDone: upgradeReadyErr, ok := agentErr.(*upgrader.UpgradeReadyError) if !ok { c.Fatalf("didn't see UpgradeReadyError, instead got: %v", agentErr) } // Confirm that the downgrade is back to the previous version. c.Assert(upgradeReadyErr.OldTools, gc.Equals, version.Current) c.Assert(upgradeReadyErr.NewTools, gc.Equals, s.oldVersion) case <-time.After(coretesting.LongWait): c.Fatal("machine agent did not exit as expected") } // UpgradeInfo doc should now be archived. err = info.Refresh() c.Assert(err, gc.ErrorMatches, "current upgrade info not found") }
func (s *S) TestUndirectedMerge(c *check.C) { g := undirected(c, uv) order := g.Order() size := g.Size() err := g.Merge(g.Node(7), g.Node(9)) if err != nil { c.Fatal(err) } conn, err := g.ConnectingEdges(g.Node(7), g.Node(7)) if err != nil { c.Fatal(err) } c.Check(len(conn), check.Equals, 1) c.Check(conn[0].String(), check.Equals, "7--7") c.Check(g.Order(), check.Equals, order-1) c.Check(g.Size(), check.Equals, size) c.Check(g.Node(7).Degree(), check.Equals, 6) c.Check(len(g.Node(7).Edges()), check.Equals, 5) err = g.Merge(g.Node(6), g.Node(3)) if err != nil { c.Fatal(err) } conn, err = g.ConnectingEdges(g.Node(7), g.Node(6)) if err != nil { c.Fatal(err) } c.Check(len(conn), check.Equals, 2) }
func (s *PublishSuite) TestInferURL(c *gc.C) { addMeta(c, s.branch, "") cmd := &PublishCommand{} cmd.ChangePushLocation(func(location string) string { c.Assert(location, gc.Equals, "lp:charms/precise/wordpress") c.SucceedNow() panic("unreachable") }) _, err := testing.RunCommandInDir(c, envcmd.Wrap(cmd), []string{"precise/wordpress"}, s.dir) c.Assert(err, gc.IsNil) c.Fatal("shouldn't get here; location closure didn't run?") }
func (s *S) TestProvisionerDestroy(c *gocheck.C) { fexec := &etesting.FakeExecutor{} execut = fexec defer func() { execut = nil }() w := new(bytes.Buffer) l := stdlog.New(w, "", stdlog.LstdFlags) log.SetLogger(l) app := testing.NewFakeApp("myapp", "python", 1) u := provision.Unit{ Name: app.ProvisionUnits()[0].GetName(), AppName: app.GetName(), Machine: app.ProvisionUnits()[0].GetMachine(), InstanceId: app.ProvisionUnits()[0].GetInstanceId(), Status: provision.StatusCreating, } err := s.conn.Collection(s.collName).Insert(&u) c.Assert(err, gocheck.IsNil) img := image{Name: app.GetName()} err = s.conn.Collection(s.imageCollName).Insert(&img) c.Assert(err, gocheck.IsNil) var p DockerProvisioner c.Assert(p.Destroy(app), gocheck.IsNil) ok := make(chan bool, 1) go func() { for { coll := s.conn.Collection(s.collName) ct, err := coll.Find(bson.M{"name": u.Name}).Count() if err != nil { c.Fatal(err) } if ct == 0 { ok <- true return } runtime.Gosched() } }() select { case <-ok: case <-time.After(10e9): c.Error("Timed out waiting for the container to be destroyed (10 seconds)") } args := []string{"stop", "i-01"} c.Assert(fexec.ExecutedCmd("docker", args), gocheck.Equals, true) args = []string{"rm", "i-01"} c.Assert(fexec.ExecutedCmd("docker", args), gocheck.Equals, true) }
func (s *S) TestUndirectedConnected(c *check.C) { g := undirected(c, uv) n := g.Nodes() conns := 0 for i := 0; i < g.Order(); i++ { for j := 0; j < g.Order(); j++ { if ok, err := g.Connected(n[i], n[j]); ok { conns++ } else if err != nil { c.Fatal(err) } } } c.Check(conns, check.Equals, 2*g.Size()+g.Order()) }
func (s *MgoSuite) TearDownTest(c *gc.C) { MgoServer.Reset() s.Session.Close() for i := 0; ; i++ { stats := mgo.GetStats() if stats.SocketsInUse == 0 && stats.SocketsAlive == 0 { break } if i == 20 { c.Fatal("Test left sockets in a dirty state") } c.Logf("Waiting for sockets to die: %d in use, %d alive", stats.SocketsInUse, stats.SocketsAlive) time.Sleep(500 * time.Millisecond) } }
func (s *S) TestNotify(c *gocheck.C) { var logs struct { l []interface{} sync.Mutex } app := App{Name: "fade"} l := NewLogListener(&app) defer l.Close() go func() { for log := range l.C { logs.Lock() logs.l = append(logs.l, log) logs.Unlock() } }() ms := []interface{}{ Applog{Date: time.Now(), Message: "Something went wrong. Check it out:", Source: "tsuru"}, Applog{Date: time.Now(), Message: "This program has performed an illegal operation.", Source: "tsuru"}, } notify(app.Name, ms) done := make(chan bool, 1) q := make(chan bool) go func(quit chan bool) { for _ = range time.Tick(1e3) { select { case <-quit: return default: } logs.Lock() if len(logs.l) == 2 { logs.Unlock() done <- true return } logs.Unlock() } }(q) select { case <-done: case <-time.After(2e9): defer close(q) c.Fatal("Timed out.") } logs.Lock() defer logs.Unlock() c.Assert(logs.l, gocheck.DeepEquals, ms) }
func (s *S) TestProvisionerDestroy(c *gocheck.C) { fexec := &etesting.FakeExecutor{} setExecut(fexec) defer setExecut(nil) w := new(bytes.Buffer) l := stdlog.New(w, "", stdlog.LstdFlags) log.SetLogger(l) app := testing.NewFakeApp("myapp", "python", 1) cont := container{ Id: app.ProvisionUnits()[0].GetName(), AppName: app.GetName(), } err := s.conn.Collection(s.collName).Insert(cont) c.Assert(err, gocheck.IsNil) defer s.conn.Collection(s.collName).RemoveId(cont.Id) s.conn.Collection(s.collName).Insert(container{Id: "something-01", AppName: app.GetName()}) defer s.conn.Collection(s.collName).RemoveId("something-01") img := image{Name: app.GetName()} err = s.conn.Collection(s.imageCollName).Insert(&img) c.Assert(err, gocheck.IsNil) var p dockerProvisioner p.Provision(app) c.Assert(p.Destroy(app), gocheck.IsNil) ok := make(chan bool, 1) go func() { coll := s.conn.Collection(s.collName) for { ct, err := coll.Find(bson.M{"appname": cont.AppName}).Count() if err != nil { c.Fatal(err) } if ct == 0 { ok <- true return } runtime.Gosched() } }() select { case <-ok: case <-time.After(10e9): c.Fatal("Timed out waiting for the container to be destroyed (10 seconds)") } args := []string{"rm", "myapp/0"} c.Assert(fexec.ExecutedCmd("docker", args), gocheck.Equals, true) c.Assert(rtesting.FakeRouter.HasBackend("myapp"), gocheck.Equals, false) }
func (s *S) TestUndirectedBuild(c *check.C) { g := undirected(c, uv) g0, err := g.Nodes().BuildUndirected(false) if err != nil { c.Fatal(err) } for _, n := range g.Nodes() { id := n.ID() c.Check(g0.Node(id).ID(), check.Equals, g.Node(id).ID()) } for i := range g.Edges() { c.Check(g0.Edge(i).ID(), check.Equals, i) c.Check(g0.Edge(i).ID(), check.Equals, g.Edge(i).ID()) c.Check(g0.Edge(i).Head().ID(), check.Equals, g.Edge(i).Head().ID()) c.Check(g0.Edge(i).Tail().ID(), check.Equals, g.Edge(i).Tail().ID()) } }