// Test public interface
func doTestStore(t *testing.T, store Store) {
store.Add("foo", "bar")
if item, ok := store.Get("foo"); !ok {
t.Errorf("didn't find inserted item")
} else {
if e, a := "bar", item.(string); e != a {
t.Errorf("expected %v, got %v", e, a)
}
}
store.Update("foo", "baz")
if item, ok := store.Get("foo"); !ok {
t.Errorf("didn't find inserted item")
} else {
if e, a := "baz", item.(string); e != a {
t.Errorf("expected %v, got %v", e, a)
}
}
store.Delete("foo", "qux")
if _, ok := store.Get("foo"); ok {
t.Errorf("found deleted item??")
}
store.Add("a", "b")
store.Add("c", "d")
store.Add("e", "e")
found := util.StringSet{}
for _, item := range store.List() {
found.Insert(item.(string))
}
if !found.HasAll("b", "d", "e") {
t.Errorf("missing items")
}
if len(found) != 3 {
t.Errorf("extra items")
}
}
// Test public interface
func doTestIndex(t *testing.T, indexer Indexer) {
mkObj := func(id string, val string) testStoreObject {
return testStoreObject{id: id, val: val}
}
// Test Index
expected := map[string]util.StringSet{}
expected["b"] = util.NewStringSet("a", "c")
expected["f"] = util.NewStringSet("e")
expected["h"] = util.NewStringSet("g")
indexer.Add(mkObj("a", "b"))
indexer.Add(mkObj("c", "b"))
indexer.Add(mkObj("e", "f"))
indexer.Add(mkObj("g", "h"))
{
for k, v := range expected {
found := util.StringSet{}
indexResults, err := indexer.Index("by_val", mkObj("", k))
if err != nil {
t.Errorf("Unexpected error %v", err)
}
for _, item := range indexResults {
found.Insert(item.(testStoreObject).id)
}
items := v.List()
if !found.HasAll(items...) {
t.Errorf("missing items, index %s, expected %v but found %v", k, items, found.List())
}
}
}
}
func TestFilterQuotaPods(t *testing.T) {
pods := []api.Pod{
{
ObjectMeta: api.ObjectMeta{Name: "pod-running"},
Status: api.PodStatus{Phase: api.PodRunning},
},
{
ObjectMeta: api.ObjectMeta{Name: "pod-pending"},
Status: api.PodStatus{Phase: api.PodPending},
},
{
ObjectMeta: api.ObjectMeta{Name: "pod-succeeded"},
Status: api.PodStatus{Phase: api.PodSucceeded},
},
{
ObjectMeta: api.ObjectMeta{Name: "pod-unknown"},
Status: api.PodStatus{Phase: api.PodUnknown},
},
{
ObjectMeta: api.ObjectMeta{Name: "pod-failed"},
Status: api.PodStatus{Phase: api.PodFailed},
},
{
ObjectMeta: api.ObjectMeta{Name: "pod-failed-with-restart-always"},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyAlways,
},
Status: api.PodStatus{Phase: api.PodFailed},
},
{
ObjectMeta: api.ObjectMeta{Name: "pod-failed-with-restart-on-failure"},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyOnFailure,
},
Status: api.PodStatus{Phase: api.PodFailed},
},
{
ObjectMeta: api.ObjectMeta{Name: "pod-failed-with-restart-never"},
Spec: api.PodSpec{
RestartPolicy: api.RestartPolicyNever,
},
Status: api.PodStatus{Phase: api.PodFailed},
},
}
expectedResults := util.NewStringSet("pod-running",
"pod-pending", "pod-unknown", "pod-failed-with-restart-always",
"pod-failed-with-restart-on-failure")
actualResults := util.StringSet{}
result := FilterQuotaPods(pods)
for i := range result {
actualResults.Insert(result[i].Name)
}
if len(expectedResults) != len(actualResults) || !actualResults.HasAll(expectedResults.List()...) {
t.Errorf("Expected results %v, Actual results %v", expectedResults, actualResults)
}
}
func TestOrphanBuildResolver(t *testing.T) {
activeBuildConfig := mockBuildConfig("a", "active-build-config")
inactiveBuildConfig := mockBuildConfig("a", "inactive-build-config")
buildConfigs := []*buildapi.BuildConfig{activeBuildConfig}
builds := []*buildapi.Build{}
expectedNames := util.StringSet{}
buildStatusOptions := []buildapi.BuildStatus{
buildapi.BuildStatusCancelled,
buildapi.BuildStatusComplete,
buildapi.BuildStatusError,
buildapi.BuildStatusFailed,
buildapi.BuildStatusNew,
buildapi.BuildStatusPending,
buildapi.BuildStatusRunning,
}
buildStatusFilter := []buildapi.BuildStatus{
buildapi.BuildStatusCancelled,
buildapi.BuildStatusComplete,
buildapi.BuildStatusError,
buildapi.BuildStatusFailed,
}
buildStatusFilterSet := util.StringSet{}
for _, buildStatus := range buildStatusFilter {
buildStatusFilterSet.Insert(string(buildStatus))
}
for _, buildStatusOption := range buildStatusOptions {
builds = append(builds, withStatus(mockBuild("a", string(buildStatusOption)+"-active", activeBuildConfig), buildStatusOption))
builds = append(builds, withStatus(mockBuild("a", string(buildStatusOption)+"-inactive", inactiveBuildConfig), buildStatusOption))
builds = append(builds, withStatus(mockBuild("a", string(buildStatusOption)+"-orphan", nil), buildStatusOption))
if buildStatusFilterSet.Has(string(buildStatusOption)) {
expectedNames.Insert(string(buildStatusOption) + "-inactive")
expectedNames.Insert(string(buildStatusOption) + "-orphan")
}
}
dataSet := NewDataSet(buildConfigs, builds)
resolver := NewOrphanBuildResolver(dataSet, buildStatusFilter)
results, err := resolver.Resolve()
if err != nil {
t.Errorf("Unexpected error %v", err)
}
foundNames := util.StringSet{}
for _, result := range results {
foundNames.Insert(result.Name)
}
if len(foundNames) != len(expectedNames) || !expectedNames.HasAll(foundNames.List()...) {
t.Errorf("expected %v, actual %v", expectedNames, foundNames)
}
}
func validateList(t *testing.T, lister Lister, user user.Info, expectedSet util.StringSet) {
namespaceList, err := lister.List(user)
if err != nil {
t.Errorf("Unexpected error %v", err)
}
results := util.StringSet{}
for _, namespace := range namespaceList.Items {
results.Insert(namespace.Name)
}
if results.Len() != expectedSet.Len() || !results.HasAll(expectedSet.List()...) {
t.Errorf("User %v, Expected: %v, Actual: %v", user.GetName(), expectedSet, results)
}
}
func TestOrphanDeploymentResolver(t *testing.T) {
activeDeploymentConfig := mockDeploymentConfig("a", "active-deployment-config")
inactiveDeploymentConfig := mockDeploymentConfig("a", "inactive-deployment-config")
deploymentConfigs := []*deployapi.DeploymentConfig{activeDeploymentConfig}
deployments := []*kapi.ReplicationController{}
expectedNames := util.StringSet{}
deploymentStatusOptions := []deployapi.DeploymentStatus{
deployapi.DeploymentStatusComplete,
deployapi.DeploymentStatusFailed,
deployapi.DeploymentStatusNew,
deployapi.DeploymentStatusPending,
deployapi.DeploymentStatusRunning,
}
deploymentStatusFilter := []deployapi.DeploymentStatus{
deployapi.DeploymentStatusComplete,
deployapi.DeploymentStatusFailed,
}
deploymentStatusFilterSet := util.StringSet{}
for _, deploymentStatus := range deploymentStatusFilter {
deploymentStatusFilterSet.Insert(string(deploymentStatus))
}
for _, deploymentStatusOption := range deploymentStatusOptions {
deployments = append(deployments, withStatus(mockDeployment("a", string(deploymentStatusOption)+"-active", activeDeploymentConfig), deploymentStatusOption))
deployments = append(deployments, withStatus(mockDeployment("a", string(deploymentStatusOption)+"-inactive", inactiveDeploymentConfig), deploymentStatusOption))
deployments = append(deployments, withStatus(mockDeployment("a", string(deploymentStatusOption)+"-orphan", nil), deploymentStatusOption))
if deploymentStatusFilterSet.Has(string(deploymentStatusOption)) {
expectedNames.Insert(string(deploymentStatusOption) + "-inactive")
expectedNames.Insert(string(deploymentStatusOption) + "-orphan")
}
}
dataSet := NewDataSet(deploymentConfigs, deployments)
resolver := NewOrphanDeploymentResolver(dataSet, deploymentStatusFilter)
results, err := resolver.Resolve()
if err != nil {
t.Errorf("Unexpected error %v", err)
}
foundNames := util.StringSet{}
for _, result := range results {
foundNames.Insert(result.Name)
}
if len(foundNames) != len(expectedNames) || !expectedNames.HasAll(foundNames.List()...) {
t.Errorf("expected %v, actual %v", expectedNames, foundNames)
}
}
// Test public interface
func doTestStore(t *testing.T, store Store) {
store.Add("foo", "bar")
if item, ok := store.Get("foo"); !ok {
t.Errorf("didn't find inserted item")
} else {
if e, a := "bar", item.(string); e != a {
t.Errorf("expected %v, got %v", e, a)
}
}
store.Update("foo", "baz")
if item, ok := store.Get("foo"); !ok {
t.Errorf("didn't find inserted item")
} else {
if e, a := "baz", item.(string); e != a {
t.Errorf("expected %v, got %v", e, a)
}
}
store.Delete("foo")
if _, ok := store.Get("foo"); ok {
t.Errorf("found deleted item??")
}
// Test List.
store.Add("a", "b")
store.Add("c", "d")
store.Add("e", "e")
{
found := util.StringSet{}
for _, item := range store.List() {
found.Insert(item.(string))
}
if !found.HasAll("b", "d", "e") {
t.Errorf("missing items")
}
if len(found) != 3 {
t.Errorf("extra items")
}
// Check that ID list is correct.
ids := store.ContainedIDs()
if !ids.HasAll("a", "c", "e") {
t.Errorf("missing items")
}
if len(ids) != 3 {
t.Errorf("extra items")
}
}
// Test Replace.
store.Replace(map[string]interface{}{
"foo": "foo",
"bar": "bar",
})
{
found := util.StringSet{}
for _, item := range store.List() {
found.Insert(item.(string))
}
if !found.HasAll("foo", "bar") {
t.Errorf("missing items")
}
if len(found) != 2 {
t.Errorf("extra items")
}
// Check that ID list is correct.
ids := store.ContainedIDs()
if !ids.HasAll("foo", "bar") {
t.Errorf("missing items")
}
if len(ids) != 2 {
t.Errorf("extra items")
}
}
}
func TestPerDeploymentConfigResolver(t *testing.T) {
deploymentStatusOptions := []deployapi.DeploymentStatus{
deployapi.DeploymentStatusComplete,
deployapi.DeploymentStatusFailed,
deployapi.DeploymentStatusNew,
deployapi.DeploymentStatusPending,
deployapi.DeploymentStatusRunning,
}
deploymentConfigs := []*deployapi.DeploymentConfig{
mockDeploymentConfig("a", "deployment-config-1"),
mockDeploymentConfig("b", "deployment-config-2"),
}
deploymentsPerStatus := 100
deployments := []*kapi.ReplicationController{}
for _, deploymentConfig := range deploymentConfigs {
for _, deploymentStatusOption := range deploymentStatusOptions {
for i := 0; i < deploymentsPerStatus; i++ {
deployment := withStatus(mockDeployment(deploymentConfig.Namespace, fmt.Sprintf("%v-%v-%v", deploymentConfig.Name, deploymentStatusOption, i), deploymentConfig), deploymentStatusOption)
deployments = append(deployments, deployment)
}
}
}
now := util.Now()
for i := range deployments {
creationTimestamp := util.NewTime(now.Time.Add(-1 * time.Duration(i) * time.Hour))
deployments[i].CreationTimestamp = creationTimestamp
}
// test number to keep at varying ranges
for keep := 0; keep < deploymentsPerStatus*2; keep++ {
dataSet := NewDataSet(deploymentConfigs, deployments)
expectedNames := util.StringSet{}
deploymentCompleteStatusFilterSet := util.NewStringSet(string(deployapi.DeploymentStatusComplete))
deploymentFailedStatusFilterSet := util.NewStringSet(string(deployapi.DeploymentStatusFailed))
for _, deploymentConfig := range deploymentConfigs {
deploymentItems, err := dataSet.ListDeploymentsByDeploymentConfig(deploymentConfig)
if err != nil {
t.Errorf("Unexpected err %v", err)
}
completedDeployments, failedDeployments := []*kapi.ReplicationController{}, []*kapi.ReplicationController{}
for _, deployment := range deploymentItems {
status := deployment.Annotations[deployapi.DeploymentStatusAnnotation]
if deploymentCompleteStatusFilterSet.Has(status) {
completedDeployments = append(completedDeployments, deployment)
} else if deploymentFailedStatusFilterSet.Has(status) {
failedDeployments = append(failedDeployments, deployment)
}
}
sort.Sort(sortableReplicationControllers(completedDeployments))
sort.Sort(sortableReplicationControllers(failedDeployments))
purgeCompleted := []*kapi.ReplicationController{}
purgeFailed := []*kapi.ReplicationController{}
if keep >= 0 && keep < len(completedDeployments) {
purgeCompleted = completedDeployments[keep:]
}
if keep >= 0 && keep < len(failedDeployments) {
purgeFailed = failedDeployments[keep:]
}
for _, deployment := range purgeCompleted {
expectedNames.Insert(deployment.Name)
}
for _, deployment := range purgeFailed {
expectedNames.Insert(deployment.Name)
}
}
resolver := NewPerDeploymentConfigResolver(dataSet, keep, keep)
results, err := resolver.Resolve()
if err != nil {
t.Errorf("Unexpected error %v", err)
}
foundNames := util.StringSet{}
for _, result := range results {
foundNames.Insert(result.Name)
}
if len(foundNames) != len(expectedNames) || !expectedNames.HasAll(foundNames.List()...) {
expectedValues := expectedNames.List()
actualValues := foundNames.List()
sort.Strings(expectedValues)
sort.Strings(actualValues)
t.Errorf("keep %v\n, expected \n\t%v\n, actual \n\t%v\n", keep, expectedValues, actualValues)
}
}
}
// Test public interface
func doTestStore(t *testing.T, store Store) {
mkObj := func(id string, val string) testStoreObject {
return testStoreObject{id: id, val: val}
}
store.Add(mkObj("foo", "bar"))
if item, ok, _ := store.Get(mkObj("foo", "")); !ok {
t.Errorf("didn't find inserted item")
} else {
if e, a := "bar", item.(testStoreObject).val; e != a {
t.Errorf("expected %v, got %v", e, a)
}
}
store.Update(mkObj("foo", "baz"))
if item, ok, _ := store.Get(mkObj("foo", "")); !ok {
t.Errorf("didn't find inserted item")
} else {
if e, a := "baz", item.(testStoreObject).val; e != a {
t.Errorf("expected %v, got %v", e, a)
}
}
store.Delete(mkObj("foo", ""))
if _, ok, _ := store.Get(mkObj("foo", "")); ok {
t.Errorf("found deleted item??")
}
// Test List.
store.Add(mkObj("a", "b"))
store.Add(mkObj("c", "d"))
store.Add(mkObj("e", "e"))
{
found := util.StringSet{}
for _, item := range store.List() {
found.Insert(item.(testStoreObject).val)
}
if !found.HasAll("b", "d", "e") {
t.Errorf("missing items, found: %v", found)
}
if len(found) != 3 {
t.Errorf("extra items")
}
}
// Test Replace.
store.Replace([]interface{}{
mkObj("foo", "foo"),
mkObj("bar", "bar"),
})
{
found := util.StringSet{}
for _, item := range store.List() {
found.Insert(item.(testStoreObject).val)
}
if !found.HasAll("foo", "bar") {
t.Errorf("missing items")
}
if len(found) != 2 {
t.Errorf("extra items")
}
}
}
func TestPerBuildConfigResolver(t *testing.T) {
buildStatusOptions := []buildapi.BuildStatus{
buildapi.BuildStatusCancelled,
buildapi.BuildStatusComplete,
buildapi.BuildStatusError,
buildapi.BuildStatusFailed,
buildapi.BuildStatusNew,
buildapi.BuildStatusPending,
buildapi.BuildStatusRunning,
}
buildConfigs := []*buildapi.BuildConfig{
mockBuildConfig("a", "build-config-1"),
mockBuildConfig("b", "build-config-2"),
}
buildsPerStatus := 100
builds := []*buildapi.Build{}
for _, buildConfig := range buildConfigs {
for _, buildStatusOption := range buildStatusOptions {
for i := 0; i < buildsPerStatus; i++ {
build := withStatus(mockBuild(buildConfig.Namespace, fmt.Sprintf("%v-%v-%v", buildConfig.Name, buildStatusOption, i), buildConfig), buildStatusOption)
builds = append(builds, build)
}
}
}
now := util.Now()
for i := range builds {
creationTimestamp := util.NewTime(now.Time.Add(-1 * time.Duration(i) * time.Hour))
builds[i].CreationTimestamp = creationTimestamp
}
// test number to keep at varying ranges
for keep := 0; keep < buildsPerStatus*2; keep++ {
dataSet := NewDataSet(buildConfigs, builds)
expectedNames := util.StringSet{}
buildCompleteStatusFilterSet := util.NewStringSet(string(buildapi.BuildStatusComplete))
buildFailedStatusFilterSet := util.NewStringSet(string(buildapi.BuildStatusCancelled), string(buildapi.BuildStatusError), string(buildapi.BuildStatusFailed))
for _, buildConfig := range buildConfigs {
buildItems, err := dataSet.ListBuildsByBuildConfig(buildConfig)
if err != nil {
t.Errorf("Unexpected err %v", err)
}
completedBuilds, failedBuilds := []*buildapi.Build{}, []*buildapi.Build{}
for _, build := range buildItems {
if buildCompleteStatusFilterSet.Has(string(build.Status)) {
completedBuilds = append(completedBuilds, build)
} else if buildFailedStatusFilterSet.Has(string(build.Status)) {
failedBuilds = append(failedBuilds, build)
}
}
sort.Sort(sortableBuilds(completedBuilds))
sort.Sort(sortableBuilds(failedBuilds))
purgeCompleted := []*buildapi.Build{}
purgeFailed := []*buildapi.Build{}
if keep >= 0 && keep < len(completedBuilds) {
purgeCompleted = completedBuilds[keep:]
}
if keep >= 0 && keep < len(failedBuilds) {
purgeFailed = failedBuilds[keep:]
}
for _, build := range purgeCompleted {
expectedNames.Insert(build.Name)
}
for _, build := range purgeFailed {
expectedNames.Insert(build.Name)
}
}
resolver := NewPerBuildConfigResolver(dataSet, keep, keep)
results, err := resolver.Resolve()
if err != nil {
t.Errorf("Unexpected error %v", err)
}
foundNames := util.StringSet{}
for _, result := range results {
foundNames.Insert(result.Name)
}
if len(foundNames) != len(expectedNames) || !expectedNames.HasAll(foundNames.List()...) {
expectedValues := expectedNames.List()
actualValues := foundNames.List()
sort.Strings(expectedValues)
sort.Strings(actualValues)
t.Errorf("keep %v\n, expected \n\t%v\n, actual \n\t%v\n", keep, expectedValues, actualValues)
}
}
}
func CheckSetEq(lhs, rhs util.StringSet) bool {
return lhs.HasAll(rhs.List()...) && rhs.HasAll(lhs.List()...)
}