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 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"))
}
// This can happen e.g. if the same source gets built twice
func TestSecondCanonicalName(t *testing.T) {
assert := assert.New(t)
dc := docker_registry.NewDummyClient()
host := "docker.repo.io"
base := "ot/wackadoo"
nc := NewNameCache(host, dc, inMemoryDB("secondCN"))
repo := "github.com/opentable/test-app"
stuffBA := func(digest string) sous.SourceID {
n := "test-service"
v := `0.1.2-ci1234`
ba := &sous.BuildArtifact{
Name: n,
Type: "docker",
}
sv := sous.MustNewSourceID(repo, "", v)
in := base + ":version-" + v
cn := base + "@sha256:" + digest
dc.FeedMetadata(docker_registry.Metadata{
Registry: host,
Labels: Labels(sv),
Etag: digest,
CanonicalName: cn,
AllNames: []string{cn, in},
})
sid, err := nc.GetSourceID(ba)
if !assert.NoError(err) {
fmt.Println(err)
nc.dump(os.Stderr)
}
assert.NotNil(sid)
return sid
}
sid1 := stuffBA(`012345678901234567890123456789AB012345678901234567890123456789AB`)
sid2 := stuffBA(`ABCDEFABCDEFABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEF12341234566`)
_, err := nc.GetArtifact(sid1) //which should not miss
assert.NoError(err)
_, err = nc.GetArtifact(sid2) //which should not miss
assert.NoError(err)
}
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 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 TestCanMakeAnAgent(t *testing.T) {
assert := assert.New(t)
agent, err := NewAgent()
assert.NoError(err)
assert.NotNil(agent)
}
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 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)
}
}
// I'm still exploring what the problem is here...
func TestHarvestAlso(t *testing.T) {
assert := assert.New(t)
dc := docker_registry.NewDummyClient()
host := "docker.repo.io"
base := "ot/wackadoo"
repo := "github.com/opentable/test-app"
nc := NewNameCache(host, dc, inMemoryDB("harvest_also"))
stuffBA := func(n, v string) sous.SourceID {
ba := &sous.BuildArtifact{
Name: n,
Type: "docker",
}
sv := sous.MustNewSourceID(repo, "", v)
in := base + ":version-" + v
digBs := sha256.Sum256([]byte(in))
digest := hex.EncodeToString(digBs[:])
cn := base + "@sha256:" + digest
dc.FeedMetadata(docker_registry.Metadata{
Registry: host,
Labels: Labels(sv),
Etag: digest,
CanonicalName: cn,
AllNames: []string{cn, in},
})
sid, err := nc.GetSourceID(ba)
assert.NoError(err)
assert.NotNil(sid)
return sid
}
sid1 := stuffBA("tom", "0.2.1")
sid2 := stuffBA("dick", "0.2.2")
sid3 := stuffBA("harry", "0.2.3")
_, err := nc.GetArtifact(sid1) //which should not miss
assert.NoError(err)
_, err = nc.GetArtifact(sid2) //which should not miss
assert.NoError(err)
_, err = nc.GetArtifact(sid3) //which should not miss
assert.NoError(err)
}
func TestRoundTrip(t *testing.T) {
assert := assert.New(t)
dc := docker_registry.NewDummyClient()
host := "docker.repo.io"
base := "ot/wackadoo"
nc := NewNameCache(host, dc, inMemoryDB("roundtrip"))
sv := sous.MustNewSourceID("https://github.com/opentable/wackadoo", "nested/there", "1.2.3")
in := base + ":version-1.2.3"
digest := "sha256:012345678901234567890123456789AB012345678901234567890123456789AB"
err := nc.Insert(sv, in, digest, []sous.Quality{})
assert.NoError(err)
cn, err := nc.GetCanonicalName(in)
if assert.NoError(err) {
assert.Equal(in, cn)
}
nin, _, err := nc.getImageName(sv)
if assert.NoError(err) {
assert.Equal(in, nin)
}
newSV := sous.MustNewSourceID("https://github.com/opentable/wackadoo", "nested/there", "1.2.42")
cn = base + "@" + digest
dc.FeedMetadata(docker_registry.Metadata{
Registry: host,
Labels: Labels(newSV),
Etag: digest,
CanonicalName: cn,
AllNames: []string{cn, in},
})
sv, err = nc.GetSourceID(NewBuildArtifact(in, nil))
if assert.Nil(err) {
assert.Equal(newSV, sv)
}
ncn, err := nc.GetCanonicalName(host + "/" + in)
if assert.Nil(err) {
assert.Equal(host+"/"+cn, ncn)
}
}
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 TestOverallRouter(t *testing.T) {
assert := assert.New(t)
gf := func() Injector {
g := graph.BuildGraph(&bytes.Buffer{}, os.Stdout, os.Stdout)
g.Add(&config.Verbosity{})
return g
}
ts := httptest.NewServer(SousRouteMap.BuildRouter(gf))
defer ts.Close()
res, err := http.Get(ts.URL + "/gdm")
assert.NoError(err)
gdm, err := ioutil.ReadAll(res.Body)
res.Body.Close()
assert.NoError(err)
assert.Regexp(`"Deployments"`, string(gdm))
assert.NotEqual(res.Header.Get("Etag"), "")
}
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 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)
}
}
func TestAllowUndeployedUglies(t *testing.T) {
assert := assert.New(t)
dr := NewDummyRegistry()
svOne := MustParseSourceID(`github.com/ot/one,1.3.5`)
config := DeployConfig{NumInstances: 0}
borken := Deployment{ClusterName: `x`, SourceID: svOne, DeployConfig: config}
dr.FeedArtifact(nil, fmt.Errorf("dummy error"))
_, err := GuardImage(dr, &borken)
assert.NoError(err)
}
func TestRecordAdvisories(t *testing.T) {
assert := assert.New(t)
require := require.New(t)
dc := docker_registry.NewDummyClient()
host := "docker.repo.io"
base := "ot/wackadoo"
nc := NewNameCache(host, dc, inMemoryDB("advisories"))
v := "1.2.3"
sv := sous.MustNewSourceID("https://github.com/opentable/wackadoo", "nested/there", v)
digest := "sha256:012345678901234567890123456789AB012345678901234567890123456789AB"
cn := base + "@" + digest
qs := []sous.Quality{{Name: "ephemeral_tag", Kind: "advisory"}}
err := nc.Insert(sv, cn, digest, qs)
assert.NoError(err)
arty, err := nc.GetArtifact(sv)
assert.NoError(err)
require.NotNil(arty)
require.Len(arty.Qualities, 1)
assert.Equal(arty.Qualities[0].Name, `ephemeral_tag`)
}
func TestAllowsWhitelistedAdvisories(t *testing.T) {
assert := assert.New(t)
svOne := MustParseSourceID(`github.com/ot/one,1.3.5`)
dr := NewDummyRegistry()
config := DeployConfig{NumInstances: 1}
intoCI := Deployment{ClusterName: `ci`, Cluster: &Cluster{AllowedAdvisories: []string{"ephemeral_tag"}}, SourceID: svOne, DeployConfig: config}
dr.FeedArtifact(&BuildArtifact{"ot-docker/one", "docker", []Quality{{"ephemeral_tag", "advisory"}}}, nil)
art, err := GuardImage(dr, &intoCI)
assert.NoError(err)
assert.NotNil(art)
}
func TestBuildingRequestIDTwoClusters(t *testing.T) {
cn := "test-cluster"
cn2 := "test-other"
url := "https://a.singularity.somewhere"
clusters := make(sous.Clusters)
clusters[cn] = &sous.Cluster{BaseURL: url}
clusters[cn2] = &sous.Cluster{BaseURL: url}
db := &deploymentBuilder{
clusters: clusters,
request: &dtos.SingularityRequest{Id: "::" + cn},
req: SingReq{SourceURL: url},
}
assert.NoError(t, db.assignClusterName())
assert.Equal(t, db.Target.ClusterName, cn)
db2 := &deploymentBuilder{
clusters: clusters,
request: &dtos.SingularityRequest{Id: "::" + cn2},
req: SingReq{SourceURL: url},
}
assert.NoError(t, db2.assignClusterName())
assert.Equal(t, db2.Target.ClusterName, cn2)
}
func TestPermissiveGuard(t *testing.T) {
assert := assert.New(t)
bc := BuildConfig{
Strict: false,
Context: &BuildContext{
Sh: &shell.Sh{},
Source: SourceContext{
RevisionUnpushed: true,
},
},
}
ctx := bc.NewContext()
assert.Contains(ctx.Advisories, string(UnpushedRev))
assert.NoError(bc.GuardStrict(ctx))
}
func TestEphemeralTag(t *testing.T) {
assert := assert.New(t)
bc := BuildConfig{
Tag: "1.2.3",
Context: &BuildContext{
Sh: &shell.Sh{},
Source: SourceContext{
PrimaryRemoteURL: "github.com/opentable/present",
Revision: "abcd",
NearestTagName: "1.2.0",
NearestTagRevision: "3541",
},
},
}
/*
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.Equal(`1.2.3+abcd`, ctx.Source.Version().Version.String())
assert.Contains(ctx.Advisories, string(EphemeralTag))
assert.NotContains(ctx.Advisories, string(TagNotHead))
assert.NoError(bc.GuardRegister(ctx))
}
func TestUntilReady(t *testing.T) {
assert := assert.New(t)
log.SetFlags(log.Flags() | log.Lshortfile)
err := UntilReady(time.Second/10, time.Second, func() (string, func() bool, func()) {
return "returns quickly",
func() bool { return true },
func() {}
})
assert.NoError(err)
err = UntilReady(time.Second/10, time.Second, func() (string, func() bool, func()) {
return "never returns",
func() bool { return false },
func() {}
})
assert.Error(err)
}
func TestHarvestGuessedRepo(t *testing.T) {
assert := assert.New(t)
dc := docker_registry.NewDummyClient()
host := "docker.repo.io"
nc := NewNameCache(host, dc, inMemoryDB("guessed_repo"))
sl := sous.SourceLocation{
Repo: "https://github.com/opentable/wackadoo",
Dir: "nested/there",
}
dc.FeedTags([]string{"something", "the other"})
nc.harvest(sl)
remainingTags, err := dc.AllTags("")
assert.NoError(err)
assert.Len(remainingTags, 0) // because all consumed by harvest
}
func TestPredicateBuilder(t *testing.T) {
assert := assert.New(t)
ds := make([]*sous.Deployment, 0, 8)
cs := []string{"cluster1", "cluster2"}
rs := []string{"github.com/ot/one", "github.com/ot/two"}
os := []string{"up", "down"}
for _, c := range cs {
for _, r := range rs {
for _, o := range os {
ds = append(ds, &sous.Deployment{
ClusterName: c,
SourceID: sous.SourceID{
Location: sous.SourceLocation{
Repo: r,
Dir: o,
},
},
})
}
}
}
parseSL := func(string) (sous.SourceLocation, error) {
return sous.SourceLocation{}, nil
}
// for i, d := range ds {
// fmt.Printf("%d: %#v\n", i, d)
// }
//
f := config.DeployFilterFlags{}
rf, err := f.BuildFilter(parseSL)
assert.NoError(err)
assert.True(rf.All())
f.Repo = string(rs[0])
pd, err := f.BuildPredicate(parseSL)
assert.NoError(err)
assert.NotNil(pd)
filtered := filter(ds, pd)
assert.Contains(filtered, ds[0])
assert.Contains(filtered, ds[1])
assert.Contains(filtered, ds[4])
assert.Contains(filtered, ds[5])
assert.Len(filtered, 4)
f.Offset = string(os[0])
pd, err = f.BuildPredicate(parseSL)
assert.NoError(err)
assert.NotNil(pd)
filtered = filter(ds, pd)
assert.Contains(filtered, ds[0])
assert.Contains(filtered, ds[4])
assert.Len(filtered, 2)
f.Cluster = cs[0]
pd, err = f.BuildPredicate(parseSL)
assert.NoError(err)
assert.NotNil(pd)
filtered = filter(ds, pd)
assert.Contains(filtered, ds[0])
assert.Len(filtered, 1)
f = config.DeployFilterFlags{Cluster: cs[1]}
pd, err = f.BuildPredicate(parseSL)
assert.NoError(err)
assert.NotNil(pd)
filtered = filter(ds, pd)
assert.Contains(filtered, ds[4])
assert.Contains(filtered, ds[5])
assert.Contains(filtered, ds[6])
assert.Contains(filtered, ds[7])
assert.Len(filtered, 4)
f = config.DeployFilterFlags{All: true}
pd, err = f.BuildPredicate(parseSL)
assert.NoError(err)
assert.NotNil(pd)
filtered = filter(ds, pd)
assert.Len(filtered, 8)
}
func TestResolve(t *testing.T) {
assert := assert.New(t)
//sous.Log.Vomit.SetOutput(os.Stderr)
sous.Log.Debug.SetOutput(os.Stderr)
ResetSingularity()
defer ResetSingularity()
clusterDefs := sous.Defs{
Clusters: sous.Clusters{
"test-cluster": &sous.Cluster{
BaseURL: SingularityURL,
},
},
}
repoOne := "github.com/opentable/one"
repoTwo := "github.com/opentable/two"
repoThree := "github.com/opentable/three"
drc := docker_registry.NewClient()
drc.BecomeFoolishlyTrusting()
db := newInMemoryDB("testresolve")
nc := docker.NewNameCache("", drc, db)
stateOneTwo := sous.State{
Defs: clusterDefs,
Manifests: sous.NewManifests(
manifest(nc, "opentable/one", "test-one", repoOne, "1.1.1"),
manifest(nc, "opentable/two", "test-two", repoTwo, "1.1.1"),
),
}
deploymentsOneTwo, err := stateOneTwo.Deployments()
if err != nil {
t.Fatal(err)
}
stateTwoThree := sous.State{
Defs: clusterDefs,
Manifests: sous.NewManifests(
manifest(nc, "opentable/two", "test-two", repoTwo, "1.1.1"),
manifest(nc, "opentable/three", "test-three", repoThree, "1.1.1"),
),
}
deploymentsTwoThree, err := stateTwoThree.Deployments()
if err != nil {
t.Fatal(err)
}
// ****
log.Print("Resolving from nothing to one+two")
client := singularity.NewRectiAgent()
deployer := singularity.NewDeployer(client)
r := sous.NewResolver(deployer, nc, &sous.ResolveFilter{})
err = r.Resolve(deploymentsOneTwo, clusterDefs.Clusters)
if err != nil {
assert.Fail(err.Error())
}
// ****
time.Sleep(3 * time.Second)
clusters := []string{"test-cluster"}
ds, which := deploymentWithRepo(clusters, nc, assert, deployer, repoOne)
deps := ds.Snapshot()
if assert.NotEqual(which, none, "opentable/one not successfully deployed") {
one := deps[which]
assert.Equal(1, one.NumInstances)
}
which = findRepo(ds, repoTwo)
if assert.NotEqual(none, which, "opentable/two not successfully deployed") {
two := deps[which]
assert.Equal(1, two.NumInstances)
}
// ****
log.Println("Resolving from one+two to two+three")
conflictRE := regexp.MustCompile(`Pending deploy already in progress`)
// XXX Let's hope this is a temporary solution to a testing issue
// The problem is laid out in DCOPS-7625
for tries := 0; tries < 3; tries++ {
client := singularity.NewRectiAgent()
deployer := singularity.NewDeployer(client)
r := sous.NewResolver(deployer, nc, &sous.ResolveFilter{})
err := r.Resolve(deploymentsTwoThree, clusterDefs.Clusters)
if err != nil {
if !conflictRE.MatchString(err.Error()) {
assert.FailNow(err.Error())
}
log.Printf("Singularity conflict - waiting for previous deploy to complete - try #%d", tries+1)
time.Sleep(1 * time.Second)
}
}
if !assert.NoError(err) {
assert.Fail(err.Error())
}
// ****
ds, which = deploymentWithRepo(clusters, nc, assert, deployer, repoTwo)
deps = ds.Snapshot()
if assert.NotEqual(none, which, "opentable/two no longer deployed after resolve") {
assert.Equal(1, deps[which].NumInstances)
}
which = findRepo(ds, repoThree)
if assert.NotEqual(none, which, "opentable/three not successfully deployed") {
assert.Equal(1, deps[which].NumInstances)
if assert.Len(deps[which].DeployConfig.Volumes, 1) {
assert.Equal("RO", string(deps[which].DeployConfig.Volumes[0].Mode))
}
}
// We no longer expect any deletions; See deployer.RectifySingleDelete.
//expectedInstances := 0
expectedInstances := 1
which = findRepo(ds, repoOne)
if which != none {
assert.Equal(expectedInstances, deps[which].NumInstances)
}
}
func TestBuildDeployments(t *testing.T) {
t.Skipf("Failing test on master preventing progress on other stories.")
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("testresolve"),
})
if err != nil {
panic(err)
}
appLocation := "testhelloreq"
clusterNick := "tcluster"
reqID := appLocation + clusterNick
nc := docker.NewNameCache("", drc, db)
singCl := sing.NewClient(SingularityURL)
//singCl.Debug = true
sr, err := singReqDep(
SingularityURL,
whitespace.CleanWS(`
{
"instances": 1,
"id": "`+reqID+`",
"requestType": "SERVICE",
"owners": ["*****@*****.**", "*****@*****.**"]
}`),
whitespace.CleanWS(`
{
"deploy": {
"id": "`+singularity.MakeDeployID(uuid.NewV4().String())+`",
"requestId": "`+reqID+`",
"resources": {
"cpus": 0.1,
"memoryMb": 32,
"numPorts": 1
},
"containerInfo": {
"type": "DOCKER",
"docker": {
"image": "`+BuildImageName("hello-server-labels", "latest")+`"
},
"volumes": [{"hostPath":"/tmp", "containerPath":"/tmp","mode":"RO"}]
},
"env": {
"TEST": "yes"
}
}
}`),
)
req := singularity.SingReq{
SourceURL: SingularityURL,
Sing: singCl,
ReqParent: sr,
}
if assert.NoError(err) {
clusters := sous.Clusters{clusterNick: {BaseURL: SingularityURL}}
dep, err := singularity.BuildDeployment(nc, clusters, req)
if assert.NoError(err) {
if assert.Len(dep.DeployConfig.Volumes, 1) {
assert.Equal(dep.DeployConfig.Volumes[0].Host, "/tmp")
}
assert.Equal("github.com/docker/dockercloud-hello-world", dep.SourceID.Location.Repo)
}
}
}
// NoError asserts that a function returned no error (i.e. `nil`).
//
// actualObj, err := SomeFunction()
// if assert.NoError(t, err) {
// assert.Equal(t, actualObj, expectedObj)
// }
//
// Returns whether the assertion was successful (true) or not (false).
func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
if !assert.NoError(t, err, msgAndArgs...) {
t.FailNow()
}
}
