func (o CreateBootstrapProjectTemplateOptions) CreateBootstrapProjectTemplate() (*templateapi.Template, error) {
template := delegated.DefaultTemplate()
template.Name = o.Name
return template, nil
}
func TestUnprivilegedNewProjectFromTemplate(t *testing.T) {
namespace := "foo"
templateName := "bar"
masterOptions, err := testserver.DefaultMasterOptions()
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
masterOptions.ProjectConfig.ProjectRequestTemplate = namespace + "/" + templateName
clusterAdminKubeConfig, err := testserver.StartConfiguredMaster(masterOptions)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
clusterAdminClientConfig, err := testutil.GetClusterAdminClientConfig(clusterAdminKubeConfig)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
clusterAdminClient, err := testutil.GetClusterAdminClient(clusterAdminKubeConfig)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
valerieClientConfig := *clusterAdminClientConfig
valerieClientConfig.Username = ""
valerieClientConfig.Password = ""
valerieClientConfig.BearerToken = ""
valerieClientConfig.CertFile = ""
valerieClientConfig.KeyFile = ""
valerieClientConfig.CertData = nil
valerieClientConfig.KeyData = nil
accessToken, err := tokencmd.RequestToken(&valerieClientConfig, nil, "valerie", "security!")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
valerieClientConfig.BearerToken = accessToken
valerieOpenshiftClient, err := client.New(&valerieClientConfig)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if _, err := clusterAdminClient.Projects().Create(&projectapi.Project{ObjectMeta: kapi.ObjectMeta{Name: namespace}}); err != nil {
t.Fatalf("unexpected error: %v", err)
}
template := projectrequeststorage.DefaultTemplate()
template.Name = templateName
template.Namespace = namespace
template.Objects[0].(*projectapi.Project).Annotations["extra"] = "here"
_, err = clusterAdminClient.Templates(namespace).Create(template)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
requestProject := oc.NewProjectOptions{
ProjectName: "new-project",
DisplayName: "display name here",
Description: "the special description",
Client: valerieOpenshiftClient,
Out: ioutil.Discard,
}
if err := requestProject.Run(); err != nil {
t.Fatalf("unexpected error: %v", err)
}
waitForProject(t, valerieOpenshiftClient, "new-project", 5*time.Second, 10)
project, err := valerieOpenshiftClient.Projects().Get("new-project")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if project.Annotations["extra"] != "here" {
t.Errorf("unexpected project %#v", project)
}
if err := clusterAdminClient.Templates(namespace).Delete(templateName); err != nil {
t.Fatalf("unexpected error: %v", err)
}
requestProject.ProjectName = "different"
// This should fail during the template retrieve
if err := requestProject.Run(); !kapierrors.IsNotFound(err) {
t.Fatalf("expected a not found error, but got %v", err)
}
}
func TestProjectRequestError(t *testing.T) {
testutil.RequireEtcd(t)
defer testutil.DumpEtcdOnFailure(t)
const (
ns = "testns"
templateNamespace = "default"
templateName = "project-request-template"
)
masterConfig, err := testserver.DefaultMasterOptions()
if err != nil {
t.Fatalf("error creating config: %v", err)
}
masterConfig.ProjectConfig.ProjectRequestTemplate = templateNamespace + "/" + templateName
kubeConfigFile, err := testserver.StartConfiguredMaster(masterConfig)
if err != nil {
t.Fatalf("error starting server: %v", err)
}
kubeClient, err := testutil.GetClusterAdminKubeClient(kubeConfigFile)
if err != nil {
t.Fatalf("error getting client: %v", err)
}
openshiftClient, err := testutil.GetClusterAdminClient(kubeConfigFile)
if err != nil {
t.Fatalf("error getting openshift client: %v", err)
}
// Create custom template
template := delegated.DefaultTemplate()
template.Name = templateName
additionalObjects := []runtime.Object{
// Append an object that will succeed
&kapi.ConfigMap{ObjectMeta: kapi.ObjectMeta{Name: "configmapname"}},
// Append a custom object that will fail validation
&kapi.ConfigMap{},
// Append another object that should never be created, since we short circuit
&kapi.ConfigMap{ObjectMeta: kapi.ObjectMeta{Name: "configmapname2"}},
}
if err := templateapi.AddObjectsToTemplate(template, additionalObjects, kapiv1.SchemeGroupVersion); err != nil {
t.Fatal(err)
}
if _, err := openshiftClient.Templates(templateNamespace).Create(template); err != nil {
t.Fatal(err)
}
// Watch the project, rolebindings, and configmaps
nswatch, err := kubeClient.Namespaces().Watch(kapi.ListOptions{FieldSelector: fields.OneTermEqualSelector("metadata.name", ns)})
if err != nil {
t.Fatal(err)
}
policywatch, err := openshiftClient.PolicyBindings(ns).Watch(kapi.ListOptions{})
if err != nil {
t.Fatal(err)
}
cmwatch, err := kubeClient.ConfigMaps(ns).Watch(kapi.ListOptions{})
if err != nil {
t.Fatal(err)
}
// Create project request
_, err = openshiftClient.ProjectRequests().Create(&projectapi.ProjectRequest{ObjectMeta: kapi.ObjectMeta{Name: ns}})
if err == nil || err.Error() != `Internal error occurred: ConfigMap "" is invalid: metadata.name: Required value: name or generateName is required` {
t.Fatalf("Expected internal error creating project, got %v", err)
}
pairCreationDeletion := func(w watch.Interface) (int, int, []watch.Event) {
added := 0
deleted := 0
events := []watch.Event{}
for {
select {
case e := <-w.ResultChan():
events = append(events, e)
switch e.Type {
case watch.Added:
added++
case watch.Deleted:
deleted++
}
case <-time.After(10 * time.Second):
return added, deleted, events
}
if added == deleted && added > 0 {
return added, deleted, events
}
}
}
if added, deleted, events := pairCreationDeletion(nswatch); added != deleted || added != 1 {
for _, e := range events {
t.Logf("%s %#v", e.Type, e.Object)
}
t.Errorf("expected 1 namespace to be added and deleted, got %d added / %d deleted", added, deleted)
}
if added, deleted, events := pairCreationDeletion(policywatch); added != deleted || added != 1 {
for _, e := range events {
t.Logf("%s %#v", e.Type, e.Object)
}
t.Errorf("expected 1 policybinding to be added and deleted, got %d added / %d deleted", added, deleted)
}
if added, deleted, events := pairCreationDeletion(cmwatch); added != deleted || added != 1 {
for _, e := range events {
t.Logf("%s %#v", e.Type, e.Object)
}
t.Errorf("expected 1 configmap to be added and deleted, got %d added / %d deleted", added, deleted)
}
// Verify project is deleted
if nsObj, err := kubeClient.Namespaces().Get(ns); !kapierrors.IsNotFound(err) {
t.Errorf("Expected namespace to be gone, got %#v, %#v", nsObj, err)
}
}