func TestNameCache(t *testing.T) {
assert := assert.New(t)
sous.Log.Debug.SetOutput(os.Stdout)
ResetSingularity()
defer ResetSingularity()
drc := docker_registry.NewClient()
drc.BecomeFoolishlyTrusting()
db, err := docker.GetDatabase(&docker.DBConfig{
Driver: "sqlite3_sous",
Connection: docker.InMemoryConnection("testnamecache"),
})
if err != nil {
t.Fatal(err)
}
nc := docker.NewNameCache("", drc, db)
repoOne := "https://github.com/opentable/one.git"
manifest(nc, "opentable/one", "test-one", repoOne, "1.1.1")
cn, err := nc.GetCanonicalName(BuildImageName("opentable/one", "1.1.1"))
if err != nil {
assert.FailNow(err.Error())
}
labels, err := drc.LabelsForImageName(cn)
if assert.NoError(err) {
assert.Equal("1.1.1", labels[docker.DockerVersionLabel])
}
}
func TestProductionReady(t *testing.T) {
assert := assert.New(t)
bc := BuildConfig{
Strict: true,
Tag: "1.2.3",
Repo: "github.com/opentable/present",
Revision: "abcdef",
Context: &BuildContext{
Sh: &shell.Sh{},
Source: SourceContext{
RemoteURL: "github.com/opentable/present",
RemoteURLs: []string{
"github.com/opentable/present",
"github.com/opentable/also",
},
Revision: "abcdef",
NearestTagName: "1.2.3",
NearestTagRevision: "abcdef",
Tags: []Tag{
Tag{Name: "1.2.3"},
},
},
},
}
ctx := bc.NewContext()
assert.Len(ctx.Advisories, 0)
assert.NoError(bc.GuardStrict(ctx))
}
func TestMetadataDockerfile(t *testing.T) {
assert := assert.New(t)
b := Builder{}
br := sous.BuildResult{
ImageID: "identifier",
Advisories: []string{`something is horribly wrong`},
}
bc := sous.BuildContext{
Source: sous.SourceContext{
OffsetDir: "sub",
RemoteURL: "github.com/opentable/test",
Revision: "abcd",
NearestTagName: "2.3.7",
},
}
mddf, err := ioutil.ReadAll(b.metadataDockerfile(&br, &bc))
assert.NoError(err)
assert.Equal(
`FROM identifier
LABEL \
com.opentable.sous.repo_offset="sub" \
com.opentable.sous.repo_url="github.com/opentable/test" \
com.opentable.sous.revision="abcd" \
com.opentable.sous.version="2.3.7" \
com.opentable.sous.advisories="something is horribly wrong"`, string(mddf))
}
func TestGetRunningDeploymentSet_otherCluster(t *testing.T) {
//sous.Log.Vomit.SetFlags(sous.Log.Vomit.Flags() | log.Ltime)
//sous.Log.Vomit.SetOutput(os.Stderr)
//sous.Log.Vomit.Print("Starting stderr output")
sous.Log.Debug.SetFlags(sous.Log.Debug.Flags() | log.Ltime)
sous.Log.Debug.SetOutput(os.Stderr)
sous.Log.Debug.Print("Starting stderr output")
assert := assert.New(t)
registerLabelledContainers()
drc := docker_registry.NewClient()
drc.BecomeFoolishlyTrusting()
nc := docker.NewNameCache("", drc, newInMemoryDB("grds"))
client := singularity.NewRectiAgent()
d := singularity.NewDeployer(client)
clusters := []string{"other-cluster"}
ds, which := deploymentWithRepo(clusters, nc, assert, d, "github.com/opentable/docker-grafana")
deps := ds.Snapshot()
if assert.Equal(1, len(deps)) {
grafana := deps[which]
assert.Equal(SingularityURL, grafana.Cluster.BaseURL)
assert.Regexp("^0\\.1", grafana.Resources["cpus"]) // XXX strings and floats...
assert.Regexp("^100\\.", grafana.Resources["memory"]) // XXX strings and floats...
assert.Equal("1", grafana.Resources["ports"]) // XXX strings and floats...
assert.Equal(17, grafana.SourceID.Version.Patch)
assert.Equal("91495f1b1630084e301241100ecf2e775f6b672c", grafana.SourceID.Version.Meta)
assert.Equal(1, grafana.NumInstances)
assert.Equal(sous.ManifestKindService, grafana.Kind)
}
ResetSingularity()
}
func TestInvokeRectifyDryruns(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
testDryRun := func(which string) (sous.Deployer, sous.Registry) {
exe := justCommand(t, []string{`sous`, `rectify`, `-dry-run`, which, `-repo`, `github.com/somewhere`})
assert.Len(exe.Args, 0)
require.IsType(&SousRectify{}, exe.Cmd)
rect := exe.Cmd.(*SousRectify)
// currently no easy way to tell if the deploy client is live or dummy
return nil, rect.Resolver.Registry
}
_, r := testDryRun("both")
assert.IsType(&sous.DummyRegistry{}, r)
_, r = testDryRun("none")
assert.IsType(&docker.NameCache{}, r)
_, r = testDryRun("scheduler")
assert.IsType(&docker.NameCache{}, r)
_, r = testDryRun("registry")
assert.IsType(&sous.DummyRegistry{}, r)
}
func TestInvokeHarvest(t *testing.T) {
assert := assert.New(t)
exe := justCommand(t, []string{`sous`, `harvest`, `sms-continual-test`})
assert.NotNil(exe)
assert.Len(exe.Args, 1)
}
func TestBuildDeployment(t *testing.T) {
assert := assert.New(t)
m := &Manifest{
Source: SourceLocation{},
Owners: []string{"*****@*****.**"},
Kind: ManifestKindService,
}
sp := DeploySpec{
DeployConfig: DeployConfig{
Resources: Resources{},
Args: []string{},
Env: Env{},
NumInstances: 3,
Volumes: Volumes{
&Volume{"h", "c", "RO"},
},
},
Version: semv.MustParse("1.2.3"),
clusterName: "cluster.name",
}
var ih []DeploySpec
nick := "cn"
state := &State{Defs: Defs{Clusters: Clusters{nick: &Cluster{BaseURL: "http://not"}}}}
d, err := BuildDeployment(state, m, nick, sp, ih)
if assert.NoError(err) {
if assert.Len(d.DeployConfig.Volumes, 1) {
assert.Equal("c", d.DeployConfig.Volumes[0].Container)
}
assert.Equal(nick, d.ClusterName)
}
}
func TestCanMakeAnAgent(t *testing.T) {
assert := assert.New(t)
agent, err := NewAgent()
assert.NoError(err)
assert.NotNil(agent)
}
func TestInvokeUpdate(t *testing.T) {
assert := assert.New(t)
exe := justCommand(t, []string{`sous`, `update`})
assert.NotNil(exe)
assert.Len(exe.Args, 0)
}
// This test is terrible, but the current design of the client is hard to test
func TestNewClient(t *testing.T) {
assert := assert.New(t)
c := NewClient()
assert.NotNil(c)
c.Cancel()
}
/*
usage: sous context
context prints out sous's view of your current context
*/
func TestInvokeContext(t *testing.T) {
assert := assert.New(t)
exe := justCommand(t, []string{`sous`, `context`})
assert.NotNil(exe)
assert.Len(exe.Args, 0)
}
func TestModifyScale(t *testing.T) {
log.SetFlags(log.Flags() | log.Lshortfile)
assert := assert.New(t)
mods := make(chan *sous.DeployablePair, 1)
errs := make(chan error, 10)
pair := baseDeployablePair()
pair.Prior.Deployment.DeployConfig.NumInstances = 12
pair.Post.Deployment.DeployConfig.NumInstances = 24
client := sous.NewDummyRectificationClient()
deployer := NewDeployer(client)
mods <- pair
close(mods)
deployer.RectifyModifies(mods, errs)
close(errs)
for e := range errs {
t.Error(e)
}
assert.Len(client.Deployed, 0)
if assert.Len(client.Created, 1) {
assert.Equal(24, client.Created[0].Count)
}
}
func TestModifyResources(t *testing.T) {
assert := assert.New(t)
version := "1.2.3-test"
pair := baseDeployablePair()
pair.Prior.Deployment.SourceID.Version = semv.MustParse(version)
pair.Prior.Deployment.Resources["memory"] = "100"
pair.Post.Deployment.SourceID.Version = semv.MustParse(version)
pair.Post.Deployment.Resources["memory"] = "500"
pair.Post.BuildArtifact.Name = "1.2.3"
mods := make(chan *sous.DeployablePair, 1)
errs := make(chan error, 10)
client := sous.NewDummyRectificationClient()
deployer := NewDeployer(client)
mods <- pair
close(mods)
deployer.RectifyModifies(mods, errs)
close(errs)
for e := range errs {
t.Error(e)
}
assert.Len(client.Created, 0)
if assert.Len(client.Deployed, 1) {
assert.Regexp("1.2.3", client.Deployed[0].ImageName)
assert.Regexp("500", client.Deployed[0].Res["memory"])
}
}
func TestModifyImage(t *testing.T) {
assert := assert.New(t)
sous.Log.Warn.SetOutput(os.Stderr)
Log.Debug.SetOutput(os.Stderr)
before := "1.2.3-test"
after := "2.3.4-new"
pair := baseDeployablePair()
pair.Prior.Deployment.SourceID.Version = semv.MustParse(before)
pair.Post.Deployment.SourceID.Version = semv.MustParse(after)
pair.Post.BuildArtifact.Name = "2.3.4"
mods := make(chan *sous.DeployablePair, 1)
errs := make(chan error, 10)
client := sous.NewDummyRectificationClient()
deployer := NewDeployer(client)
mods <- pair
close(mods)
deployer.RectifyModifies(mods, errs)
close(errs)
for e := range errs {
t.Error(e)
}
assert.Len(client.Created, 0)
if assert.Len(client.Deployed, 1) {
assert.Regexp("2.3.4", client.Deployed[0].ImageName)
}
}
func TestQueryValuesToManifestIDHappyPath(t *testing.T) {
assert := assert.New(t)
pq := func(s string) *QueryValues {
v, _ := url.ParseQuery(s)
return &QueryValues{v}
}
ev := func(x interface{}, e error) error {
return e
}
mid := func(v sous.ManifestID, e error) sous.ManifestID {
return v
}
assert.NoError(ev(manifestIDFromValues(pq("repo=gh1"))))
assert.NoError(ev(manifestIDFromValues(pq("repo=gh1&offset=o1"))))
assert.NoError(ev(manifestIDFromValues(pq("repo=gh1&offset=o1&flavor=f1"))))
assert.Equal(
mid(manifestIDFromValues(pq("repo=gh1"))),
sous.ManifestID{Source: sous.SourceLocation{Repo: "gh1"}})
assert.Equal(
mid(manifestIDFromValues(pq("repo=gh1&offset=o1"))),
sous.ManifestID{Source: sous.SourceLocation{Repo: "gh1", Dir: "o1"}})
assert.Equal(
mid(manifestIDFromValues(pq("repo=gh1&offset=o1&flavor=f1"))),
sous.ManifestID{Source: sous.SourceLocation{Repo: "gh1", Dir: "o1"}, Flavor: "f1"})
}
func TestInvokeMetadataSet(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
exe := justCommand(t, []string{`sous`, `metadata`, `set`, `-repo`, `github.com/opentable/sous`, `BuildBranch`, `master`})
assert.NotNil(exe)
metaSet, good := exe.Cmd.(*SousMetadataSet)
require.True(good)
assert.NotNil(metaSet.State)
}
func TestGetDepSetWorks(t *testing.T) {
assert := assert.New(t)
Log.Debug.SetOutput(os.Stderr)
whip := make(map[string]swaggering.DummyControl)
reg := sous.NewDummyRegistry()
client := sous.NewDummyRectificationClient()
dep := deployer{client,
func(url string) *singularity.Client {
cl, co := singularity.NewDummyClient(url)
co.FeedDTO(&dtos.SingularityRequestParentList{
&dtos.SingularityRequestParent{
RequestDeployState: &dtos.SingularityRequestDeployState{
ActiveDeploy: &dtos.SingularityDeployMarker{
DeployId: "testdep",
RequestId: "testreq",
},
},
Request: &dtos.SingularityRequest{
Id: "testreq",
RequestType: dtos.SingularityRequestRequestTypeSERVICE,
Owners: swaggering.StringList{"*****@*****.**"},
},
},
}, nil)
co.FeedDTO(&dtos.SingularityDeployHistory{
Deploy: &dtos.SingularityDeploy{
Id: "testdep",
ContainerInfo: &dtos.SingularityContainerInfo{
Type: dtos.SingularityContainerInfoSingularityContainerTypeDOCKER,
Docker: &dtos.SingularityDockerInfo{},
Volumes: dtos.SingularityVolumeList{
&dtos.SingularityVolume{
HostPath: "/onhost",
ContainerPath: "/indocker",
Mode: dtos.SingularityVolumeSingularityDockerVolumeModeRW,
},
},
},
Resources: &dtos.Resources{},
},
}, nil)
whip[url] = co
return cl
},
}
clusters := sous.Clusters{"test": {BaseURL: "http://test-singularity.org/"}}
res, err := dep.RunningDeployments(reg, clusters)
assert.NoError(err)
assert.NotNil(res)
}
func TestInvokeManifestSet(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
exe := justCommand(t, []string{`sous`, `manifest`, `set`, `-repo`, `github.com/opentable/sous`})
assert.NotNil(exe)
maniSet, good := exe.Cmd.(*SousManifestSet)
require.True(good)
assert.NotNil(maniSet.StateWriter)
}
func TestInvokeInit(t *testing.T) {
assert := assert.New(t)
exe := justCommand(t, []string{`sous`, `init`})
init := exe.Cmd.(*SousInit)
assert.NotNil(init)
assert.False(init.Flags.IgnoreOTPLDeploy)
assert.False(init.Flags.IgnoreOTPLDeploy)
}
func TestRegistries(t *testing.T) {
assert := assert.New(t)
rs := NewRegistries()
r := ®istry{}
assert.NoError(rs.AddRegistry("x", r))
assert.Equal(rs.GetRegistry("x"), r)
assert.NoError(rs.DeleteRegistry("x"))
assert.Nil(rs.GetRegistry("x"))
}
func TestDeploymentDumper(t *testing.T) {
assert := assert.New(t)
io := &bytes.Buffer{}
ds := NewDeployments()
ds.Add(&Deployment{ClusterName: "andromeda"})
DumpDeployments(io, ds)
assert.Regexp(`andromeda`, io.String())
}
func TestHandlesGDMGet(t *testing.T) {
assert := assert.New(t)
th := &GDMHandler{graph.CurrentGDM{
Deployments: sous.NewDeployments(),
}}
data, status := th.Exchange()
assert.Equal(status, 200)
assert.Len(data.(gdmWrapper).Deployments, 0)
}
func TestDump(t *testing.T) {
assert := assert.New(t)
io := &bytes.Buffer{}
dc := docker_registry.NewDummyClient()
nc := NewNameCache("", dc, inMemoryDB("dump"))
nc.dump(io)
assert.Regexp(`name_id`, io.String())
}
func TestInvokeDeploy(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
exe := justCommand(t, []string{`sous`, `deploy`, `-cluster`, `ci-sf`, `-tag`, `1.2.3`})
assert.NotNil(exe)
assert.Len(exe.Args, 0)
deploy, good := exe.Cmd.(*SousDeploy)
require.True(good)
assert.Equal(deploy.DeployFilterFlags.Cluster, `ci-sf`)
assert.Equal(deploy.DeployFilterFlags.Tag, `1.2.3`)
}
func TestReharvest(t *testing.T) {
assert := assert.New(t)
dc := docker_registry.NewDummyClient()
_, err := dc.GetImageMetadata("", "")
assert.Error(err) //because channel starved
host := "docker.repo.io"
base := "ot/wackadoo"
nc := NewNameCache(host, dc, inMemoryDB("reharvest"))
vstr := "1.2.3"
sv := sous.MustNewSourceID("https://github.com/opentable/wackadoo", "nested/there", vstr)
in := base + ":version-" + vstr
digest := "sha256:012345678901234567890123456789AB012345678901234567890123456789AB"
cn := base + "@" + digest
dc.FeedMetadata(docker_registry.Metadata{
Registry: host,
Labels: Labels(sv),
Etag: digest,
CanonicalName: cn,
AllNames: []string{cn, in},
})
gotSV, err := nc.GetSourceID(NewBuildArtifact(host+"/"+in, nil)) // XXX Really prefix with host?
if assert.Nil(err) {
assert.Equal(gotSV, sv)
}
nc.dump(os.Stderr)
nc.DB.Exec("update _database_metadata_ set value='' where name='fingerprint'")
dc.FeedTags([]string{"version" + vstr})
dc.FeedMetadata(docker_registry.Metadata{
Registry: host,
Labels: Labels(sv),
Etag: digest,
CanonicalName: cn,
AllNames: []string{cn, in},
})
nc.dump(os.Stderr)
Log.Debug.SetOutput(os.Stderr)
Log.Vomit.SetOutput(os.Stderr)
err = nc.GroomDatabase()
assert.NoError(err)
nc.dump(os.Stderr)
_, err = dc.GetImageMetadata("", "")
assert.Error(err) //because channel starved
list, _ := dc.AllTags("")
assert.Len(list, 0) //because channel starved
}
func TestMissingName(t *testing.T) {
assert := assert.New(t)
dc := docker_registry.NewDummyClient()
nc := NewNameCache("", dc, inMemoryDB("missing"))
v := "4.5.6"
sv := sous.MustNewSourceID("https://github.com/opentable/brand-new-idea", "nested/there", v)
name, _, err := nc.getImageName(sv)
assert.Equal("", name)
assert.Error(err)
}
func TestTagStrings(t *testing.T) {
assert := assert.New(t)
sid, err := sous.NewSourceID("github.com/opentable/sous", "docker", "1.2.3+deadbeef")
if err != nil {
t.Fatal(err)
}
assert.Equal("/sous/docker:1.2.3", versionName(sid))
assert.Equal("/sous/docker:deadbeef", revisionName(sid))
}
func TestInvokeQuery(t *testing.T) {
assert := assert.New(t)
exe := justCommand(t, []string{`sous`, `query`})
assert.NotNil(exe)
exe = justCommand(t, []string{`sous`, `query`, `ads`})
assert.NotNil(exe)
exe = justCommand(t, []string{`sous`, `query`, `gdm`})
assert.NotNil(exe)
}
func TestGetLabels(t *testing.T) {
registerLabelledContainers()
assert := assert.New(t)
cl := docker_registry.NewClient()
cl.BecomeFoolishlyTrusting()
labels, err := cl.LabelsForImageName(imageName)
assert.Nil(err)
assert.Contains(labels, docker.DockerRepoLabel)
ResetSingularity()
}
func TestHarvesting(t *testing.T) {
assert := assert.New(t)
dc := docker_registry.NewDummyClient()
host := "docker.repo.io"
base := "ot/wackadoo"
nc := NewNameCache(host, dc, inMemoryDB("harvesting"))
v := "1.2.3"
sv := sous.MustNewSourceID("https://github.com/opentable/wackadoo", "nested/there", v)
v2 := "2.3.4"
sisterSV := sous.MustNewSourceID("https://github.com/opentable/wackadoo", "nested/there", v2)
tag := "version-1.2.3"
digest := "sha256:012345678901234567890123456789AB012345678901234567890123456789AB"
cn := base + "@" + digest
in := base + ":" + tag
dc.FeedMetadata(docker_registry.Metadata{
Registry: host,
Labels: Labels(sv),
Etag: digest,
CanonicalName: cn,
AllNames: []string{cn, in},
})
// a la a SetCollector getting the SV
_, err := nc.GetSourceID(NewBuildArtifact(in, nil))
if err != nil {
fmt.Printf("%+v", err)
}
assert.Nil(err)
tag = "version-2.3.4"
dc.FeedTags([]string{tag})
digest = "sha256:abcdefabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeffffffff"
cn = base + "@" + digest
in = base + ":" + tag
dc.FeedMetadata(docker_registry.Metadata{
Registry: host,
Labels: Labels(sisterSV),
Etag: digest,
CanonicalName: cn,
AllNames: []string{cn, in},
})
nin, err := nc.GetArtifact(sisterSV)
if assert.NoError(err) {
assert.Equal(host+"/"+cn, nin.Name)
}
}