"github.com/flynn/flynn/cli/config"
"github.com/flynn/flynn/controller/client"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/host/resource"
"github.com/flynn/flynn/pkg/attempt"
hh "github.com/flynn/flynn/pkg/httphelper"
"github.com/flynn/flynn/pkg/random"
"github.com/flynn/flynn/pkg/tlscert"
c "github.com/flynn/go-check"
)
type CLISuite struct {
Helper
}
var _ = c.ConcurrentSuite(&CLISuite{})
const UUIDRegex = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
func (s *CLISuite) flynn(t *c.C, args ...string) *CmdResult {
return flynn(t, "/", args...)
}
func (s *CLISuite) TestCreateAppNoGit(t *c.C) {
dir := t.MkDir()
name := random.String(30)
t.Assert(flynn(t, dir, "create", name), Outputs, fmt.Sprintf("Created %s\n", name))
}
func testApp(s *CLISuite, t *c.C, remote string) {
app := s.newGitRepo(t, "")
import (
"time"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/types"
"github.com/flynn/flynn/pkg/attempt"
"github.com/flynn/flynn/pkg/stream"
c "github.com/flynn/go-check"
)
type DeployerSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&DeployerSuite{})
type testDeploy struct {
s *DeployerSuite
t *c.C
deployment *ct.Deployment
deployEvents chan *ct.DeploymentEvent
deployStream stream.Stream
jobEvents chan *ct.Job
jobStream stream.Stream
}
func (t *testDeploy) cleanup() {
t.jobStream.Close()
t.deployStream.Close()
}
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/types"
"github.com/flynn/flynn/pkg/cluster"
"github.com/flynn/flynn/pkg/dialer"
"github.com/flynn/flynn/pkg/exec"
hh "github.com/flynn/flynn/pkg/httphelper"
"github.com/flynn/flynn/pkg/random"
"github.com/flynn/flynn/pkg/schedutil"
c "github.com/flynn/go-check"
)
type HostSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&HostSuite{})
func (s *HostSuite) TestGetNonExistentJob(t *c.C) {
cluster := s.clusterClient(t)
hosts, err := cluster.Hosts()
t.Assert(err, c.IsNil)
// Getting a non-existent job should error
_, err = hosts[0].GetJob("i-dont-exist")
t.Assert(hh.IsObjectNotFoundError(err), c.Equals, true)
}
func (s *HostSuite) TestAddFailingJob(t *c.C) {
// get a host and watch events
hosts, err := s.clusterClient(t).Hosts()
t.Assert(err, c.IsNil)
"strings"
"text/template"
"github.com/flynn/flynn/controller/client"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/pkg/random"
tc "github.com/flynn/flynn/test/cluster"
"github.com/flynn/flynn/updater/types"
c "github.com/flynn/go-check"
)
type ReleaseSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&ReleaseSuite{})
func (s *ReleaseSuite) addReleaseHosts(t *c.C) *tc.BootResult {
res, err := testCluster.AddReleaseHosts()
t.Assert(err, c.IsNil)
t.Assert(res.Instances, c.HasLen, 4)
return res
}
var releaseScript = template.Must(template.New("release-script").Delims("[[", "]]").Parse(`
export TUF_TARGETS_PASSPHRASE="flynn-test"
export TUF_SNAPSHOT_PASSPHRASE="flynn-test"
export TUF_TIMESTAMP_PASSPHRASE="flynn-test"
export GOPATH=~/go
src="${GOPATH}/src/github.com/flynn/flynn"
package main
import (
"path/filepath"
"strings"
c "github.com/flynn/go-check"
)
type RedisSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&RedisSuite{})
func (s *RedisSuite) TestDumpRestore(t *c.C) {
a := s.newCliTestApp(t)
res := a.flynn("resource", "add", "redis")
t.Assert(res, Succeeds)
id := strings.Split(res.Output, " ")[2]
release, err := s.controllerClient(t).GetAppRelease(a.id)
t.Assert(err, c.IsNil)
t.Assert(release.Env["FLYNN_REDIS"], c.Not(c.Equals), "")
a.waitForService(release.Env["FLYNN_REDIS"])
t.Assert(a.flynn("redis", "redis-cli", "set", "foo", "bar"), Succeeds)
file := filepath.Join(t.MkDir(), "dump.rdb")
import (
"fmt"
"path/filepath"
"strings"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/pkg/postgres"
c "github.com/flynn/go-check"
)
type PostgresSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&PostgresSuite{})
// Check postgres config to avoid regressing on https://github.com/flynn/flynn/issues/101
func (s *PostgresSuite) TestSSLRenegotiationLimit(t *c.C) {
query := flynn(t, "/", "-a", "controller", "pg", "psql", "--", "-c", "SHOW ssl_renegotiation_limit")
t.Assert(query, SuccessfulOutputContains, "ssl_renegotiation_limit \n-------------------------\n 0\n(1 row)")
}
func (s *PostgresSuite) TestDumpRestore(t *c.C) {
r := s.newGitRepo(t, "empty")
t.Assert(r.flynn("create"), Succeeds)
res := r.flynn("resource", "add", "postgres")
t.Assert(res, Succeeds)
id := strings.Split(res.Output, " ")[2]
package main
import (
"bytes"
"fmt"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/pkg/cluster"
c "github.com/flynn/go-check"
)
type TaffyDeploySuite struct {
Helper
}
var _ = c.ConcurrentSuite(&TaffyDeploySuite{})
func (s *TaffyDeploySuite) deployWithTaffy(t *c.C, app *ct.App, env, meta, github map[string]string) {
client := s.controllerClient(t)
taffyRelease, err := client.GetAppRelease("taffy")
t.Assert(err, c.IsNil)
args := []string{
"/bin/taffy",
app.Name,
github["clone_url"],
github["branch"],
github["rev"],
}
"database/sql"
"fmt"
"path/filepath"
"strings"
"github.com/flynn/flynn/appliance/mariadb"
ct "github.com/flynn/flynn/controller/types"
c "github.com/flynn/go-check"
_ "github.com/go-sql-driver/mysql"
)
type MariaDBSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&MariaDBSuite{})
// Sirenia integration tests
var sireniaMariaDB = sireniaDatabase{
appName: "mariadb",
serviceKey: "FLYNN_MYSQL",
hostKey: "MYSQL_HOST",
initDb: func(t *c.C, r *ct.Release, d *sireniaDeploy) {
dsn := &mariadb.DSN{
Host: fmt.Sprintf("leader.%s.discoverd", d.name) + ":3306",
User: "******",
Password: r.Env["MYSQL_PWD"],
Database: "mysql",
}
db, err := sql.Open("mysql", dsn.String())
t.Assert(err, c.IsNil)
"encoding/json"
"net/http"
"time"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/types"
"github.com/flynn/flynn/pkg/status"
c "github.com/flynn/go-check"
)
type HealthcheckSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&HealthcheckSuite{})
func (s *HealthcheckSuite) createAppWithService(t *c.C, process string, service *host.Service) (*ct.App, *ct.Release) {
app, release := s.createApp(t)
release.ID = ""
proctype := release.Processes[process]
proctype.Ports = []ct.Port{{
Proto: "tcp",
Service: service,
}}
release.Processes[process] = proctype
t.Assert(s.controllerClient(t).CreateRelease(release), c.IsNil)
t.Assert(s.controllerClient(t).SetAppRelease(app.ID, release.ID), c.IsNil)
return app, release
import (
"fmt"
"path/filepath"
"strings"
ct "github.com/flynn/flynn/controller/types"
c "github.com/flynn/go-check"
"gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
)
type MongoDBSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&MongoDBSuite{})
type mgoLogger struct {
t *c.C
}
func (l mgoLogger) Output(calldepth int, s string) error {
debugf(l.t, s)
return nil
}
func (s *MongoDBSuite) TestDumpRestore(t *c.C) {
r := s.newGitRepo(t, "empty")
t.Assert(r.flynn("create"), Succeeds)
res := r.flynn("resource", "add", "mongodb")
"strings"
"syscall"
"time"
"github.com/docker/docker/pkg/term"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/pkg/attempt"
c "github.com/flynn/go-check"
"github.com/kr/pty"
)
type GitDeploySuite struct {
Helper
}
var _ = c.ConcurrentSuite(&GitDeploySuite{})
var Attempts = attempt.Strategy{
Total: 60 * time.Second,
Delay: 500 * time.Millisecond,
}
func (s *GitDeploySuite) TestEnvDir(t *c.C) {
r := s.newGitRepo(t, "env-dir")
t.Assert(r.flynn("create"), Succeeds)
t.Assert(r.flynn("env", "set", "FOO=bar", "BUILDPACK_URL=https://github.com/kr/heroku-buildpack-inline"), Succeeds)
push := r.git("push", "flynn", "master")
t.Assert(push, SuccessfulOutputContains, "bar")
}
