// TestPushSecretName exercises one of the complex Build scenarios, where you
// first build a Docker image using Docker build strategy, which will later by
// consumed by Custom build strategy to verify that the 'PushSecretName' (Docker
// credentials) were successfully transported to the builder. The content of the
// Secret file is verified in the end.
func TestPushSecretName(t *testing.T) {
namespace := testutil.RandomNamespace("secret")
client, _ := testutil.GetClusterAdminClient(testutil.KubeConfigPath())
kclient, _ := testutil.GetClusterAdminKubeClient(testutil.KubeConfigPath())
stream := testutil.CreateSampleImageStream(namespace)
if stream == nil {
t.Fatal("Failed to create ImageStream")
}
defer testutil.DeleteSampleImageStream(stream, namespace)
// Create Secret with dockercfg
secret := testutil.GetSecretFixture("fixtures/test-secret.json")
// TODO: Why do I need to set namespace here?
secret.Namespace = namespace
_, err := kclient.Secrets(namespace).Create(secret)
if err != nil {
t.Fatalf("Failed to create Secret: %v", err)
}
watcher, err := client.Builds(namespace).Watch(labels.Everything(), fields.Everything(), "0")
if err != nil {
t.Fatalf("Failed to create watcher: %v", err)
}
defer watcher.Stop()
// First build the builder image (custom build builder)
dockerBuild := testutil.GetBuildFixture("fixtures/test-secret-build.json")
newDockerBuild, err := client.Builds(namespace).Create(dockerBuild)
if err != nil {
t.Fatalf("Unable to create Build %s: %v", dockerBuild.Name, err)
}
waitForComplete(newDockerBuild, watcher, t)
// Now build the application image using custom build (run the previous image)
// Custom build will copy the dockercfg file into the application image.
customBuild := testutil.GetBuildFixture("fixtures/test-custom-build.json")
imageName := fmt.Sprintf("%s/%s/%s", os.Getenv("REGISTRY_ADDR"), namespace, stream.Name)
customBuild.Parameters.Strategy.CustomStrategy.Image = imageName
newCustomBuild, err := client.Builds(namespace).Create(customBuild)
if err != nil {
t.Fatalf("Unable to create Build %s: %v", dockerBuild.Name, err)
}
waitForComplete(newCustomBuild, watcher, t)
// Verify that the dockercfg file is there
if err := testutil.VerifyImage(stream, "application", namespace, validatePushSecret); err != nil {
t.Fatalf("Image verification failed: %v", err)
}
}
// RequireServer verifies if the etcd, docker and the OpenShift server are
// available and you can successfully connected to them.
func RequireServer() {
util.RequireEtcd()
util.RequireDocker()
if _, err := util.GetClusterAdminClient(util.KubeConfigPath()); err != nil {
os.Exit(1)
}
}
func StartConfiguredMasterWithOptions(masterConfig *configapi.MasterConfig, testOptions TestOptions) (string, error) {
if testOptions.DeleteAllEtcdKeys {
util.DeleteAllEtcdKeys()
}
if err := start.NewMaster(masterConfig, true, true).Start(); err != nil {
return "", err
}
adminKubeConfigFile := util.KubeConfigPath()
clientConfig, err := util.GetClusterAdminClientConfig(adminKubeConfigFile)
if err != nil {
return "", err
}
masterURL, err := url.Parse(clientConfig.Host)
if err != nil {
return "", err
}
// wait for the server to come up: 35 seconds
if err := cmdutil.WaitForSuccessfulDial(true, "tcp", masterURL.Host, 100*time.Millisecond, 1*time.Second, 35); err != nil {
return "", err
}
for {
// confirm that we can actually query from the api server
if client, err := util.GetClusterAdminClient(adminKubeConfigFile); err == nil {
if _, err := client.ClusterPolicies().List(labels.Everything(), fields.Everything()); err == nil {
break
}
}
time.Sleep(100 * time.Millisecond)
}
return adminKubeConfigFile, nil
}
// TestSTIEnvironmentBuild exercises the scenario where you have .sti/environment
// file in your source code repository and you use STI build strategy. In that
// case the STI build should read that file and set all environment variables
// from that file to output image.
func TestSTIEnvironmentBuild(t *testing.T) {
namespace := testutil.RandomNamespace("stienv")
fmt.Printf("Using '%s' namespace\n", namespace)
build := testutil.GetBuildFixture("fixtures/test-env-build.json")
client, _ := testutil.GetClusterAdminClient(testutil.KubeConfigPath())
stream := testutil.CreateSampleImageStream(namespace)
if stream == nil {
t.Fatal("Failed to create ImageStream")
}
defer testutil.DeleteSampleImageStream(stream, namespace)
// TODO: Tweak the selector to match the build name
watcher, err := client.Builds(namespace).Watch(labels.Everything(), fields.Everything(), "0")
if err != nil {
t.Fatalf("Failed to create watcher: %v", err)
}
defer watcher.Stop()
newBuild, err := client.Builds(namespace).Create(build)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
waitForComplete(newBuild, watcher, t)
if err := testutil.VerifyImage(stream, "", namespace, validateSTIEnvironment); err != nil {
t.Fatalf("The build image failed validation: %v", err)
}
}
// RequireServer verifies if the etcd and the OpenShift server are
// available and you can successfully connect to them.
func RequireServer(t *testing.T) {
util.RequireEtcd(t)
if _, err := util.GetClusterAdminClient(util.KubeConfigPath()); err != nil {
os.Exit(1)
}
}