コード例 #1
0
ファイル: image_mapping_test.go プロジェクト: opentable/sous
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
}
コード例 #2
0
func TestQueryValuesToManifestIDSadPath(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
	}

	assert.Error(ev(manifestIDFromValues(pq(""))))
	assert.Error(ev(manifestIDFromValues(pq("repo=gh1&repo=gh2"))))
	assert.Error(ev(manifestIDFromValues(pq("repo=gh1&offset=o1&offset=o2"))))
	assert.Error(ev(manifestIDFromValues(pq("repo=gh1&offset=o1&flavor=f1&flavor=f2"))))
}
コード例 #3
0
ファイル: image_mapping_test.go プロジェクト: opentable/sous
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)
}
コード例 #4
0
ファイル: resolver_test.go プロジェクト: opentable/sous
func TestGuardImageMissing(t *testing.T) {
	assert := assert.New(t)

	svOne := MustParseSourceID(`github.com/ot/one,1.3.5`)
	dr := NewDummyRegistry()
	config := DeployConfig{NumInstances: 1}
	clusterX := &Cluster{Name: "x"}
	missing := Deployment{ClusterName: `x`, SourceID: svOne, DeployConfig: config, Cluster: clusterX}

	dr.FeedArtifact(nil, fmt.Errorf("dummy error"))
	_, err := GuardImage(dr, &missing)
	assert.Error(err)
}
コード例 #5
0
ファイル: integration_test.go プロジェクト: opentable/sous
func TestMissingImage(t *testing.T) {
	assert := assert.New(t)

	clusterDefs := sous.Defs{
		Clusters: sous.Clusters{
			"test-cluster": &sous.Cluster{
				BaseURL: SingularityURL,
			},
		},
	}
	repoOne := "github.com/opentable/one"

	drc := docker_registry.NewClient()
	drc.BecomeFoolishlyTrusting()
	// easiest way to make sure that the manifest doesn't actually get registered
	dummyNc := docker.NewNameCache("", drc, newInMemoryDB("bitbucket"))

	stateOne := sous.State{
		Defs: clusterDefs,
		Manifests: sous.NewManifests(
			manifest(dummyNc, "opentable/one", "test-one", repoOne, "1.1.1"),
		),
	}

	// ****
	nc := docker.NewNameCache("", drc, newInMemoryDB("missingimage"))

	client := singularity.NewRectiAgent()
	deployer := singularity.NewDeployer(client)

	r := sous.NewResolver(deployer, nc, &sous.ResolveFilter{})

	deploymentsOne, err := stateOne.Deployments()
	if err != nil {
		t.Fatal(err)
	}
	err = r.Resolve(deploymentsOne, clusterDefs.Clusters)

	assert.Error(err)

	// ****
	time.Sleep(1 * time.Second)

	clusters := []string{"test-cluster"}

	_, which := deploymentWithRepo(clusters, nc, assert, deployer, repoOne)
	assert.Equal(which, none, "opentable/one was deployed")

	ResetSingularity()
}
コード例 #6
0
ファイル: resolver_test.go プロジェクト: opentable/sous
func TestGuardImageRejected(t *testing.T) {
	assert := assert.New(t)

	svTwo := MustParseSourceID(`github.com/ot/two,2.3.5`)
	dr := NewDummyRegistry()
	config := DeployConfig{NumInstances: 1}
	clusterX := &Cluster{Name: "x"}
	rejected := Deployment{ClusterName: `x`, SourceID: svTwo, DeployConfig: config, Cluster: clusterX}

	dr.FeedArtifact(&BuildArtifact{"ot-docker/one", "docker", []Quality{{"ephemeral_tag", "advisory"}}}, nil)

	_, err := GuardImage(dr, &rejected)
	assert.Error(err)

}
コード例 #7
0
ファイル: build_config_test.go プロジェクト: opentable/sous
func TestDirtyWorkspaceAdvisory(t *testing.T) {
	assert := assert.New(t)

	bc := BuildConfig{
		Context: &BuildContext{
			Sh: &shell.Sh{},
			Source: SourceContext{
				DirtyWorkingTree: true,
			},
		},
	}

	ctx := bc.NewContext()
	assert.Contains(ctx.Advisories, string(DirtyWS))
	assert.Error(bc.GuardRegister(ctx))
}
コード例 #8
0
ファイル: build_config_test.go プロジェクト: opentable/sous
func TestUnpushedRevisionAdvisory(t *testing.T) {
	assert := assert.New(t)

	bc := BuildConfig{
		Strict: true,
		Context: &BuildContext{
			Sh: &shell.Sh{},
			Source: SourceContext{
				RevisionUnpushed: true,
			},
		},
	}

	ctx := bc.NewContext()
	assert.Contains(ctx.Advisories, string(UnpushedRev))
	assert.Error(bc.GuardStrict(ctx))
}
コード例 #9
0
ファイル: until_ready_test.go プロジェクト: opentable/sous
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)
}
コード例 #10
0
func TestGitConflicts(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)
	gsm, dsm := setupManagers(t)

	actual, err := gsm.ReadState()
	require.NoError(err)

	expected := exampleState()

	expected.Manifests.Add(&sous.Manifest{Source: sous.SourceLocation{Repo: "github.com/opentable/brandnew"}})
	dsm.WriteState(expected)
	expected, err = dsm.ReadState()
	require.NoError(err)
	runScript(t, `git add .
	git commit -m ""`, `testdata/origin`)

	actual.Manifests.Add(&sous.Manifest{Source: sous.SourceLocation{Repo: "github.com/opentable/newhotness"}})
	assert.Error(gsm.WriteState(actual))
	actual, err = gsm.ReadState()
	require.NoError(err)
	sameYAML(t, actual, expected)
}
コード例 #11
0
ファイル: require.go プロジェクト: opentable/sous
// Error asserts that a function returned an error (i.e. not `nil`).
//
//   actualObj, err := SomeFunction()
//   if assert.Error(t, err, "An error was expected") {
// 	   assert.Equal(t, err, expectedError)
//   }
//
// Returns whether the assertion was successful (true) or not (false).
func Error(t TestingT, err error, msgAndArgs ...interface{}) {
	if !assert.Error(t, err, msgAndArgs...) {
		t.FailNow()
	}
}