func (s *S) SetUpTest(c *check.C) {
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Apps().Database)
os.Setenv("TSURU_TARGET", "http://localhost")
}
func init() {
suite := &routertest.RouterSuite{
SetUpSuiteFunc: func(c *check.C) {
config.Set("routers:galeb:username", "myusername")
config.Set("routers:galeb:password", "mypassword")
config.Set("routers:galeb:domain", "galeb.com")
config.Set("routers:galeb:type", "galeb")
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "router_galebv2_tests")
},
}
var server *httptest.Server
suite.SetUpTestFunc = func(c *check.C) {
handler, err := NewFakeGalebServer()
c.Assert(err, check.IsNil)
server = httptest.NewServer(handler)
config.Set("routers:galeb:api-url", server.URL+"/api")
gRouter, err := createRouter("routers:galeb")
c.Assert(err, check.IsNil)
suite.Router = gRouter
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Collection("router_galebv2_tests").Database)
}
suite.TearDownTestFunc = func(c *check.C) {
server.Close()
}
check.Suite(suite)
}
func (s *S) SetUpTest(c *check.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_events_migrate_tests")
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
err = dbtest.ClearAllCollections(conn.Events().Database)
c.Assert(err, check.IsNil)
config.Set("routers:fake:type", "fake")
err = (&app.Plan{Name: "default", Router: "fake", CpuShare: 100, Default: true}).Save()
c.Assert(err, check.IsNil)
nativeScheme := auth.ManagedScheme(native.NativeScheme{})
app.AuthScheme = nativeScheme
s.user = &auth.User{Email: "*****@*****.**", Password: "******"}
_, err = nativeScheme.Create(s.user)
c.Assert(err, check.IsNil)
s.team = &auth.Team{Name: "angra"}
err = conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
provision.DefaultProvisioner = "fake"
provisiontest.ProvisionerInstance.Reset()
opts := provision.AddPoolOptions{Name: "test1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
}
func (s *S) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
rand.Seed(0)
config.Set("swarm:swarm-port", 0)
err := dbtest.ClearAllCollections(s.conn.Apps().Database)
c.Assert(err, check.IsNil)
err = provision.AddPool(provision.AddPoolOptions{Name: "bonehunters", Default: true, Provisioner: "swarm"})
c.Assert(err, check.IsNil)
p := app.Plan{
Name: "default",
Router: "fake",
Default: true,
CpuShare: 100,
}
err = p.Save()
c.Assert(err, check.IsNil)
s.p = &swarmProvisioner{}
err = s.p.Initialize()
c.Assert(err, check.IsNil)
s.user = &auth.User{Email: "*****@*****.**", Password: "******", Quota: quota.Unlimited}
nativeScheme := auth.ManagedScheme(native.NativeScheme{})
app.AuthScheme = nativeScheme
_, err = nativeScheme.Create(s.user)
c.Assert(err, check.IsNil)
s.team = &auth.Team{Name: "admin"}
c.Assert(err, check.IsNil)
err = s.conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
s.token, err = nativeScheme.Login(map[string]string{"email": s.user.Email, "password": "******"})
c.Assert(err, check.IsNil)
}
func (s *InstanceSuite) SetUpTest(c *check.C) {
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.user = &auth.User{Email: "*****@*****.**", Password: "******"}
s.team = &auth.Team{Name: "Raul"}
s.conn.Users().Insert(s.user)
s.conn.Teams().Insert(s.team)
}
func (s *S) TearDownTest(c *check.C) {
err := dbtest.ClearAllCollections(s.conn.Users().Database)
c.Assert(err, check.IsNil)
s.conn.Close()
cost = 0
tokenExpire = 0
}
func (s *ConsumptionSuite) SetUpTest(c *check.C) {
repositorytest.Reset()
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_consumption_test")
config.Set("auth:hash-cost", 4)
config.Set("repo-manager", "fake")
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.team = &auth.Team{Name: "tsuruteam"}
err = s.conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
s.token = customUserWithPermission(c, "consumption-master-user", permission.Permission{
Scheme: permission.PermServiceInstance,
Context: permission.Context(permission.CtxTeam, s.team.Name),
}, permission.Permission{
Scheme: permission.PermServiceRead,
Context: permission.Context(permission.CtxTeam, s.team.Name),
})
s.user, err = s.token.User()
c.Assert(err, check.IsNil)
app.AuthScheme = nativeScheme
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
}
func (s *S) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
repositorytest.Reset()
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.logConn, err = db.LogConn()
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
app.AuthScheme = nativeScheme
p := app.Platform{Name: "zend"}
s.conn.Platforms().Insert(p)
s.Pool = "test1"
opts := provision.AddPoolOptions{Name: "test1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
repository.Manager().CreateUser(s.adminuser.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func (s *S) SetUpTest(c *check.C) {
queue.ResetQueue()
err := rebuild.RegisterTask(func(appName string) (rebuild.RebuildApp, error) {
a, err := app.GetByName(appName)
if err == app.ErrAppNotFound {
return nil, nil
}
return a, err
})
c.Assert(err, check.IsNil)
routertest.FakeRouter.Reset()
provisiontest.ProvisionerInstance.Reset()
err = dbtest.ClearAllCollections(s.conn.Apps().Database)
c.Assert(err, check.IsNil)
s.user = &auth.User{Email: "*****@*****.**", Password: "******", Quota: quota.Unlimited}
nativeScheme := auth.ManagedScheme(native.NativeScheme{})
app.AuthScheme = nativeScheme
_, err = nativeScheme.Create(s.user)
c.Assert(err, check.IsNil)
s.team = &auth.Team{Name: "admin"}
c.Assert(err, check.IsNil)
err = s.conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
err = provision.AddPool(provision.AddPoolOptions{
Name: "p1",
Default: true,
Provisioner: "fake",
})
c.Assert(err, check.IsNil)
}
func (s *ActionsSuite) SetUpTest(c *check.C) {
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
repositorytest.Reset()
}
func (s *S) SetUpTest(c *check.C) {
s.provisioner.Reset()
repositorytest.Reset()
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.createUserAndTeam(c)
platform := Platform{Name: "python"}
s.conn.Platforms().Insert(platform)
s.defaultPlan = Plan{
Name: "default-plan",
Memory: 1024,
Swap: 1024,
CpuShare: 100,
Default: true,
}
err := s.conn.Plans().Insert(s.defaultPlan)
c.Assert(err, check.IsNil)
s.Pool = "pool1"
opts := provision.AddPoolOptions{Name: s.Pool}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func init() {
suite := &routertest.RouterSuite{
SetUpSuiteFunc: func(c *check.C) {
config.Set("routers:fusis:domain", "fusis.com")
config.Set("routers:fusis:type", "fusis")
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "router_fusis_tests")
},
}
var fakeServer *fusisTesting.FakeFusisServer
suite.SetUpTestFunc = func(c *check.C) {
var err error
fakeServer = fusisTesting.NewFakeFusisServer()
config.Set("routers:fusis:api-url", fakeServer.URL)
fRouter, err := createRouter("fusis", "routers:fusis")
c.Assert(err, check.IsNil)
suite.Router = fRouter
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Collection("router_fusis_tests").Database)
}
suite.TearDownTestFunc = func(c *check.C) {
fakeServer.Close()
}
check.Suite(suite)
}
func (s *S) TearDownSuite(c *check.C) {
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
err = dbtest.ClearAllCollections(conn.Apps().Database)
c.Assert(err, check.IsNil)
s.server.Stop()
}
func (s *BindSuite) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.user = auth.User{Email: "*****@*****.**"}
s.user.Create()
s.team = auth.Team{Name: "metallica", Users: []string{s.user.Email}}
s.conn.Teams().Insert(s.team)
}
func (s *S) SetUpTest(c *check.C) {
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
err = dbtest.ClearAllCollections(conn.Apps().Database)
c.Assert(err, check.IsNil)
routertest.FakeRouter.Reset()
}
func (s *S) SetUpTest(c *check.C) {
config.ReadConfigFile("testdata/tsuru.conf")
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Apps().Database)
repositorytest.Reset()
}
func (s *PlatformSuite) SetUpTest(c *check.C) {
provisiontest.ExtensibleInstance.Reset()
repositorytest.Reset()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Apps().Database)
}
func (s *PlatformSuite) SetUpTest(c *check.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_platform_test")
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Apps().Database)
}
func (s *HandlersSuite) TearDownSuite(c *check.C) {
s.clusterSess.Close()
coll := mainDockerProvisioner.collection()
defer coll.Close()
err := dbtest.ClearAllCollections(coll.Database)
c.Assert(err, check.IsNil)
s.conn.Close()
}
func (s *LimiterSuite) SetUpTest(c *check.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "provision_limiter_tests_s")
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
err = dbtest.ClearAllCollections(conn.Apps().Database)
c.Assert(err, check.IsNil)
}
func (s *EventSuite) SetUpTest(c *check.C) {
repositorytest.Reset()
var err error
routertest.FakeRouter.Reset()
err = dbtest.ClearAllCollections(s.conn.Apps().Database)
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
s.conn.Platforms().Insert(app.Platform{Name: "python"})
}
func (s *PlatformSuite) SetUpTest(c *check.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_platform_test")
var err error
app.AuthScheme = nativeScheme
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
}
func (s *LogSuite) SetUpTest(c *check.C) {
repositorytest.Reset()
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.logConn, err = db.LogConn()
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
}
func (s *S) SetUpTest(c *check.C) {
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Apps().Database)
s.server, err = dtesting.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
s.p, err = newFakeDockerProvisioner(s.server.URL())
c.Assert(err, check.IsNil)
}
func (s *S) SetUpTest(c *check.C) {
HealerInstance = nil
provisiontest.ProvisionerInstance.Reset()
routertest.FakeRouter.Reset()
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Apps().Database)
iaas.ResetAll()
}
func (s *PlatformSuite) SetUpTest(c *check.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_platform_test")
var err error
app.AuthScheme = nativeScheme
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
provision.DefaultProvisioner = "fake-extensible"
provisiontest.ExtensibleInstance.Reset()
}
func (s *S) SetUpTest(c *check.C) {
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Collection("router_vulcand_tests").Database)
s.engine = memng.New(registry.GetRegistry())
scrollApp := scroll.NewApp()
api.InitProxyController(s.engine, &supervisor.Supervisor{}, scrollApp)
s.vulcandServer = httptest.NewServer(scrollApp.GetHandler())
config.Set("routers:vulcand:api-url", s.vulcandServer.URL)
}
func (s *ProvisionSuite) SetUpTest(c *check.C) {
repositorytest.Reset()
var err error
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_api_service_provision_test")
config.Set("auth:hash-cost", bcrypt.MinCost)
config.Set("repo-manager", "fake")
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.createUserAndTeam(c)
}
func (s *DeploySuite) SetUpTest(c *check.C) {
repositorytest.Reset()
err := dbtest.ClearAllCollections(s.conn.Apps().Database)
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
s.conn.Platforms().Insert(app.Platform{Name: "python"})
err = provision.AddPool("pool1", false)
c.Assert(err, check.IsNil)
user, err := s.token.User()
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(user.Email)
}
func (s *S) SetUpTest(c *check.C) {
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
dbtest.ClearAllCollections(conn.Apps().Database)
repositorytest.Reset()
user := &auth.User{Email: "*****@*****.**", Password: "******"}
_, err = nativeScheme.Create(user)
c.Assert(err, check.IsNil)
s.token, err = nativeScheme.Login(map[string]string{"email": user.Email, "password": "******"})
c.Assert(err, check.IsNil)
s.app = &app.App{Name: "app"}
}